diff --git a/src/os/inc/common_types.h b/src/os/inc/common_types.h
index 64c8c9a8d..f868a3d34 100644
--- a/src/os/inc/common_types.h
+++ b/src/os/inc/common_types.h
@@ -96,6 +96,11 @@
   typedef size_t                                cpusize;
   typedef ptrdiff_t                             cpudiff;
 
+  /**
+   * A type to be used for OSAL resource identifiers.
+   */
+  typedef uint32_t                              osal_id_t;
+
 
 
 #ifndef NULL              /* pointer to nothing */
diff --git a/src/os/inc/osapi-os-core.h b/src/os/inc/osapi-os-core.h
index 40da37028..0a0337223 100644
--- a/src/os/inc/osapi-os-core.h
+++ b/src/os/inc/osapi-os-core.h
@@ -58,11 +58,16 @@
 /** @brief Upper limit for OSAL task priorities */
 #define OS_MAX_TASK_PRIORITY        255
 
+/**
+ * @brief Initializer for the osal_id_t type which will not match any valid value
+ */
+#define OS_OBJECT_ID_UNDEFINED      ((osal_id_t){0})
+
 /**
  * @brief Constant that may be passed to OS_ForEachObject()/OS_ForEachObjectOfType() to match any
  * creator (i.e. get all objects)
  */
-#define OS_OBJECT_CREATOR_ANY       0
+#define OS_OBJECT_CREATOR_ANY       OS_OBJECT_ID_UNDEFINED
 
 
 /** @defgroup OSSemaphoreStates OSAL Semaphore State Defines
@@ -82,13 +87,14 @@
  */
 #define OS_ERROR_NAME_LENGTH     35
 
+
 /*  Object property structures */
 
 /** @brief OSAL task properties */
 typedef struct
 {
     char name [OS_MAX_API_NAME];
-    uint32 creator;
+    osal_id_t creator;
     uint32 stack_size;
     uint32 priority;
 }OS_task_prop_t;
@@ -97,14 +103,14 @@ typedef struct
 typedef struct
 {
     char name [OS_MAX_API_NAME];
-    uint32 creator;
+    osal_id_t creator;
 }OS_queue_prop_t;
 
 /** @brief OSAL binary semaphore properties */
 typedef struct
 {                     
     char name [OS_MAX_API_NAME];
-    uint32 creator;
+    osal_id_t creator;
     int32  value;
 }OS_bin_sem_prop_t;
 
@@ -112,7 +118,7 @@ typedef struct
 typedef struct
 {                     
     char name [OS_MAX_API_NAME];
-    uint32 creator;
+    osal_id_t creator;
     int32 value;
 }OS_count_sem_prop_t;
 
@@ -120,7 +126,7 @@ typedef struct
 typedef struct
 {
     char name [OS_MAX_API_NAME];
-    uint32 creator;
+    osal_id_t creator;
 }OS_mut_sem_prop_t;
 
 
@@ -193,7 +199,7 @@ typedef osal_task ((*osal_task_entry)(void)); /**< @brief For task entry point *
  *
  * This may be used by multiple APIS
  */
-typedef void (*OS_ArgCallback_t)(uint32 object_id, void *arg);
+typedef void (*OS_ArgCallback_t)(osal_id_t object_id, void *arg);
 
 /** @defgroup OSAPICore OSAL Core Operation APIs
  *
@@ -293,6 +299,81 @@ void OS_ApplicationExit(int32 Status);
  * @{
  */
 
+/*-------------------------------------------------------------------------------------*/
+/**
+ * @brief Obtain an integer value corresponding to an object ID
+ *
+ * Obtains an integer representation of an object id, generally
+ * for the purpose of printing to the console or system logs.
+ *
+ * The returned value is of the type "unsigned long" for direct use with
+ * printf-style functions. It is recommended to use the "%lx" conversion
+ * specifier as the hexidecimal encoding clearly delineates the internal fields.
+ *
+ * @note This provides the raw integer value and is _not_ suitable for use
+ * as an array index, as the result is not zero-based.  See the
+ * OS_ConvertToArrayIndex() to obtain a zero-based index value.
+ *
+ * @param[in]   object_id The object ID
+ * @returns     integer value representation of object ID
+ */
+static inline unsigned long OS_ObjectIdToInteger(osal_id_t object_id)
+{
+    return object_id;
+}
+
+/*-------------------------------------------------------------------------------------*/
+/**
+ * @brief Obtain an osal ID corresponding to an integer value
+ *
+ * Provides the inverse of OS_ObjectIdToInteger().  Reconstitutes the original
+ * osal_id_t type from an integer representation.
+ *
+ * @param[in]   value   The integer representation of an OSAL ID
+ * @returns     The ID value converted to an osal_id_t
+ */
+static inline osal_id_t OS_ObjectIdFromInteger(unsigned long value)
+{
+    return value;
+}
+
+/*-------------------------------------------------------------------------------------*/
+/**
+ * @brief Check two OSAL object ID values for equality
+ *
+ * The OSAL ID values should be treated as abstract values by applications, and not
+ * directly manipulated using standard C operators.
+ *
+ * This checks two values for equality, replacing the "==" operator.
+ *
+ * @param[in]   object_id1 The first object ID
+ * @param[in]   object_id2 The second object ID
+ * @returns     true if the object IDs are equal
+ */
+static inline bool OS_ObjectIdEqual(osal_id_t object_id1, osal_id_t object_id2)
+{
+    return (object_id1 == object_id2);
+}
+
+/*-------------------------------------------------------------------------------------*/
+/**
+ * @brief Check if an object ID is defined.
+ *
+ * The OSAL ID values should be treated as abstract values by applications, and not
+ * directly manipulated using standard C operators.
+ *
+ * This returns false if the ID is NOT a defined resource (i.e. free/empty/invalid).
+ *
+ * @note OS_ObjectIdDefined(OS_OBJECT_ID_UNDEFINED) is always guaranteed to be false.
+ *
+ * @param[in]   object_id The first object ID
+ */
+static inline bool OS_ObjectIdDefined(osal_id_t object_id)
+{
+    return (object_id != 0);
+}
+
+
 /*-------------------------------------------------------------------------------------*/
 /**
  * @brief Obtain the name of an object given an arbitrary object ID
@@ -309,7 +390,7 @@ void OS_ApplicationExit(int32 Status);
  *          #OS_INVALID_POINTER if the passed-in buffer is invalid
  *          #OS_ERR_NAME_TOO_LONG if the name will not fit in the buffer provided
  */
-int32 OS_GetResourceName(uint32 object_id, char *buffer, uint32 buffer_size);
+int32 OS_GetResourceName(osal_id_t object_id, char *buffer, uint32 buffer_size);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -322,7 +403,7 @@ int32 OS_GetResourceName(uint32 object_id, char *buffer, uint32 buffer_size);
  * @return The object type portion of the object_id, see @ref OSObjectTypes for
  *         expected values
  */
-uint32 OS_IdentifyObject       (uint32 object_id);
+uint32 OS_IdentifyObject       (osal_id_t object_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -342,7 +423,7 @@ uint32 OS_IdentifyObject       (uint32 object_id);
  * @retval #OS_SUCCESS                 @copybrief OS_SUCCESS
  * @retval #OS_ERR_INCORRECT_OBJ_TYPE  @copybrief OS_ERR_INCORRECT_OBJ_TYPE
  */
-int32 OS_ConvertToArrayIndex   (uint32 object_id, uint32 *ArrayIndex);
+int32 OS_ConvertToArrayIndex   (osal_id_t object_id, uint32 *ArrayIndex);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -356,8 +437,7 @@ int32 OS_ConvertToArrayIndex   (uint32 object_id, uint32 *ArrayIndex);
  * @param[in]  callback_ptr Function to invoke for each matching object ID
  * @param[in]  callback_arg Opaque Argument to pass to callback function
  */
-void OS_ForEachObject           (uint32 creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg);
-/**@}*/
+void OS_ForEachObject           (osal_id_t creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -372,7 +452,8 @@ void OS_ForEachObject           (uint32 creator_id, OS_ArgCallback_t callback_pt
  * @param[in]  callback_ptr Function to invoke for each matching object ID
  * @param[in]  callback_arg Opaque Argument to pass to callback function
   */
-void OS_ForEachObjectOfType     (uint32 objtype, uint32 creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg);
+void OS_ForEachObjectOfType     (uint32 objtype, osal_id_t creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg);
+/**@}*/
 
 
 /** @defgroup OSAPITask OSAL Task APIs
@@ -404,7 +485,7 @@ void OS_ForEachObjectOfType     (uint32 objtype, uint32 creator_id, OS_ArgCallba
  * @retval #OS_ERR_NAME_TAKEN if the name specified is already used by a task
  * @retval #OS_ERROR if an unspecified/other error occurs
  */
-int32 OS_TaskCreate            (uint32 *task_id, const char *task_name, 
+int32 OS_TaskCreate            (osal_id_t *task_id, const char *task_name,
                                 osal_task_entry function_pointer,
                                 uint32 *stack_pointer,
                                 uint32 stack_size,
@@ -424,7 +505,7 @@ int32 OS_TaskCreate            (uint32 *task_id, const char *task_name,
  * @retval #OS_ERR_INVALID_ID if the ID given to it is invalid
  * @retval #OS_ERROR if the OS delete call fails
  */
-int32 OS_TaskDelete            (uint32 task_id); 
+int32 OS_TaskDelete            (osal_id_t task_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -477,7 +558,7 @@ int32 OS_TaskDelay             (uint32 millisecond);
  * @retval #OS_ERR_INVALID_PRIORITY if the priority is greater than the max allowed
  * @retval #OS_ERROR if the OS call to change the priority fails
  */
-int32 OS_TaskSetPriority       (uint32 task_id, uint32 new_priority);
+int32 OS_TaskSetPriority       (osal_id_t task_id, uint32 new_priority);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -499,7 +580,7 @@ int32 OS_TaskRegister          (void);
  *
  * @return Task ID, or zero if the operation failed (zero is never a valid task ID)
  */
-uint32 OS_TaskGetId            (void);
+osal_id_t OS_TaskGetId            (void);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -516,7 +597,7 @@ uint32 OS_TaskGetId            (void);
  * @retval #OS_ERR_NAME_TOO_LONG name length including null terminator greater than #OS_MAX_API_NAME
  * @retval #OS_ERR_NAME_NOT_FOUND if the name wasn't found in the table
  */
-int32 OS_TaskGetIdByName       (uint32 *task_id, const char *task_name);
+int32 OS_TaskGetIdByName       (osal_id_t *task_id, const char *task_name);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -534,7 +615,7 @@ int32 OS_TaskGetIdByName       (uint32 *task_id, const char *task_name);
  * @retval #OS_ERR_INVALID_ID if the ID passed to it is invalid
  * @retval #OS_INVALID_POINTER if the task_prop pointer is NULL
  */
-int32 OS_TaskGetInfo           (uint32 task_id, OS_task_prop_t *task_prop);          
+int32 OS_TaskGetInfo           (osal_id_t task_id, OS_task_prop_t *task_prop);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -555,7 +636,7 @@ int32 OS_TaskGetInfo           (uint32 task_id, OS_task_prop_t *task_prop);
  * @return Execution status, see @ref OSReturnCodes
  * @retval #OS_SUCCESS @copybrief OS_SUCCESS
  */
-int32 OS_TaskFindIdBySystemData(uint32 *task_id, const void *sysdata, size_t sysdata_size);
+int32 OS_TaskFindIdBySystemData(osal_id_t *task_id, const void *sysdata, size_t sysdata_size);
 
 
 /**@}*/
@@ -589,7 +670,7 @@ int32 OS_TaskFindIdBySystemData(uint32 *task_id, const void *sysdata, size_t sys
  * @retval #OS_QUEUE_INVALID_SIZE if the queue depth exceeds the limit
  * @retval #OS_ERROR if the OS create call fails
  */
-int32 OS_QueueCreate           (uint32 *queue_id, const char *queue_name,
+int32 OS_QueueCreate           (osal_id_t *queue_id, const char *queue_name,
                                 uint32 queue_depth, uint32 data_size, uint32 flags);
 
 /*-------------------------------------------------------------------------------------*/
@@ -609,7 +690,7 @@ int32 OS_QueueCreate           (uint32 *queue_id, const char *queue_name,
  * @retval #OS_ERR_INVALID_ID if the id passed in does not exist
  * @retval #OS_ERROR if the OS call to delete the queue fails
  */
-int32 OS_QueueDelete           (uint32 queue_id);
+int32 OS_QueueDelete           (osal_id_t queue_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -632,7 +713,7 @@ int32 OS_QueueDelete           (uint32 queue_id);
  * @retval #OS_QUEUE_TIMEOUT if the timeout was OS_PEND and the time expired
  * @retval #OS_QUEUE_INVALID_SIZE if the size copied from the queue was not correct
  */
-int32 OS_QueueGet              (uint32 queue_id, void *data, uint32 size, 
+int32 OS_QueueGet              (osal_id_t queue_id, void *data, uint32 size,
                                 uint32 *size_copied, int32 timeout);
 
 /*-------------------------------------------------------------------------------------*/
@@ -651,7 +732,7 @@ int32 OS_QueueGet              (uint32 queue_id, void *data, uint32 size,
  * @retval #OS_QUEUE_FULL if the queue cannot accept another message
  * @retval #OS_ERROR if the OS call returns an error
  */
-int32 OS_QueuePut              (uint32 queue_id, const void *data, uint32 size,
+int32 OS_QueuePut              (osal_id_t queue_id, const void *data, uint32 size,
                                 uint32 flags);
 
 /*-------------------------------------------------------------------------------------*/
@@ -670,7 +751,7 @@ int32 OS_QueuePut              (uint32 queue_id, const void *data, uint32 size,
  * @retval #OS_ERR_NAME_TOO_LONG name length including null terminator greater than #OS_MAX_API_NAME
  * @retval #OS_ERR_NAME_NOT_FOUND the name was not found in the table
  */
-int32 OS_QueueGetIdByName      (uint32 *queue_id, const char *queue_name);
+int32 OS_QueueGetIdByName      (osal_id_t *queue_id, const char *queue_name);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -687,7 +768,7 @@ int32 OS_QueueGetIdByName      (uint32 *queue_id, const char *queue_name);
  * @retval #OS_INVALID_POINTER if queue_prop is NULL
  * @retval #OS_ERR_INVALID_ID if the ID given is not  a valid queue
  */
-int32 OS_QueueGetInfo          (uint32 queue_id, OS_queue_prop_t *queue_prop);
+int32 OS_QueueGetInfo          (osal_id_t queue_id, OS_queue_prop_t *queue_prop);
 /**@}*/
 
 /** @defgroup OSAPISem OSAL Semaphore APIs
@@ -715,7 +796,7 @@ int32 OS_QueueGetInfo          (uint32 queue_id, OS_queue_prop_t *queue_prop);
  * @retval #OS_ERR_NAME_TAKEN if this is already the name of a binary semaphore
  * @retval #OS_SEM_FAILURE if the OS call failed
  */
-int32 OS_BinSemCreate          (uint32 *sem_id, const char *sem_name, 
+int32 OS_BinSemCreate          (osal_id_t *sem_id, const char *sem_name,
                                 uint32 sem_initial_value, uint32 options);
 
 /*-------------------------------------------------------------------------------------*/
@@ -732,7 +813,7 @@ int32 OS_BinSemCreate          (uint32 *sem_id, const char *sem_name,
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a binary semaphore
  * @retval #OS_SEM_FAILURE if an unspecified failure occurs
  */
-int32 OS_BinSemFlush            (uint32 sem_id);
+int32 OS_BinSemFlush            (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -752,7 +833,7 @@ int32 OS_BinSemFlush            (uint32 sem_id);
  * in the array of semaphores defined by the system
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a binary semaphore
  */
-int32 OS_BinSemGive            (uint32 sem_id);
+int32 OS_BinSemGive            (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -771,7 +852,7 @@ int32 OS_BinSemGive            (uint32 sem_id);
  * @retval #OS_ERR_INVALID_ID the Id passed in is not a valid binary semaphore
  * @retval #OS_SEM_FAILURE if the OS call failed
  */
-int32 OS_BinSemTake            (uint32 sem_id);
+int32 OS_BinSemTake            (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -792,7 +873,7 @@ int32 OS_BinSemTake            (uint32 sem_id);
  * in the array of semaphores defined by the system
  * @retval #OS_ERR_INVALID_ID if the ID passed in is not a valid semaphore ID
  */
-int32 OS_BinSemTimedWait       (uint32 sem_id, uint32 msecs);
+int32 OS_BinSemTimedWait       (osal_id_t sem_id, uint32 msecs);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -808,7 +889,7 @@ int32 OS_BinSemTimedWait       (uint32 sem_id, uint32 msecs);
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid binary semaphore
  * @retval #OS_SEM_FAILURE the OS call failed
  */
-int32 OS_BinSemDelete          (uint32 sem_id);
+int32 OS_BinSemDelete          (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -826,7 +907,7 @@ int32 OS_BinSemDelete          (uint32 sem_id);
  * @retval #OS_ERR_NAME_TOO_LONG name length including null terminator greater than #OS_MAX_API_NAME
  * @retval #OS_ERR_NAME_NOT_FOUND if the name was not found in the table
  */
-int32 OS_BinSemGetIdByName     (uint32 *sem_id, const char *sem_name);
+int32 OS_BinSemGetIdByName     (osal_id_t *sem_id, const char *sem_name);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -844,7 +925,7 @@ int32 OS_BinSemGetIdByName     (uint32 *sem_id, const char *sem_name);
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid semaphore
  * @retval #OS_INVALID_POINTER if the bin_prop pointer is null
  */
-int32 OS_BinSemGetInfo         (uint32 sem_id, OS_bin_sem_prop_t *bin_prop);
+int32 OS_BinSemGetInfo         (osal_id_t sem_id, OS_bin_sem_prop_t *bin_prop);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -868,7 +949,7 @@ int32 OS_BinSemGetInfo         (uint32 sem_id, OS_bin_sem_prop_t *bin_prop);
  * @retval #OS_SEM_FAILURE if the OS call failed
  * @retval #OS_INVALID_SEM_VALUE if the semaphore value is too high
  */
-int32 OS_CountSemCreate          (uint32 *sem_id, const char *sem_name, 
+int32 OS_CountSemCreate          (osal_id_t *sem_id, const char *sem_name,
                                 uint32 sem_initial_value, uint32 options);
 
 /*-------------------------------------------------------------------------------------*/
@@ -889,7 +970,7 @@ int32 OS_CountSemCreate          (uint32 *sem_id, const char *sem_name,
  * in the array of semaphores defined by the system
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a counting semaphore
  */
-int32 OS_CountSemGive            (uint32 sem_id);
+int32 OS_CountSemGive            (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -908,7 +989,7 @@ int32 OS_CountSemGive            (uint32 sem_id);
  * @retval #OS_ERR_INVALID_ID the Id passed in is not a valid counting semaphore
  * @retval #OS_SEM_FAILURE if the OS call failed
  */
-int32 OS_CountSemTake            (uint32 sem_id);
+int32 OS_CountSemTake            (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -929,7 +1010,7 @@ int32 OS_CountSemTake            (uint32 sem_id);
  * in the array of semaphores defined by the system
  * @retval #OS_ERR_INVALID_ID if the ID passed in is not a valid semaphore ID
  */
-int32 OS_CountSemTimedWait       (uint32 sem_id, uint32 msecs);
+int32 OS_CountSemTimedWait       (osal_id_t sem_id, uint32 msecs);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -942,7 +1023,7 @@ int32 OS_CountSemTimedWait       (uint32 sem_id, uint32 msecs);
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid counting semaphore
  * @retval #OS_SEM_FAILURE the OS call failed
  */
-int32 OS_CountSemDelete          (uint32 sem_id);
+int32 OS_CountSemDelete          (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -960,7 +1041,7 @@ int32 OS_CountSemDelete          (uint32 sem_id);
  * @retval #OS_ERR_NAME_TOO_LONG name length including null terminator greater than #OS_MAX_API_NAME
  * @retval #OS_ERR_NAME_NOT_FOUND if the name was not found in the table
  */
-int32 OS_CountSemGetIdByName     (uint32 *sem_id, const char *sem_name);
+int32 OS_CountSemGetIdByName     (osal_id_t *sem_id, const char *sem_name);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -978,7 +1059,7 @@ int32 OS_CountSemGetIdByName     (uint32 *sem_id, const char *sem_name);
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid semaphore
  * @retval #OS_INVALID_POINTER if the count_prop pointer is null
  */
-int32 OS_CountSemGetInfo         (uint32 sem_id, OS_count_sem_prop_t *count_prop);
+int32 OS_CountSemGetInfo         (osal_id_t sem_id, OS_count_sem_prop_t *count_prop);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -998,7 +1079,7 @@ int32 OS_CountSemGetInfo         (uint32 sem_id, OS_count_sem_prop_t *count_prop
  * @retval #OS_ERR_NAME_TAKEN if there is already a mutex with the same name
  * @retval #OS_SEM_FAILURE if the OS call failed
  */
-int32 OS_MutSemCreate           (uint32 *sem_id, const char *sem_name, uint32 options);
+int32 OS_MutSemCreate           (osal_id_t *sem_id, const char *sem_name, uint32 options);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -1016,7 +1097,7 @@ int32 OS_MutSemCreate           (uint32 *sem_id, const char *sem_name, uint32 op
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid mutex
  * @retval #OS_SEM_FAILURE if an unspecified error occurs
  */
-int32 OS_MutSemGive             (uint32 sem_id);
+int32 OS_MutSemGive             (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -1035,7 +1116,7 @@ int32 OS_MutSemGive             (uint32 sem_id);
  * not in the array of semaphores defined by the system
  * @retval #OS_ERR_INVALID_ID the id passed in is not a valid mutex
  */
-int32 OS_MutSemTake             (uint32 sem_id);
+int32 OS_MutSemTake             (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -1051,7 +1132,7 @@ int32 OS_MutSemTake             (uint32 sem_id);
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid mutex
  * @retval #OS_SEM_FAILURE if the OS call failed
  */
-int32 OS_MutSemDelete           (uint32 sem_id);  
+int32 OS_MutSemDelete           (osal_id_t sem_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -1069,7 +1150,7 @@ int32 OS_MutSemDelete           (uint32 sem_id);
  * @retval #OS_ERR_NAME_TOO_LONG name length including null terminator greater than #OS_MAX_API_NAME
  * @retval #OS_ERR_NAME_NOT_FOUND if the name was not found in the table
  */
-int32 OS_MutSemGetIdByName      (uint32 *sem_id, const char *sem_name); 
+int32 OS_MutSemGetIdByName      (osal_id_t *sem_id, const char *sem_name);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -1087,7 +1168,7 @@ int32 OS_MutSemGetIdByName      (uint32 *sem_id, const char *sem_name);
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid semaphore
  * @retval #OS_INVALID_POINTER if the mut_prop pointer is null
  */
-int32 OS_MutSemGetInfo          (uint32 sem_id, OS_mut_sem_prop_t *mut_prop);
+int32 OS_MutSemGetInfo          (osal_id_t sem_id, OS_mut_sem_prop_t *mut_prop);
 /**@}*/
 
 /** @defgroup OSAPITime OSAL Time/Tick APIs
@@ -1239,7 +1320,7 @@ int32 OS_SelectMultiple(OS_FdSet *ReadSet, OS_FdSet *WriteSet, int32 msecs);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_SelectSingle(uint32 objid, uint32 *StateFlags, int32 msecs);
+int32 OS_SelectSingle(osal_id_t objid, uint32 *StateFlags, int32 msecs);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -1259,7 +1340,7 @@ int32 OS_SelectFdZero(OS_FdSet *Set);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_SelectFdAdd(OS_FdSet *Set, uint32 objid);
+int32 OS_SelectFdAdd(OS_FdSet *Set, osal_id_t objid);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -1269,7 +1350,7 @@ int32 OS_SelectFdAdd(OS_FdSet *Set, uint32 objid);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_SelectFdClear(OS_FdSet *Set, uint32 objid);
+int32 OS_SelectFdClear(OS_FdSet *Set, osal_id_t objid);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -1279,7 +1360,7 @@ int32 OS_SelectFdClear(OS_FdSet *Set, uint32 objid);
  * @retval true  FdSet structure contains ID
  * @retval false FDSet structure does not contain ID
  */
-bool OS_SelectFdIsSet(OS_FdSet *Set, uint32 objid);
+bool OS_SelectFdIsSet(OS_FdSet *Set, osal_id_t objid);
 /**@}*/
 
 /** @defgroup OSAPIPrintf OSAL Printf APIs
diff --git a/src/os/inc/osapi-os-filesys.h b/src/os/inc/osapi-os-filesys.h
index 4ee3e6a87..1e5b13da1 100644
--- a/src/os/inc/osapi-os-filesys.h
+++ b/src/os/inc/osapi-os-filesys.h
@@ -98,7 +98,7 @@ typedef struct
 typedef struct
 {
     char Path[OS_MAX_PATH_LEN];
-    uint32 User;
+    osal_id_t User;
     uint8 IsValid;                /* For backward compatibility -- always true if OS_FDGetInfo returned true */
 }OS_file_prop_t;
 
@@ -215,7 +215,26 @@ int32           OS_creat  (const char *path, int32  access);
  */
 int32           OS_open   (const char *path,  int32 access,  uint32 mode);
 
+/*-------------------------------------------------------------------------------------*/
+/**
+ * @brief Open or create a file
+ *
+ * Implements the same as OS_open/OS_creat but follows the OSAL paradigm
+ * of outputting the ID/descriptor separately from the return value, rather
+ * than relying on the user to convert it back.
+ *
+ * @param[out] filedes  The handle ID
+ * @param[in] path      File name to create or open
+ * @param[in] flags     The file permissions - see @ref OS_file_flag_t
+ * @param[in] access    Intended access mode - see @ref OSFileAccess
+ *
+ * @return Execution status, see @ref OSReturnCodes
+ * @retval #OS_SUCCESS @copybrief OS_SUCCESS
+ * @retval #OS_ERROR if the command was not executed properly
+ */
+int32 OS_OpenCreate(osal_id_t *filedes, const char *path, int32 flags, int32 access);
 
+/**@}*/
 /*-------------------------------------------------------------------------------------*/
 /**
  * @brief Closes an open file handle
@@ -230,7 +249,7 @@ int32           OS_open   (const char *path,  int32 access,  uint32 mode);
  * @retval #OS_ERROR if file descriptor could not be closed
  * @retval #OS_ERR_INVALID_ID if the file descriptor passed in is invalid
  */
-int32           OS_close  (uint32  filedes);
+int32           OS_close  (osal_id_t  filedes);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -251,7 +270,7 @@ int32           OS_close  (uint32  filedes);
  * @retval #OS_ERROR if OS call failed
  * @retval #OS_ERR_INVALID_ID if the file descriptor passed in is invalid
  */
-int32           OS_read   (uint32  filedes, void *buffer, uint32 nbytes);
+int32           OS_read   (osal_id_t  filedes, void *buffer, uint32 nbytes);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -273,7 +292,7 @@ int32           OS_read   (uint32  filedes, void *buffer, uint32 nbytes);
  * @retval #OS_ERROR if OS call failed
  * @retval #OS_ERR_INVALID_ID if the file descriptor passed in is invalid
  */
-int32           OS_write  (uint32  filedes, const void *buffer, uint32 nbytes);
+int32           OS_write  (osal_id_t  filedes, const void *buffer, uint32 nbytes);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -304,7 +323,7 @@ int32           OS_write  (uint32  filedes, const void *buffer, uint32 nbytes);
  * @return Byte count on success, zero for timeout, or appropriate error code,
  *         see @ref OSReturnCodes
  */
-int32           OS_TimedRead(uint32  filedes, void *buffer, uint32 nbytes, int32 timeout);
+int32           OS_TimedRead(osal_id_t  filedes, void *buffer, uint32 nbytes, int32 timeout);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -336,7 +355,7 @@ int32           OS_TimedRead(uint32  filedes, void *buffer, uint32 nbytes, int32
  * @return Byte count on success, zero for timeout, or appropriate error code,
  *         see @ref OSReturnCodes
  */
-int32           OS_TimedWrite(uint32  filedes, const void *buffer, uint32 nbytes, int32 timeout);
+int32           OS_TimedWrite(osal_id_t  filedes, const void *buffer, uint32 nbytes, int32 timeout);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -388,7 +407,7 @@ int32           OS_stat   (const char *path, os_fstat_t  *filestats);
  * @retval #OS_ERR_INVALID_ID if the file descriptor passed in is invalid
  * @retval #OS_ERROR if OS call failed
  */
-int32           OS_lseek  (uint32  filedes, int32 offset, uint32 whence);
+int32           OS_lseek  (osal_id_t  filedes, int32 offset, uint32 whence);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -506,7 +525,7 @@ int32 OS_mv (const char *src, const char *dest);
  * @retval #OS_SUCCESS @copybrief OS_SUCCESS
  * @retval #OS_ERR_INVALID_ID if the file descriptor passed in is invalid
  */
-int32 OS_FDGetInfo (uint32 filedes, OS_file_prop_t *fd_prop);
+int32 OS_FDGetInfo (osal_id_t filedes, OS_file_prop_t *fd_prop);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -569,7 +588,7 @@ int32 OS_CloseFileByName(const char *Filename);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32           OS_DirectoryOpen(uint32 *dir_id, const char *path);
+int32           OS_DirectoryOpen(osal_id_t *dir_id, const char *path);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -582,7 +601,7 @@ int32           OS_DirectoryOpen(uint32 *dir_id, const char *path);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32           OS_DirectoryClose(uint32 dir_id);
+int32           OS_DirectoryClose(osal_id_t dir_id);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -595,7 +614,7 @@ int32           OS_DirectoryClose(uint32 dir_id);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32           OS_DirectoryRewind(uint32 dir_id);
+int32           OS_DirectoryRewind(osal_id_t dir_id);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -609,7 +628,7 @@ int32           OS_DirectoryRewind(uint32 dir_id);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32           OS_DirectoryRead(uint32 dir_id, os_dirent_t *dirent);
+int32           OS_DirectoryRead(osal_id_t dir_id, os_dirent_t *dirent);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -671,7 +690,7 @@ int32           OS_rmdir   (const char *path);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32           OS_FileSysAddFixedMap(uint32 *filesys_id, const char *phys_path,
+int32           OS_FileSysAddFixedMap(osal_id_t *filesys_id, const char *phys_path,
                                 const char *virt_path);
 
 /*-------------------------------------------------------------------------------------*/
@@ -899,7 +918,11 @@ int32       OS_GetFsInfo(os_fsinfo_t  *filesys_info);
  * @retval #OS_ERROR if the command was not executed properly
  * @retval #OS_ERR_INVALID_ID if the file descriptor passed in is invalid
  */
-int32 OS_ShellOutputToFile(const char* Cmd, uint32 filedes);
-/**@}*/
+int32 OS_ShellOutputToFile(const char* Cmd, osal_id_t filedes);
+
+
+
+
+
 
 #endif
diff --git a/src/os/inc/osapi-os-loader.h b/src/os/inc/osapi-os-loader.h
index 38c8de213..cc62fb357 100644
--- a/src/os/inc/osapi-os-loader.h
+++ b/src/os/inc/osapi-os-loader.h
@@ -139,7 +139,7 @@ int32 OS_SymbolTableDump ( const char *filename, uint32 size_limit );
  * @retval #OS_ERR_NO_FREE_IDS if the module table is full
  * @retval #OS_ERR_NAME_TAKEN if the name is in use
  */
-int32 OS_ModuleLoad ( uint32 *module_id, const char *module_name, const char *filename );
+int32 OS_ModuleLoad ( osal_id_t *module_id, const char *module_name, const char *filename );
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -153,7 +153,7 @@ int32 OS_ModuleLoad ( uint32 *module_id, const char *module_name, const char *fi
  * @retval #OS_SUCCESS @copybrief OS_SUCCESS
  * @retval #OS_ERROR if the module is invalid or cannot be unloaded
  */
-int32 OS_ModuleUnload ( uint32 module_id );
+int32 OS_ModuleUnload ( osal_id_t module_id );
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -169,7 +169,7 @@ int32 OS_ModuleUnload ( uint32 module_id );
  * @retval #OS_ERR_INVALID_ID if the module id invalid
  * @retval #OS_INVALID_POINTER if the pointer to the ModuleInfo structure is invalid
  */
-int32 OS_ModuleInfo ( uint32 module_id, OS_module_prop_t *module_info );
+int32 OS_ModuleInfo ( osal_id_t module_id, OS_module_prop_t *module_info );
 /**@}*/
 
 #endif
diff --git a/src/os/inc/osapi-os-net.h b/src/os/inc/osapi-os-net.h
index ad1e8a702..9d0647134 100644
--- a/src/os/inc/osapi-os-net.h
+++ b/src/os/inc/osapi-os-net.h
@@ -117,7 +117,7 @@ typedef struct
 typedef struct
 {
     char name [OS_MAX_API_NAME];        /**< @brief Name of the socket */
-    uint32 creator;                     /**< @brief OSAL TaskID which opened the socket */
+    osal_id_t creator;                     /**< @brief OSAL TaskID which opened the socket */
 } OS_socket_prop_t;
 
 /**
@@ -247,7 +247,7 @@ int32 OS_SocketAddrSetPort(OS_SockAddr_t *Addr, uint16 PortNum);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_SocketOpen(uint32 *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t Type);
+int32 OS_SocketOpen(osal_id_t *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t Type);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -265,7 +265,7 @@ int32 OS_SocketOpen(uint32 *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t T
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_SocketBind(uint32 sock_id, const OS_SockAddr_t *Addr);
+int32 OS_SocketBind(osal_id_t sock_id, const OS_SockAddr_t *Addr);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -281,7 +281,7 @@ int32 OS_SocketBind(uint32 sock_id, const OS_SockAddr_t *Addr);
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_SocketConnect(uint32 sock_id, const OS_SockAddr_t *Addr, int32 timeout);
+int32 OS_SocketConnect(osal_id_t sock_id, const OS_SockAddr_t *Addr, int32 timeout);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -302,7 +302,7 @@ int32 OS_SocketConnect(uint32 sock_id, const OS_SockAddr_t *Addr, int32 timeout)
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_SocketAccept(uint32 sock_id, uint32 *connsock_id, OS_SockAddr_t *Addr, int32 timeout);
+int32 OS_SocketAccept(osal_id_t sock_id, osal_id_t *connsock_id, OS_SockAddr_t *Addr, int32 timeout);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -319,7 +319,7 @@ int32 OS_SocketAccept(uint32 sock_id, uint32 *connsock_id, OS_SockAddr_t *Addr,
  *
  * @return Count of actual bytes received or error status, see @ref OSReturnCodes
  */
-int32 OS_SocketRecvFrom(uint32 sock_id, void *buffer, uint32 buflen, OS_SockAddr_t *RemoteAddr, int32 timeout);
+int32 OS_SocketRecvFrom(osal_id_t sock_id, void *buffer, uint32 buflen, OS_SockAddr_t *RemoteAddr, int32 timeout);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -336,7 +336,7 @@ int32 OS_SocketRecvFrom(uint32 sock_id, void *buffer, uint32 buflen, OS_SockAddr
  *
  * @return Count of actual bytes sent or error status, see @ref OSReturnCodes
  */
-int32 OS_SocketSendTo(uint32 sock_id, const void *buffer, uint32 buflen, const OS_SockAddr_t *RemoteAddr);
+int32 OS_SocketSendTo(osal_id_t sock_id, const void *buffer, uint32 buflen, const OS_SockAddr_t *RemoteAddr);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -355,7 +355,7 @@ int32 OS_SocketSendTo(uint32 sock_id, const void *buffer, uint32 buflen, const O
  * @retval #OS_ERR_NAME_TOO_LONG name length including null terminator greater than #OS_MAX_API_NAME
  * @retval #OS_ERR_NAME_NOT_FOUND if the name was not found in the table
  */
-int32 OS_SocketGetIdByName (uint32 *sock_id, const char *sock_name);
+int32 OS_SocketGetIdByName (osal_id_t *sock_id, const char *sock_name);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -372,7 +372,7 @@ int32 OS_SocketGetIdByName (uint32 *sock_id, const char *sock_name);
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid semaphore
  * @retval #OS_INVALID_POINTER if the count_prop pointer is null
  */
-int32 OS_SocketGetInfo (uint32 sock_id, OS_socket_prop_t *sock_prop);
+int32 OS_SocketGetInfo (osal_id_t sock_id, OS_socket_prop_t *sock_prop);
 
 
 /*-------------------------------------------------------------------------------------*/
diff --git a/src/os/inc/osapi-os-timer.h b/src/os/inc/osapi-os-timer.h
index 66385f295..51aa708e3 100644
--- a/src/os/inc/osapi-os-timer.h
+++ b/src/os/inc/osapi-os-timer.h
@@ -33,14 +33,14 @@
 /*
 ** Typedefs
 */
-typedef void (*OS_TimerCallback_t)(uint32 timer_id); /**< @brief Timer callback */
+typedef void (*OS_TimerCallback_t)(osal_id_t timer_id); /**< @brief Timer callback */
 typedef uint32 (*OS_TimerSync_t)(uint32 timer_id);   /**< @brief Timer sync */
 
 /** @brief Timer properties */
 typedef struct 
 {
    char                name[OS_MAX_API_NAME];
-   uint32              creator;
+   osal_id_t           creator;
    uint32              start_time;
    uint32              interval_time;
    uint32              accuracy;
@@ -51,7 +51,7 @@ typedef struct
 typedef struct
 {
     char                name[OS_MAX_API_NAME];
-    uint32              creator;
+    osal_id_t           creator;
     uint32              nominal_interval_time;
     uint32              freerun_time;
     uint32              accuracy;
@@ -91,7 +91,7 @@ typedef struct
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_TimeBaseCreate         (uint32 *timebase_id, const char *timebase_name, OS_TimerSync_t external_sync);
+int32 OS_TimeBaseCreate         (osal_id_t *timebase_id, const char *timebase_name, OS_TimerSync_t external_sync);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -113,7 +113,7 @@ int32 OS_TimeBaseCreate         (uint32 *timebase_id, const char *timebase_name,
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_TimeBaseSet            (uint32 timebase_id, uint32 start_time, uint32 interval_time);
+int32 OS_TimeBaseSet            (osal_id_t timebase_id, uint32 start_time, uint32 interval_time);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -126,7 +126,7 @@ int32 OS_TimeBaseSet            (uint32 timebase_id, uint32 start_time, uint32 i
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_TimeBaseDelete         (uint32 timebase_id);
+int32 OS_TimeBaseDelete         (osal_id_t timebase_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -143,7 +143,7 @@ int32 OS_TimeBaseDelete         (uint32 timebase_id);
  * @retval #OS_ERR_NAME_TOO_LONG name length including null terminator greater than #OS_MAX_API_NAME
  * @retval #OS_ERR_NAME_NOT_FOUND if the name was not found in the table
  */
-int32 OS_TimeBaseGetIdByName    (uint32 *timebase_id, const char *timebase_name);
+int32 OS_TimeBaseGetIdByName    (osal_id_t *timebase_id, const char *timebase_name);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -163,7 +163,7 @@ int32 OS_TimeBaseGetIdByName    (uint32 *timebase_id, const char *timebase_name)
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid timebase
  * @retval #OS_INVALID_POINTER if the timebase_prop pointer is null
  */
-int32 OS_TimeBaseGetInfo        (uint32 timebase_id, OS_timebase_prop_t *timebase_prop);
+int32 OS_TimeBaseGetInfo        (osal_id_t timebase_id, OS_timebase_prop_t *timebase_prop);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -195,7 +195,7 @@ int32 OS_TimeBaseGetInfo        (uint32 timebase_id, OS_timebase_prop_t *timebas
  * @retval #OS_SUCCESS @copybrief OS_SUCCESS
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid timebase
  */
-int32 OS_TimeBaseGetFreeRun     (uint32 timebase_id, uint32 *freerun_val);
+int32 OS_TimeBaseGetFreeRun     (osal_id_t timebase_id, uint32 *freerun_val);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -234,7 +234,7 @@ int32 OS_TimeBaseGetFreeRun     (uint32 timebase_id, uint32 *freerun_val);
  * @retval #OS_TIMER_ERR_INVALID_ARGS if the callback pointer is zero.
  * @retval #OS_TIMER_ERR_UNAVAILABLE if the timer cannot be created.
  */
-int32 OS_TimerCreate            (uint32 *timer_id, const char *timer_name, uint32 *clock_accuracy, OS_TimerCallback_t callback_ptr);
+int32 OS_TimerCreate            (osal_id_t *timer_id, const char *timer_name, uint32 *clock_accuracy, OS_TimerCallback_t callback_ptr);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -264,7 +264,7 @@ int32 OS_TimerCreate            (uint32 *timer_id, const char *timer_name, uint3
  *
  * @return Execution status, see @ref OSReturnCodes
  */
-int32 OS_TimerAdd               (uint32 *timer_id, const char *timer_name, uint32 timebase_id, OS_ArgCallback_t  callback_ptr, void *callback_arg);
+int32 OS_TimerAdd               (osal_id_t *timer_id, const char *timer_name, osal_id_t timebase_id, OS_ArgCallback_t  callback_ptr, void *callback_arg);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -297,7 +297,7 @@ int32 OS_TimerAdd               (uint32 *timer_id, const char *timer_name, uint3
  * @retval #OS_TIMER_ERR_INTERNAL if there was an error programming the OS timer.
  * @retval #OS_ERROR if both start time and interval time are zero. 
  */
-int32 OS_TimerSet               (uint32 timer_id, uint32 start_time, uint32 interval_time);
+int32 OS_TimerSet               (osal_id_t timer_id, uint32 start_time, uint32 interval_time);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -313,7 +313,7 @@ int32 OS_TimerSet               (uint32 timer_id, uint32 start_time, uint32 inte
  * @retval #OS_ERR_INVALID_ID if the timer_id is invalid.
  * @retval #OS_TIMER_ERR_INTERNAL if there was a problem deleting the timer in the host OS.
  */
-int32 OS_TimerDelete            (uint32 timer_id);
+int32 OS_TimerDelete            (osal_id_t timer_id);
 
 /*-------------------------------------------------------------------------------------*/
 /**
@@ -330,7 +330,7 @@ int32 OS_TimerDelete            (uint32 timer_id);
  * @retval #OS_ERR_NAME_TOO_LONG name length including null terminator greater than #OS_MAX_API_NAME
  * @retval #OS_ERR_NAME_NOT_FOUND if the name was not found in the table
  */
-int32 OS_TimerGetIdByName       (uint32 *timer_id, const char *timer_name);
+int32 OS_TimerGetIdByName       (osal_id_t *timer_id, const char *timer_name);
 
 
 /*-------------------------------------------------------------------------------------*/
@@ -353,7 +353,7 @@ int32 OS_TimerGetIdByName       (uint32 *timer_id, const char *timer_name);
  * @retval #OS_ERR_INVALID_ID if the id passed in is not a valid timer
  * @retval #OS_INVALID_POINTER if the timer_prop pointer is null
  */
-int32 OS_TimerGetInfo           (uint32  timer_id, OS_timer_prop_t *timer_prop);
+int32 OS_TimerGetInfo           (osal_id_t  timer_id, OS_timer_prop_t *timer_prop);
 /**@}*/
 
 #endif
diff --git a/src/os/posix/src/os-impl-tasks.c b/src/os/posix/src/os-impl-tasks.c
index 16f77271d..73cae66dc 100644
--- a/src/os/posix/src/os-impl-tasks.c
+++ b/src/os/posix/src/os-impl-tasks.c
@@ -125,7 +125,7 @@ static void *OS_PthreadTaskEntry(void *arg)
    OS_U32ValueWrapper_t local_arg;
 
    local_arg.opaque_arg = arg;
-   OS_TaskEntryPoint(local_arg.value); /* Never returns */
+   OS_TaskEntryPoint(local_arg.id); /* Never returns */
 
    return NULL;
 }
@@ -579,7 +579,7 @@ int32 OS_TaskCreate_Impl (uint32 task_id, uint32 flags)
     int32 return_code;
 
     arg.opaque_arg = NULL;
-    arg.value = OS_global_task_table[task_id].active_id;
+    arg.id = OS_global_task_table[task_id].active_id;
 
     return_code = OS_Posix_InternalTaskCreate_Impl(
            &OS_impl_task_table[task_id].id,
@@ -730,13 +730,13 @@ int32 OS_TaskSetPriority_Impl (uint32 task_id, uint32 new_priority)
  *           See prototype for argument/return detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TaskRegister_Impl(uint32 global_task_id)
+int32 OS_TaskRegister_Impl(osal_id_t global_task_id)
 {
    int32 return_code;
    OS_U32ValueWrapper_t arg;
 
    arg.opaque_arg = 0;
-   arg.value = global_task_id;
+   arg.id = global_task_id;
 
    return_code = pthread_setspecific(POSIX_GlobalVars.ThreadKey, arg.opaque_arg);
    if (return_code == 0)
@@ -761,13 +761,13 @@ int32 OS_TaskRegister_Impl(uint32 global_task_id)
  *           See prototype for argument/return detail
  *
  *-----------------------------------------------------------------*/
-uint32 OS_TaskGetId_Impl (void)
+osal_id_t OS_TaskGetId_Impl (void)
 {
    OS_U32ValueWrapper_t self_record;
 
    self_record.opaque_arg = pthread_getspecific(POSIX_GlobalVars.ThreadKey);
 
-   return(self_record.value);
+   return(self_record.id);
 } /* end OS_TaskGetId_Impl */
 
 
diff --git a/src/os/posix/src/os-impl-timebase.c b/src/os/posix/src/os-impl-timebase.c
index 36b872757..4b206df49 100644
--- a/src/os/posix/src/os-impl-timebase.c
+++ b/src/os/posix/src/os-impl-timebase.c
@@ -309,7 +309,7 @@ static void *OS_TimeBasePthreadEntry(void *arg)
     OS_U32ValueWrapper_t local_arg;
 
     local_arg.opaque_arg = arg;
-    OS_TimeBase_CallbackThread(local_arg.value);
+    OS_TimeBase_CallbackThread(local_arg.id);
     return NULL;
 }
 
@@ -347,7 +347,7 @@ int32 OS_TimeBaseCreate_Impl(uint32 timer_id)
      * the global table lock.
      */
     arg.opaque_arg = NULL;
-    arg.value = global->active_id;
+    arg.id = global->active_id;
     return_code = OS_Posix_InternalTaskCreate_Impl(&local->handler_thread, 0, 0, OS_TimeBasePthreadEntry, arg.opaque_arg);
     if (return_code != OS_SUCCESS)
     {
@@ -378,7 +378,7 @@ int32 OS_TimeBaseCreate_Impl(uint32 timer_id)
         for(i = 0; i < OS_MAX_TIMEBASES; ++i)
         {
             if (i != timer_id &&
-                    OS_global_timebase_table[i].active_id != 0 &&
+                    OS_ObjectIdDefined(OS_global_timebase_table[i].active_id) &&
                     OS_impl_timebase_table[i].assigned_signal != 0)
             {
                 sigaddset(&local->sigset, OS_impl_timebase_table[i].assigned_signal);
@@ -447,7 +447,7 @@ int32 OS_TimeBaseCreate_Impl(uint32 timer_id)
              *  and doing it this way should still work on a system where sizeof(sival_int) < sizeof(uint32)
              *  (as long as sizeof(sival_int) >= number of bits in OS_OBJECT_INDEX_MASK)
              */
-            evp.sigev_value.sival_int = (int)(global->active_id & OS_OBJECT_INDEX_MASK);
+            evp.sigev_value.sival_int = (int)OS_ObjectIdToSerialNumber_Impl(global->active_id);
 
             /*
             ** Create the timer
diff --git a/src/os/rtems/src/os-impl-tasks.c b/src/os/rtems/src/os-impl-tasks.c
index 6b4c83a02..f8cdce82b 100644
--- a/src/os/rtems/src/os-impl-tasks.c
+++ b/src/os/rtems/src/os-impl-tasks.c
@@ -269,7 +269,7 @@ int32 OS_TaskMatch_Impl(uint32 task_id)
  *           See prototype for argument/return detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TaskRegister_Impl (uint32 global_task_id)
+int32 OS_TaskRegister_Impl (osal_id_t global_task_id)
 {
     /*
      * This is supposed to maintain the "reverse lookup" information used
diff --git a/src/os/shared/inc/os-shared-common.h b/src/os/shared/inc/os-shared-common.h
index dff48082a..befd20d10 100644
--- a/src/os/shared/inc/os-shared-common.h
+++ b/src/os/shared/inc/os-shared-common.h
@@ -46,7 +46,7 @@ struct OS_shared_global_vars
    /*
     * The console device ID used for OS_printf() calls
     */
-   uint32            PrintfConsoleId;
+   osal_id_t         PrintfConsoleId;
 
    /*
     * PrintfEnabled and ShutdownFlag are marked "volatile"
diff --git a/src/os/shared/inc/os-shared-globaldefs.h b/src/os/shared/inc/os-shared-globaldefs.h
index 9c26cff90..71c1f16aa 100644
--- a/src/os/shared/inc/os-shared-globaldefs.h
+++ b/src/os/shared/inc/os-shared-globaldefs.h
@@ -60,6 +60,7 @@ typedef union
    OS_ArgCallback_t arg_callback_func;
    OS_TimerCallback_t timer_callback_func;
    osal_task_entry entry_func;
+   osal_id_t id;
    uint32 value;
 } OS_U32ValueWrapper_t;
 
diff --git a/src/os/shared/inc/os-shared-idmap.h b/src/os/shared/inc/os-shared-idmap.h
index 9d7a397a7..d18aac8c3 100644
--- a/src/os/shared/inc/os-shared-idmap.h
+++ b/src/os/shared/inc/os-shared-idmap.h
@@ -33,14 +33,16 @@
 
 #define OS_OBJECT_EXCL_REQ_FLAG     0x0001
 
+#define OS_OBJECT_ID_RESERVED       ((osal_id_t){0xFFFFFFFF})
+
 /*
  * This supplies a non-abstract definition of "OS_common_record_t"
  */
 struct OS_common_record
 {
    const char *name_entry;
-   uint32     active_id;
-   uint32     creator;
+   osal_id_t     active_id;
+   osal_id_t     creator;
    uint16     refcount;
    uint16     flags;
 };
@@ -160,9 +162,9 @@ int32 OS_Unlock_Global_Impl(uint32 idtype);
 
     Purpose: Obtain the serial number component of a generic OSAL Object ID
  ------------------------------------------------------------------*/
-static inline uint32 OS_ObjectIdToSerialNumber_Impl(uint32 id)
+static inline uint32 OS_ObjectIdToSerialNumber_Impl(osal_id_t id)
 {
-    return (id & OS_OBJECT_INDEX_MASK);
+    return (OS_ObjectIdToInteger(id) & OS_OBJECT_INDEX_MASK);
 }
 
 /*----------------------------------------------------------------
@@ -170,9 +172,9 @@ static inline uint32 OS_ObjectIdToSerialNumber_Impl(uint32 id)
 
     Purpose: Obtain the object type component of a generic OSAL Object ID
  ------------------------------------------------------------------*/
-static inline uint32 OS_ObjectIdToType_Impl(uint32 id)
+static inline uint32 OS_ObjectIdToType_Impl(osal_id_t id)
 {
-    return (id >> OS_OBJECT_TYPE_SHIFT);
+    return (OS_ObjectIdToInteger(id) >> OS_OBJECT_TYPE_SHIFT);
 }
 
 
@@ -181,9 +183,9 @@ static inline uint32 OS_ObjectIdToType_Impl(uint32 id)
 
     Purpose: Convert an object serial number and resource type into an external 32-bit OSAL ID
  ------------------------------------------------------------------*/
-static inline void OS_ObjectIdCompose_Impl(uint32 idtype, uint32 idserial, uint32 *result)
+static inline void OS_ObjectIdCompose_Impl(uint32 idtype, uint32 idserial, osal_id_t *result)
 {
-    *result = (idtype << OS_OBJECT_TYPE_SHIFT) | idserial;
+    *result = OS_ObjectIdFromInteger((idtype << OS_OBJECT_TYPE_SHIFT) | idserial);
 }
 
 
@@ -212,7 +214,7 @@ uint32 OS_GetBaseForObjectType(uint32 idtype);
 
     Returns: OS_SUCCESS on success, or relevant error code
  ------------------------------------------------------------------*/
-int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, uint32 *object_id);
+int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, osal_id_t *object_id);
 
 /*----------------------------------------------------------------
    Function: OS_ObjectIdToArrayIndex
@@ -221,7 +223,7 @@ int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, uint32 *object_id)
 
     Returns: OS_SUCCESS on success, or relevant error code
  ------------------------------------------------------------------*/
-int32 OS_ObjectIdToArrayIndex(uint32 idtype, uint32 id, uint32 *ArrayIndex);
+int32 OS_ObjectIdToArrayIndex(uint32 idtype, osal_id_t id, uint32 *ArrayIndex);
 
 /*----------------------------------------------------------------
    Function: OS_ObjectIdGetBySearch
@@ -252,7 +254,7 @@ int32 OS_ObjectIdGetByName (OS_lock_mode_t lock_mode, uint32 idtype, const char
 
     Returns: OS_SUCCESS on success, or relevant error code
  ------------------------------------------------------------------*/
-int32 OS_ObjectIdGetById(OS_lock_mode_t lock_mode, uint32 idtype, uint32 id, uint32 *array_index, OS_common_record_t **record);
+int32 OS_ObjectIdGetById(OS_lock_mode_t lock_mode, uint32 idtype, osal_id_t id, uint32 *array_index, OS_common_record_t **record);
 
 /*----------------------------------------------------------------
    Function: OS_ObjectIdAllocateNew
@@ -276,7 +278,7 @@ int32 OS_ObjectIdAllocateNew(uint32 idtype, const char *name, uint32 *array_inde
 
     Returns: OS_SUCCESS on success, or relevant error code
  ------------------------------------------------------------------*/
-int32 OS_ObjectIdFinalizeNew(int32 operation_status, OS_common_record_t *record, uint32 *outid);
+int32 OS_ObjectIdFinalizeNew(int32 operation_status, OS_common_record_t *record, osal_id_t *outid);
 
 /*----------------------------------------------------------------
    Function: OS_ObjectIdFinalizeDelete
@@ -308,7 +310,7 @@ int32 OS_ObjectIdRefcountDecr(OS_common_record_t *record);
  */
 bool OS_ObjectNameMatch(void *ref, uint32 local_id, const OS_common_record_t *obj);
 void OS_ObjectIdInitiateLock(OS_lock_mode_t lock_mode, uint32 idtype);
-int32 OS_ObjectIdConvertLock(OS_lock_mode_t lock_mode, uint32 idtype, uint32 reference_id, OS_common_record_t *obj);
+int32 OS_ObjectIdConvertLock(OS_lock_mode_t lock_mode, uint32 idtype, osal_id_t reference_id, OS_common_record_t *obj);
 int32 OS_ObjectIdSearch(uint32 idtype, OS_ObjectMatchFunc_t MatchFunc, void *arg, OS_common_record_t **record);
 int32 OS_ObjectIdFindNext(uint32 idtype, uint32 *array_index, OS_common_record_t **record);
 
diff --git a/src/os/shared/inc/os-shared-task.h b/src/os/shared/inc/os-shared-task.h
index 33c79678d..7f4dc79e2 100644
--- a/src/os/shared/inc/os-shared-task.h
+++ b/src/os/shared/inc/os-shared-task.h
@@ -75,7 +75,7 @@ int32 OS_TaskAPI_Init                (void);
 
     Returns: OS_SUCCESS on success, or relevant error code
  ------------------------------------------------------------------*/
-void   OS_TaskEntryPoint              (uint32 global_task_id);
+void   OS_TaskEntryPoint              (osal_id_t global_task_id);
 
 /*----------------------------------------------------------------
    Function: OS_TaskMatch_Impl
@@ -140,7 +140,7 @@ int32  OS_TaskSetPriority_Impl       (uint32 task_id, uint32 new_priority);
 
     Returns: The OSAL ID of the calling task, or zero if not registered
  ------------------------------------------------------------------*/
-uint32 OS_TaskGetId_Impl             (void);
+osal_id_t OS_TaskGetId_Impl             (void);
 
 /*----------------------------------------------------------------
    Function: OS_TaskGetInfo_Impl
@@ -162,7 +162,7 @@ int32  OS_TaskGetInfo_Impl           (uint32 task_id, OS_task_prop_t *task_prop)
 
     Returns: OS_SUCCESS on success, or relevant error code
  ------------------------------------------------------------------*/
-int32  OS_TaskRegister_Impl          (uint32 global_task_id);
+int32  OS_TaskRegister_Impl          (osal_id_t global_task_id);
 
 
 /*----------------------------------------------------------------
diff --git a/src/os/shared/inc/os-shared-timebase.h b/src/os/shared/inc/os-shared-timebase.h
index efb42546a..31617c540 100644
--- a/src/os/shared/inc/os-shared-timebase.h
+++ b/src/os/shared/inc/os-shared-timebase.h
@@ -36,7 +36,7 @@ typedef struct
     char                timebase_name[OS_MAX_API_NAME];
     OS_TimerSync_t      external_sync;
     uint32              accuracy_usec;
-    uint32              first_cb;
+    osal_id_t           first_cb;
     uint32              freerun_time;
     uint32              nominal_start_time;
     uint32              nominal_interval_time;
@@ -132,7 +132,7 @@ int32 OS_TimeBaseGetInfo_Impl       (uint32 timer_id, OS_timebase_prop_t *timer_
     Purpose: Implement the time base helper thread
              This is the context for providing application callbacks
  ------------------------------------------------------------------*/
-void  OS_TimeBase_CallbackThread    (uint32 timebase_id);
+void  OS_TimeBase_CallbackThread    (osal_id_t timebase_id);
 
 
 #endif  /* INCLUDE_OS_SHARED_TIMEBASE_H_ */
diff --git a/src/os/shared/src/osapi-binsem.c b/src/os/shared/src/osapi-binsem.c
index 3784aa652..ce1a2f5d5 100644
--- a/src/os/shared/src/osapi-binsem.c
+++ b/src/os/shared/src/osapi-binsem.c
@@ -99,7 +99,7 @@ int32 OS_BinSemAPI_Init(void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_BinSemCreate (uint32 *sem_id, const char *sem_name, uint32 sem_initial_value,
+int32 OS_BinSemCreate (osal_id_t *sem_id, const char *sem_name, uint32 sem_initial_value,
                         uint32 options)
 {
    OS_common_record_t *record;
@@ -146,7 +146,7 @@ int32 OS_BinSemCreate (uint32 *sem_id, const char *sem_name, uint32 sem_initial_
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_BinSemDelete (uint32 sem_id)
+int32 OS_BinSemDelete (osal_id_t sem_id)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -175,7 +175,7 @@ int32 OS_BinSemDelete (uint32 sem_id)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_BinSemGive ( uint32 sem_id )
+int32 OS_BinSemGive ( osal_id_t sem_id )
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -201,7 +201,7 @@ int32 OS_BinSemGive ( uint32 sem_id )
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_BinSemFlush (uint32 sem_id)
+int32 OS_BinSemFlush (osal_id_t sem_id)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -226,7 +226,7 @@ int32 OS_BinSemFlush (uint32 sem_id)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_BinSemTake ( uint32 sem_id )
+int32 OS_BinSemTake ( osal_id_t sem_id )
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -251,7 +251,7 @@ int32 OS_BinSemTake ( uint32 sem_id )
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_BinSemTimedWait ( uint32 sem_id, uint32 msecs )
+int32 OS_BinSemTimedWait ( osal_id_t sem_id, uint32 msecs )
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -275,7 +275,7 @@ int32 OS_BinSemTimedWait ( uint32 sem_id, uint32 msecs )
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_BinSemGetIdByName (uint32 *sem_id, const char *sem_name)
+int32 OS_BinSemGetIdByName (osal_id_t *sem_id, const char *sem_name)
 {
    int32 return_code;
 
@@ -298,7 +298,7 @@ int32 OS_BinSemGetIdByName (uint32 *sem_id, const char *sem_name)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_BinSemGetInfo (uint32 sem_id, OS_bin_sem_prop_t *bin_prop)
+int32 OS_BinSemGetInfo (osal_id_t sem_id, OS_bin_sem_prop_t *bin_prop)
 {
    OS_common_record_t *record;
    uint32 local_id;
diff --git a/src/os/shared/src/osapi-common.c b/src/os/shared/src/osapi-common.c
index ffe53f7bb..d9d1598a7 100644
--- a/src/os/shared/src/osapi-common.c
+++ b/src/os/shared/src/osapi-common.c
@@ -237,7 +237,7 @@ void OS_ApplicationExit(int32 Status)
  *  Purpose: Local helper routine, not part of OSAL API.
  *
  *-----------------------------------------------------------------*/
-void OS_CleanUpObject(uint32 object_id, void *arg)
+void OS_CleanUpObject(osal_id_t object_id, void *arg)
 {
     uint32 *ObjectCount;
 
@@ -303,7 +303,7 @@ void OS_DeleteAllObjects(void)
     {
         ObjectCount = 0;
         ++TryCount;
-        OS_ForEachObject(0, OS_CleanUpObject, &ObjectCount);
+        OS_ForEachObject(OS_OBJECT_CREATOR_ANY, OS_CleanUpObject, &ObjectCount);
         if (ObjectCount == 0 || TryCount > 4)
         {
            break;
diff --git a/src/os/shared/src/osapi-countsem.c b/src/os/shared/src/osapi-countsem.c
index 42f61d410..56688b6b4 100644
--- a/src/os/shared/src/osapi-countsem.c
+++ b/src/os/shared/src/osapi-countsem.c
@@ -93,7 +93,7 @@ int32 OS_CountSemAPI_Init(void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_CountSemCreate (uint32 *sem_id, const char *sem_name, uint32 sem_initial_value,
+int32 OS_CountSemCreate (osal_id_t *sem_id, const char *sem_name, uint32 sem_initial_value,
                         uint32 options)
 {
    OS_common_record_t *record;
@@ -139,7 +139,7 @@ int32 OS_CountSemCreate (uint32 *sem_id, const char *sem_name, uint32 sem_initia
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_CountSemDelete (uint32 sem_id)
+int32 OS_CountSemDelete (osal_id_t sem_id)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -168,7 +168,7 @@ int32 OS_CountSemDelete (uint32 sem_id)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_CountSemGive ( uint32 sem_id )
+int32 OS_CountSemGive ( osal_id_t sem_id )
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -194,7 +194,7 @@ int32 OS_CountSemGive ( uint32 sem_id )
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_CountSemTake ( uint32 sem_id )
+int32 OS_CountSemTake ( osal_id_t sem_id )
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -219,7 +219,7 @@ int32 OS_CountSemTake ( uint32 sem_id )
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_CountSemTimedWait ( uint32 sem_id, uint32 msecs )
+int32 OS_CountSemTimedWait ( osal_id_t sem_id, uint32 msecs )
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -244,7 +244,7 @@ int32 OS_CountSemTimedWait ( uint32 sem_id, uint32 msecs )
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_CountSemGetIdByName (uint32 *sem_id, const char *sem_name)
+int32 OS_CountSemGetIdByName (osal_id_t *sem_id, const char *sem_name)
 {
    int32 return_code;
 
@@ -267,7 +267,7 @@ int32 OS_CountSemGetIdByName (uint32 *sem_id, const char *sem_name)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_CountSemGetInfo (uint32 sem_id, OS_count_sem_prop_t *count_prop)
+int32 OS_CountSemGetInfo (osal_id_t sem_id, OS_count_sem_prop_t *count_prop)
 {
    OS_common_record_t *record;
    uint32 local_id;
diff --git a/src/os/shared/src/osapi-dir.c b/src/os/shared/src/osapi-dir.c
index 687636484..6f20a0404 100644
--- a/src/os/shared/src/osapi-dir.c
+++ b/src/os/shared/src/osapi-dir.c
@@ -117,7 +117,7 @@ int32 OS_mkdir (const char *path, uint32 access)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_DirectoryOpen(uint32 *dir_id, const char *path)
+int32 OS_DirectoryOpen(osal_id_t *dir_id, const char *path)
 {
     char local_path[OS_MAX_LOCAL_PATH_LEN];
     OS_common_record_t *record;
@@ -161,7 +161,7 @@ int32 OS_DirectoryOpen(uint32 *dir_id, const char *path)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_DirectoryClose(uint32 dir_id)
+int32 OS_DirectoryClose(osal_id_t dir_id)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -189,7 +189,7 @@ int32 OS_DirectoryClose(uint32 dir_id)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_DirectoryRead(uint32 dir_id, os_dirent_t *dirent)
+int32 OS_DirectoryRead(osal_id_t dir_id, os_dirent_t *dirent)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -232,7 +232,7 @@ int32 OS_DirectoryRead(uint32 dir_id, os_dirent_t *dirent)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_DirectoryRewind(uint32 dir_id)
+int32 OS_DirectoryRewind(osal_id_t dir_id)
 {
    OS_common_record_t *record;
    uint32 local_id;
diff --git a/src/os/shared/src/osapi-file.c b/src/os/shared/src/osapi-file.c
index 007c25bb6..72b95cf2c 100644
--- a/src/os/shared/src/osapi-file.c
+++ b/src/os/shared/src/osapi-file.c
@@ -92,7 +92,7 @@ int32 OS_FileAPI_Init(void)
  *           (The difference is a matter of what flags are passed in)
  *
  *-----------------------------------------------------------------*/
-static int32 OS_OpenCreate(uint32 *filedes, const char *path, int32 flags, int32 access)
+int32 OS_OpenCreate(osal_id_t *filedes, const char *path, int32 flags, int32 access)
 {
    int32 return_code;
    uint32 local_id;
@@ -137,7 +137,7 @@ static int32 OS_OpenCreate(uint32 *filedes, const char *path, int32 flags, int32
  *-----------------------------------------------------------------*/
 int32 OS_creat  (const char *path, int32  access)
 {
-   uint32 filedes;
+   osal_id_t filedes;
    int32 return_code;
 
    /*
@@ -158,7 +158,9 @@ int32 OS_creat  (const char *path, int32  access)
    return_code = OS_OpenCreate(&filedes, path, OS_FILE_FLAG_CREATE | OS_FILE_FLAG_TRUNCATE, access);
    if (return_code == OS_SUCCESS)
    {
-      return_code = (int32)filedes;
+      /* for backward compatibility, on success return the ID as an int32.
+       * This will always within the positive range */
+      return_code = (int32)OS_ObjectIdToInteger(filedes);
    }
 
    return return_code;
@@ -175,7 +177,7 @@ int32 OS_creat  (const char *path, int32  access)
  *-----------------------------------------------------------------*/
 int32 OS_open   (const char *path,  int32 access,  uint32  mode)
 {
-   uint32 filedes;
+   osal_id_t filedes;
    int32 return_code;
 
    /*
@@ -195,7 +197,9 @@ int32 OS_open   (const char *path,  int32 access,  uint32  mode)
    return_code = OS_OpenCreate(&filedes, path, OS_FILE_FLAG_NONE, access);
    if (return_code == OS_SUCCESS)
    {
-      return_code = (int32)filedes;
+       /* for backward compatibility, on success return the ID as an int32.
+        * This will always within the positive range */
+       return_code = (int32)OS_ObjectIdToInteger(filedes);
    }
 
    return return_code;
@@ -211,7 +215,7 @@ int32 OS_open   (const char *path,  int32 access,  uint32  mode)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_close (uint32 filedes)
+int32 OS_close (osal_id_t filedes)
 {
     OS_common_record_t *record;
     uint32 local_id;
@@ -240,7 +244,7 @@ int32 OS_close (uint32 filedes)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimedRead(uint32  filedes, void *buffer, uint32 nbytes, int32 timeout)
+int32 OS_TimedRead(osal_id_t  filedes, void *buffer, uint32 nbytes, int32 timeout)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -271,7 +275,7 @@ int32 OS_TimedRead(uint32  filedes, void *buffer, uint32 nbytes, int32 timeout)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimedWrite(uint32  filedes, const void *buffer, uint32 nbytes, int32 timeout)
+int32 OS_TimedWrite(osal_id_t  filedes, const void *buffer, uint32 nbytes, int32 timeout)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -302,7 +306,7 @@ int32 OS_TimedWrite(uint32  filedes, const void *buffer, uint32 nbytes, int32 ti
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_read  (uint32  filedes, void *buffer, uint32 nbytes)
+int32 OS_read  (osal_id_t  filedes, void *buffer, uint32 nbytes)
 {
    return OS_TimedRead(filedes, buffer, nbytes, OS_PEND);
 } /* end OS_read */
@@ -316,7 +320,7 @@ int32 OS_read  (uint32  filedes, void *buffer, uint32 nbytes)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_write (uint32  filedes, const void *buffer, uint32 nbytes)
+int32 OS_write (osal_id_t  filedes, const void *buffer, uint32 nbytes)
 {
     return OS_TimedWrite(filedes, buffer, nbytes, OS_PEND);
 } /* end OS_write */
@@ -385,7 +389,7 @@ int32 OS_stat   (const char *path, os_fstat_t *filestats)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_lseek  (uint32  filedes, int32 offset, uint32 whence)
+int32 OS_lseek  (osal_id_t  filedes, int32 offset, uint32 whence)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -458,7 +462,7 @@ int32 OS_rename (const char *old, const char *new)
       OS_Lock_Global(LOCAL_OBJID_TYPE);
       for ( i =0; i < OS_MAX_NUM_OPEN_FILES; i++)
       {
-         if (OS_global_stream_table[i].active_id != 0 &&
+         if (OS_ObjectIdDefined(OS_global_stream_table[i].active_id) &&
                OS_stream_table[i].socket_domain == OS_SocketDomain_INVALID &&
                strcmp(OS_stream_table[i].stream_name, old) == 0)
          {
@@ -487,8 +491,8 @@ int32 OS_cp (const char *src, const char *dest)
     int32 rd_size;
     int32 wr_size;
     int32 wr_total;
-    int32 file1;
-    int32 file2;
+    osal_id_t file1;
+    osal_id_t file2;
     uint8 copyblock[512];
 
     if (src == NULL || dest == NULL)
@@ -496,25 +500,17 @@ int32 OS_cp (const char *src, const char *dest)
         return OS_INVALID_POINTER;
     }
 
-    return_code = OS_SUCCESS;
-    file2 = -1;
-    file1 = OS_open(src, OS_READ_ONLY, 0);
-    if (file1 < 0)
-    {
-       return_code = file1;
-    }
-    else
+    file1 = OS_OBJECT_ID_UNDEFINED;
+    file2 = OS_OBJECT_ID_UNDEFINED;
+    return_code = OS_OpenCreate(&file1, src, OS_FILE_FLAG_NONE, OS_READ_ONLY);
+    if (return_code == OS_SUCCESS)
     {
-       file2 = OS_creat(dest, OS_WRITE_ONLY);
-       if (file2 < 0)
-       {
-          return_code = file2;
-       }
+       return_code = OS_OpenCreate(&file2, dest, OS_FILE_FLAG_CREATE | OS_FILE_FLAG_TRUNCATE, OS_WRITE_ONLY);
     }
 
     while (return_code == OS_SUCCESS)
     {
-       rd_size = OS_read((uint32)file1, copyblock, sizeof(copyblock));
+       rd_size = OS_read(file1, copyblock, sizeof(copyblock));
        if (rd_size < 0)
        {
           return_code = rd_size;
@@ -527,7 +523,7 @@ int32 OS_cp (const char *src, const char *dest)
        wr_total = 0;
        while (wr_total < rd_size)
        {
-          wr_size = OS_write((uint32)file2, &copyblock[wr_total], rd_size - wr_total);
+          wr_size = OS_write(file2, &copyblock[wr_total], rd_size - wr_total);
           if (wr_size < 0)
           {
              return_code = wr_size;
@@ -537,11 +533,11 @@ int32 OS_cp (const char *src, const char *dest)
        }
     }
 
-    if (file1 >= 0)
+    if (OS_ObjectIdDefined(file1))
     {
        OS_close(file1);
     }
-    if (file2 >= 0)
+    if (OS_ObjectIdDefined(file2))
     {
        OS_close(file2);
     }
@@ -589,7 +585,7 @@ int32 OS_mv (const char *src, const char *dest)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_FDGetInfo (uint32 filedes, OS_file_prop_t *fd_prop)
+int32 OS_FDGetInfo (osal_id_t filedes, OS_file_prop_t *fd_prop)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -642,7 +638,7 @@ int32 OS_FileOpenCheck(const char *Filename)
 
    for ( i = 0; i < OS_MAX_NUM_OPEN_FILES; i++)
    {
-      if (OS_global_stream_table[i].active_id != 0 &&
+      if (OS_ObjectIdDefined(OS_global_stream_table[i].active_id) &&
             OS_stream_table[i].socket_domain == OS_SocketDomain_INVALID &&
             (strcmp(OS_stream_table[i].stream_name, Filename) == 0))
       {
@@ -683,14 +679,14 @@ int32 OS_CloseFileByName(const char *Filename)
 
    for ( i = 0; i < OS_MAX_NUM_OPEN_FILES; i++)
    {
-      if (OS_global_stream_table[i].active_id != 0 &&
+      if (OS_ObjectIdDefined(OS_global_stream_table[i].active_id) &&
             OS_stream_table[i].socket_domain == OS_SocketDomain_INVALID &&
             (strcmp(OS_stream_table[i].stream_name, Filename) == 0))
       {
          close_code = OS_GenericClose_Impl(i);
          if (close_code == OS_SUCCESS)
          {
-             OS_global_stream_table[i].active_id = 0;
+             OS_global_stream_table[i].active_id = OS_OBJECT_ID_UNDEFINED;
          }
          if (return_code == OS_FS_ERR_PATH_INVALID || close_code != OS_SUCCESS)
          {
@@ -726,12 +722,12 @@ int32 OS_CloseAllFiles(void)
 
    for ( i = 0; i < OS_MAX_NUM_OPEN_FILES; i++)
    {
-      if (OS_global_stream_table[i].active_id != 0)
+      if (OS_ObjectIdDefined(OS_global_stream_table[i].active_id))
       {
          close_code = OS_GenericClose_Impl(i);
          if (close_code == OS_SUCCESS)
          {
-             OS_global_stream_table[i].active_id = 0;
+             OS_global_stream_table[i].active_id = OS_OBJECT_ID_UNDEFINED;
          }
          if (close_code != OS_SUCCESS)
          {
diff --git a/src/os/shared/src/osapi-filesys.c b/src/os/shared/src/osapi-filesys.c
index 627ebe33e..27ba47e5c 100644
--- a/src/os/shared/src/osapi-filesys.c
+++ b/src/os/shared/src/osapi-filesys.c
@@ -228,7 +228,7 @@ int32 OS_FileSysAPI_Init(void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_FileSysAddFixedMap(uint32 *filesys_id, const char *phys_path, const char *virt_path)
+int32 OS_FileSysAddFixedMap(osal_id_t *filesys_id, const char *phys_path, const char *virt_path)
 {
     OS_common_record_t *global;
     OS_filesys_internal_record_t *local;
@@ -394,7 +394,7 @@ int32 OS_rmfs (const char *devname)
         if (return_code == OS_SUCCESS)
         {
            /* Only need to clear the ID as zero is the "unused" flag */
-           global->active_id = 0;
+           global->active_id = OS_OBJECT_ID_UNDEFINED;
         }
 
         OS_Unlock_Global(LOCAL_OBJID_TYPE);
@@ -832,7 +832,7 @@ int32 OS_GetFsInfo(os_fsinfo_t  *filesys_info)
 
    for ( i = 0; i < OS_MAX_NUM_OPEN_FILES; i++ )
    {
-      if ( OS_global_stream_table[i].active_id == 0)
+      if ( !OS_ObjectIdDefined(OS_global_stream_table[i].active_id) )
       {
          filesys_info->FreeFds++;
       }
@@ -844,7 +844,7 @@ int32 OS_GetFsInfo(os_fsinfo_t  *filesys_info)
 
    for ( i = 0; i < OS_MAX_FILE_SYSTEMS; i++ )
    {
-       if ( OS_global_filesys_table[i].active_id == 0)
+       if ( !OS_ObjectIdDefined(OS_global_filesys_table[i].active_id) )
        {
            filesys_info->FreeVolumes++;
        }
diff --git a/src/os/shared/src/osapi-idmap.c b/src/os/shared/src/osapi-idmap.c
index 2d172bf3d..f33626a5e 100644
--- a/src/os/shared/src/osapi-idmap.c
+++ b/src/os/shared/src/osapi-idmap.c
@@ -84,10 +84,10 @@ static OS_common_record_t OS_common_table[OS_MAX_TOTAL_RECORDS];
 typedef struct
 {
     /* Keep track of the last successfully-issued object ID of each type */
-    uint32 last_id_issued;
+    osal_id_t last_id_issued;
 
     /* The last task to lock/own this global table */
-    uint32 table_owner;
+    osal_id_t table_owner;
 } OS_objtype_state_t;
 
 OS_objtype_state_t OS_objtype_state[OS_OBJECT_TYPE_USER];
@@ -272,7 +272,7 @@ void OS_ObjectIdInitiateLock(OS_lock_mode_t lock_mode, uint32 idtype)
  *         all lock modes other than OS_LOCK_MODE_NONE.
  *
  *-----------------------------------------------------------------*/
-int32 OS_ObjectIdConvertLock(OS_lock_mode_t lock_mode, uint32 idtype, uint32 reference_id, OS_common_record_t *obj)
+int32 OS_ObjectIdConvertLock(OS_lock_mode_t lock_mode, uint32 idtype, osal_id_t reference_id, OS_common_record_t *obj)
 {
     int32 return_code = OS_ERROR;
     uint32 exclusive_bits = 0;
@@ -282,7 +282,7 @@ int32 OS_ObjectIdConvertLock(OS_lock_mode_t lock_mode, uint32 idtype, uint32 ref
     {
         /* Validate the integrity of the ID.  As the "active_id" is a single
          * integer, we can do this check regardless of whether global is locked or not. */
-        if (obj->active_id != reference_id)
+        if (!OS_ObjectIdEqual(obj->active_id, reference_id))
         {
             /* The ID does not match, so unlock and return error.
              * This basically means the ID was stale or otherwise no longer invalid */
@@ -424,7 +424,8 @@ int32 OS_ObjectIdSearch(uint32 idtype, OS_ObjectMatchFunc_t MatchFunc, void *arg
         }
         --obj_count;
 
-        if (obj->active_id != 0 && MatchFunc(arg, local_id, obj))
+        if ( OS_ObjectIdDefined(obj->active_id) &&
+                MatchFunc(arg, local_id, obj))
         {
             return_code = OS_SUCCESS;
             break;
@@ -483,7 +484,7 @@ int32 OS_ObjectIdFindNext(uint32 idtype, uint32 *array_index, OS_common_record_t
    else
    {
        return_code = OS_ERR_NO_FREE_IDS;
-       idvalue = OS_objtype_state[idtype].last_id_issued & OS_OBJECT_INDEX_MASK;
+       idvalue = OS_ObjectIdToSerialNumber_Impl(OS_objtype_state[idtype].last_id_issued);
    }
 
    for (i = 0; i < max_id; ++i)
@@ -495,7 +496,7 @@ int32 OS_ObjectIdFindNext(uint32 idtype, uint32 *array_index, OS_common_record_t
           idvalue = local_id;
       }
       obj = &OS_common_table[local_id + base_id];
-      if (obj->active_id == 0)
+      if (!OS_ObjectIdDefined(obj->active_id))
       {
          return_code = OS_SUCCESS;
          break;
@@ -548,7 +549,7 @@ int32 OS_ObjectIdFindNext(uint32 idtype, uint32 *array_index, OS_common_record_t
 void OS_Lock_Global(uint32 idtype)
 {
     int32 return_code;
-    uint32 self_task_id;
+    osal_id_t self_task_id;
     OS_objtype_state_t *objtype;
 
     if (idtype < OS_OBJECT_TYPE_USER)
@@ -567,22 +568,23 @@ void OS_Lock_Global(uint32 idtype)
              * This is done after successfully locking, so this has exclusive access
              * to the state object.
              */
-            if (self_task_id == 0)
+            if ( !OS_ObjectIdDefined(self_task_id) )
             {
                 /*
                  * This just means the calling context is not an OSAL-created task.
                  * This is not necessarily an error, but it should be tracked.
                  * Also note that the root/initial task also does not have an ID.
                  */
-                self_task_id = 0xFFFFFFFF; /* nonzero, but also won't alias a known task */
+                self_task_id = OS_OBJECT_ID_RESERVED; /* nonzero, but also won't alias a known task */
             }
 
-            if (objtype->table_owner != 0)
+            if ( OS_ObjectIdDefined(objtype->table_owner) )
             {
                 /* this is almost certainly a bug */
                 OS_DEBUG("ERROR: global %u acquired by task 0x%lx when already owned by task 0x%lx\n",
-                        (unsigned int)idtype, (unsigned long)self_task_id,
-                        (unsigned long)objtype->table_owner);
+                        (unsigned int)idtype,
+                        OS_ObjectIdToInteger(self_task_id),
+                        OS_ObjectIdToInteger(objtype->table_owner));
             }
             else
             {
@@ -609,7 +611,7 @@ void OS_Lock_Global(uint32 idtype)
 void OS_Unlock_Global(uint32 idtype)
 {
     int32 return_code;
-    uint32 self_task_id;
+    osal_id_t self_task_id;
     OS_objtype_state_t *objtype;
 
     if (idtype < OS_OBJECT_TYPE_USER)
@@ -625,26 +627,27 @@ void OS_Unlock_Global(uint32 idtype)
          * This is done before unlocking, while this has exclusive access
          * to the state object.
          */
-        if (self_task_id == 0)
+        if ( !OS_ObjectIdDefined(self_task_id) )
         {
             /*
              * This just means the calling context is not an OSAL-created task.
              * This is not necessarily an error, but it should be tracked.
              * Also note that the root/initial task also does not have an ID.
              */
-            self_task_id = 0xFFFFFFFF; /* nonzero, but also won't alias a known task */
+            self_task_id = OS_OBJECT_ID_RESERVED; /* nonzero, but also won't alias a known task */
         }
 
-        if (objtype->table_owner != self_task_id)
+        if ( !OS_ObjectIdEqual(objtype->table_owner, self_task_id) )
         {
             /* this is almost certainly a bug */
             OS_DEBUG("ERROR: global %u released by task 0x%lx when owned by task 0x%lx\n",
-                    (unsigned int)idtype, (unsigned long)self_task_id,
-                    (unsigned long)objtype->table_owner);
+                    (unsigned int)idtype,
+                    OS_ObjectIdToInteger(self_task_id),
+                    OS_ObjectIdToInteger(objtype->table_owner));
         }
         else
         {
-            objtype->table_owner = 0;
+            objtype->table_owner = OS_OBJECT_ID_UNDEFINED;
         }
 
         return_code = OS_Unlock_Global_Impl(idtype);
@@ -677,7 +680,7 @@ void OS_Unlock_Global(uint32 idtype)
  *           Otherwise OS_SUCCESS is returned.
  *
  *-----------------------------------------------------------------*/
-int32 OS_ObjectIdToArrayIndex(uint32 idtype, uint32 id, uint32 *ArrayIndex)
+int32 OS_ObjectIdToArrayIndex(uint32 idtype, osal_id_t id, uint32 *ArrayIndex)
 {
    uint32 max_id;
    uint32 obj_index;
@@ -730,9 +733,9 @@ int32 OS_ObjectIdToArrayIndex(uint32 idtype, uint32 id, uint32 *ArrayIndex)
  *           were detected while validating the ID.
  *
  *-----------------------------------------------------------------*/
-int32 OS_ObjectIdFinalizeNew(int32 operation_status, OS_common_record_t *record, uint32 *outid)
+int32 OS_ObjectIdFinalizeNew(int32 operation_status, OS_common_record_t *record, osal_id_t *outid)
 {
-    uint32 idtype = record->active_id >> OS_OBJECT_TYPE_SHIFT;
+    uint32 idtype = OS_ObjectIdToType_Impl(record->active_id);
 
     /* if operation was unsuccessful, then clear
      * the active_id field within the record, so
@@ -743,13 +746,13 @@ int32 OS_ObjectIdFinalizeNew(int32 operation_status, OS_common_record_t *record,
      */
     if (operation_status != OS_SUCCESS)
     {
-        record->active_id = 0;
+        record->active_id = OS_OBJECT_ID_UNDEFINED;
     }
     else if (idtype == 0 || idtype >= OS_OBJECT_TYPE_USER)
     {
         /* should never happen - indicates a bug. */
         operation_status = OS_ERR_INVALID_ID;
-        record->active_id = 0;
+        record->active_id = OS_OBJECT_ID_UNDEFINED;
     }
     else
     {
@@ -782,7 +785,7 @@ int32 OS_ObjectIdFinalizeDelete(int32 operation_status, OS_common_record_t *reco
     /* Clear the OSAL ID if successful - this returns the record to the pool */
     if (operation_status == OS_SUCCESS)
     {
-        record->active_id = 0;
+        record->active_id = OS_OBJECT_ID_UNDEFINED;
     }
 
     /* Either way we must unlock the object type */
@@ -869,7 +872,7 @@ int32 OS_ObjectIdGetByName (OS_lock_mode_t lock_mode, uint32 idtype, const char
  *  returns: OS_ERR_NAME_NOT_FOUND if not found, OS_SUCCESS if match is found
  *
  *-----------------------------------------------------------------*/
-int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, uint32 *object_id)
+int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, osal_id_t *object_id)
 {
     int32 return_code;
     OS_common_record_t *global;
@@ -918,7 +921,7 @@ int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, uint32 *object_id)
  *           If this returns something other than OS_SUCCESS then the global is NOT locked.
  *
  *-----------------------------------------------------------------*/
-int32 OS_ObjectIdGetById(OS_lock_mode_t lock_mode, uint32 idtype, uint32 id, uint32 *array_index, OS_common_record_t **record)
+int32 OS_ObjectIdGetById(OS_lock_mode_t lock_mode, uint32 idtype, osal_id_t id, uint32 *array_index, OS_common_record_t **record)
 {
    int32 return_code;
 
@@ -977,9 +980,9 @@ int32 OS_ObjectIdGetById(OS_lock_mode_t lock_mode, uint32 idtype, uint32 id, uin
 int32 OS_ObjectIdRefcountDecr(OS_common_record_t *record)
 {
    int32 return_code;
-   uint32 idtype = record->active_id >> OS_OBJECT_TYPE_SHIFT;
+   uint32 idtype = OS_ObjectIdToType_Impl(record->active_id);
 
-   if (idtype == 0 || record->active_id == 0)
+   if (idtype == 0 || !OS_ObjectIdDefined(record->active_id))
    {
       return_code = OS_ERR_INVALID_ID;
    }
@@ -1096,7 +1099,7 @@ int32 OS_ObjectIdAllocateNew(uint32 idtype, const char *name, uint32 *array_inde
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_ConvertToArrayIndex(uint32 object_id, uint32 *ArrayIndex)
+int32 OS_ConvertToArrayIndex(osal_id_t object_id, uint32 *ArrayIndex)
 {
     /* just pass to the generic internal conversion routine */
     return OS_ObjectIdToArrayIndex(OS_OBJECT_TYPE_UNDEFINED, object_id, ArrayIndex);
@@ -1111,7 +1114,7 @@ int32 OS_ConvertToArrayIndex(uint32 object_id, uint32 *ArrayIndex)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-void OS_ForEachObject (uint32 creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg)
+void OS_ForEachObject (osal_id_t creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg)
 {
     uint32 idtype;
 
@@ -1129,11 +1132,11 @@ void OS_ForEachObject (uint32 creator_id, OS_ArgCallback_t callback_ptr, void *c
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-void OS_ForEachObjectOfType     (uint32 idtype, uint32 creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg)
+void OS_ForEachObjectOfType     (uint32 idtype, osal_id_t creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg)
 {
     uint32 obj_index;
     uint32 obj_max;
-    uint32 obj_id;
+    osal_id_t obj_id;
 
     obj_max = OS_GetMaxForObjectType(idtype);
     if (obj_max > 0)
@@ -1147,15 +1150,16 @@ void OS_ForEachObjectOfType     (uint32 idtype, uint32 creator_id, OS_ArgCallbac
              * the specified creator_id
              */
             obj_id = OS_common_table[obj_index].active_id;
-            if (obj_id != 0 && creator_id != OS_OBJECT_CREATOR_ANY &&
-                    OS_common_table[obj_index].creator != creator_id)
+            if (OS_ObjectIdDefined(obj_id) &&
+                    !OS_ObjectIdEqual(creator_id, OS_OBJECT_CREATOR_ANY) &&
+                    !OS_ObjectIdEqual(OS_common_table[obj_index].creator, creator_id))
             {
                 /* valid object but not a creator match -
                  * skip the callback for this object */
-                obj_id = 0;
+                obj_id = OS_OBJECT_ID_UNDEFINED;
             }
 
-            if (obj_id != 0)
+            if (OS_ObjectIdDefined(obj_id))
             {
                 /*
                  * Invoke Callback for the object, which must be done
@@ -1188,7 +1192,7 @@ void OS_ForEachObjectOfType     (uint32 idtype, uint32 creator_id, OS_ArgCallbac
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-uint32 OS_IdentifyObject       (uint32 object_id)
+uint32 OS_IdentifyObject       (osal_id_t object_id)
 {
     return OS_ObjectIdToType_Impl(object_id);
 } /* end OS_IdentifyObject */
@@ -1201,7 +1205,7 @@ uint32 OS_IdentifyObject       (uint32 object_id)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_GetResourceName(uint32 object_id, char *buffer, uint32 buffer_size)
+int32 OS_GetResourceName(osal_id_t object_id, char *buffer, uint32 buffer_size)
 {
     uint32 idtype;
     OS_common_record_t *record;
diff --git a/src/os/shared/src/osapi-module.c b/src/os/shared/src/osapi-module.c
index e730ac7cb..ac46c62d2 100644
--- a/src/os/shared/src/osapi-module.c
+++ b/src/os/shared/src/osapi-module.c
@@ -183,7 +183,7 @@ int32 OS_ModuleAPI_Init(void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_ModuleLoad ( uint32 *module_id, const char *module_name, const char *filename )
+int32 OS_ModuleLoad ( osal_id_t *module_id, const char *module_name, const char *filename )
 {
     char        translated_path[OS_MAX_LOCAL_PATH_LEN];
     int32       return_code;
@@ -275,7 +275,7 @@ int32 OS_ModuleLoad ( uint32 *module_id, const char *module_name, const char *fi
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_ModuleUnload ( uint32 module_id )
+int32 OS_ModuleUnload ( osal_id_t module_id )
 {
     OS_common_record_t *record;
     int32             return_code;
@@ -304,7 +304,7 @@ int32 OS_ModuleUnload ( uint32 module_id )
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_ModuleInfo ( uint32 module_id, OS_module_prop_t *module_prop )
+int32 OS_ModuleInfo ( osal_id_t module_id, OS_module_prop_t *module_prop )
 {
     OS_common_record_t *record;
     int32             return_code;
diff --git a/src/os/shared/src/osapi-mutex.c b/src/os/shared/src/osapi-mutex.c
index eb35e079e..f33ff7fad 100644
--- a/src/os/shared/src/osapi-mutex.c
+++ b/src/os/shared/src/osapi-mutex.c
@@ -90,7 +90,7 @@ int32 OS_MutexAPI_Init(void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_MutSemCreate (uint32 *sem_id, const char *sem_name, uint32 options)
+int32 OS_MutSemCreate (osal_id_t *sem_id, const char *sem_name, uint32 options)
 {
    OS_common_record_t *record;
    int32             return_code;
@@ -134,7 +134,7 @@ int32 OS_MutSemCreate (uint32 *sem_id, const char *sem_name, uint32 options)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_MutSemDelete (uint32 sem_id)
+int32 OS_MutSemDelete (osal_id_t sem_id)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -162,7 +162,7 @@ int32 OS_MutSemDelete (uint32 sem_id)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_MutSemGive ( uint32 sem_id )
+int32 OS_MutSemGive ( osal_id_t sem_id )
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -188,7 +188,7 @@ int32 OS_MutSemGive ( uint32 sem_id )
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_MutSemTake ( uint32 sem_id )
+int32 OS_MutSemTake ( osal_id_t sem_id )
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -213,7 +213,7 @@ int32 OS_MutSemTake ( uint32 sem_id )
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_MutSemGetIdByName (uint32 *sem_id, const char *sem_name)
+int32 OS_MutSemGetIdByName (osal_id_t *sem_id, const char *sem_name)
 {
    int32 return_code;
 
@@ -237,7 +237,7 @@ int32 OS_MutSemGetIdByName (uint32 *sem_id, const char *sem_name)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_MutSemGetInfo (uint32 sem_id, OS_mut_sem_prop_t *mut_prop)
+int32 OS_MutSemGetInfo (osal_id_t sem_id, OS_mut_sem_prop_t *mut_prop)
 {
    OS_common_record_t *record;
    int32             return_code;
diff --git a/src/os/shared/src/osapi-printf.c b/src/os/shared/src/osapi-printf.c
index 918511aa4..81c4ef625 100644
--- a/src/os/shared/src/osapi-printf.c
+++ b/src/os/shared/src/osapi-printf.c
@@ -194,7 +194,7 @@ static int32 OS_Console_CopyOut(OS_console_internal_record_t *console, const cha
  *           Write into the console ring buffer
  *
  *-----------------------------------------------------------------*/
-int32 OS_ConsoleWrite(uint32 console_id, const char *Str)
+int32 OS_ConsoleWrite(osal_id_t console_id, const char *Str)
 {
     int32 return_code;
     OS_common_record_t *record;
diff --git a/src/os/shared/src/osapi-queue.c b/src/os/shared/src/osapi-queue.c
index b1e104152..36f838361 100644
--- a/src/os/shared/src/osapi-queue.c
+++ b/src/os/shared/src/osapi-queue.c
@@ -93,7 +93,7 @@ int32 OS_QueueAPI_Init(void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_QueueCreate (uint32 *queue_id, const char *queue_name, uint32 queue_depth, uint32 data_size, uint32 flags)
+int32 OS_QueueCreate (osal_id_t *queue_id, const char *queue_name, uint32 queue_depth, uint32 data_size, uint32 flags)
 {
    OS_common_record_t *record;
    int32             return_code;
@@ -145,7 +145,7 @@ int32 OS_QueueCreate (uint32 *queue_id, const char *queue_name, uint32 queue_dep
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_QueueDelete (uint32 queue_id)
+int32 OS_QueueDelete (osal_id_t queue_id)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -173,7 +173,7 @@ int32 OS_QueueDelete (uint32 queue_id)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_QueueGet (uint32 queue_id, void *data, uint32 size, uint32 *size_copied, int32 timeout)
+int32 OS_QueueGet (osal_id_t queue_id, void *data, uint32 size, uint32 *size_copied, int32 timeout)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -216,7 +216,7 @@ int32 OS_QueueGet (uint32 queue_id, void *data, uint32 size, uint32 *size_copied
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_QueuePut (uint32 queue_id, const void *data, uint32 size, uint32 flags)
+int32 OS_QueuePut (osal_id_t queue_id, const void *data, uint32 size, uint32 flags)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -249,7 +249,7 @@ int32 OS_QueuePut (uint32 queue_id, const void *data, uint32 size, uint32 flags)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_QueueGetIdByName (uint32 *queue_id, const char *queue_name)
+int32 OS_QueueGetIdByName (osal_id_t *queue_id, const char *queue_name)
 {
    int32 return_code;
 
@@ -273,7 +273,7 @@ int32 OS_QueueGetIdByName (uint32 *queue_id, const char *queue_name)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_QueueGetInfo (uint32 queue_id, OS_queue_prop_t *queue_prop)
+int32 OS_QueueGetInfo (osal_id_t queue_id, OS_queue_prop_t *queue_prop)
 {
    OS_common_record_t *record;
    int32             return_code;
diff --git a/src/os/shared/src/osapi-select.c b/src/os/shared/src/osapi-select.c
index 839a70d1a..66a9b75bd 100644
--- a/src/os/shared/src/osapi-select.c
+++ b/src/os/shared/src/osapi-select.c
@@ -60,7 +60,7 @@
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SelectSingle(uint32 objid, uint32 *StateFlags, int32 msecs)
+int32 OS_SelectSingle(osal_id_t objid, uint32 *StateFlags, int32 msecs)
 {
    int32 return_code;
    uint32 local_id;
@@ -125,7 +125,7 @@ int32 OS_SelectFdZero(OS_FdSet *Set)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SelectFdAdd(OS_FdSet *Set, uint32 objid)
+int32 OS_SelectFdAdd(OS_FdSet *Set, osal_id_t objid)
 {
    int32 return_code;
    uint32 local_id;
@@ -149,7 +149,7 @@ int32 OS_SelectFdAdd(OS_FdSet *Set, uint32 objid)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SelectFdClear(OS_FdSet *Set, uint32 objid)
+int32 OS_SelectFdClear(OS_FdSet *Set, osal_id_t objid)
 {
    int32 return_code;
    uint32 local_id;
@@ -173,7 +173,7 @@ int32 OS_SelectFdClear(OS_FdSet *Set, uint32 objid)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-bool OS_SelectFdIsSet(OS_FdSet *Set, uint32 objid)
+bool OS_SelectFdIsSet(OS_FdSet *Set, osal_id_t objid)
 {
    int32 return_code;
    uint32 local_id;
diff --git a/src/os/shared/src/osapi-shell.c b/src/os/shared/src/osapi-shell.c
index 228582d53..86782aaf3 100644
--- a/src/os/shared/src/osapi-shell.c
+++ b/src/os/shared/src/osapi-shell.c
@@ -52,7 +52,7 @@
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_ShellOutputToFile(const char* Cmd, uint32 filedes)
+int32 OS_ShellOutputToFile(const char* Cmd, osal_id_t filedes)
 {
    OS_common_record_t *record;
    uint32 local_id;
diff --git a/src/os/shared/src/osapi-sockets.c b/src/os/shared/src/osapi-sockets.c
index 7f33b94d7..b846b260c 100644
--- a/src/os/shared/src/osapi-sockets.c
+++ b/src/os/shared/src/osapi-sockets.c
@@ -123,7 +123,7 @@ void OS_CreateSocketName(uint32 local_id, const OS_SockAddr_t *Addr, const char
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SocketOpen(uint32 *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t Type)
+int32 OS_SocketOpen(osal_id_t *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t Type)
 {
    OS_common_record_t *record;
    int32             return_code;
@@ -163,7 +163,7 @@ int32 OS_SocketOpen(uint32 *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t T
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SocketBind(uint32 sock_id, const OS_SockAddr_t *Addr)
+int32 OS_SocketBind(osal_id_t sock_id, const OS_SockAddr_t *Addr)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -216,7 +216,7 @@ int32 OS_SocketBind(uint32 sock_id, const OS_SockAddr_t *Addr)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SocketAccept(uint32 sock_id, uint32 *connsock_id, OS_SockAddr_t *Addr, int32 timeout)
+int32 OS_SocketAccept(osal_id_t sock_id, osal_id_t *connsock_id, OS_SockAddr_t *Addr, int32 timeout)
 {
    OS_common_record_t *record;
    OS_common_record_t *connrecord;
@@ -292,7 +292,7 @@ int32 OS_SocketAccept(uint32 sock_id, uint32 *connsock_id, OS_SockAddr_t *Addr,
       else
       {
          /* Clear the connrecord */
-         connrecord->active_id = 0;
+         connrecord->active_id = OS_OBJECT_ID_UNDEFINED;
       }
 
       /* Decrement both ref counters that were increased earlier */
@@ -312,7 +312,7 @@ int32 OS_SocketAccept(uint32 sock_id, uint32 *connsock_id, OS_SockAddr_t *Addr,
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SocketConnect(uint32 sock_id, const OS_SockAddr_t *Addr, int32 Timeout)
+int32 OS_SocketConnect(osal_id_t sock_id, const OS_SockAddr_t *Addr, int32 Timeout)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -369,7 +369,7 @@ int32 OS_SocketConnect(uint32 sock_id, const OS_SockAddr_t *Addr, int32 Timeout)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SocketRecvFrom(uint32 sock_id, void *buffer, uint32 buflen, OS_SockAddr_t *RemoteAddr, int32 timeout)
+int32 OS_SocketRecvFrom(osal_id_t sock_id, void *buffer, uint32 buflen, OS_SockAddr_t *RemoteAddr, int32 timeout)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -412,7 +412,7 @@ int32 OS_SocketRecvFrom(uint32 sock_id, void *buffer, uint32 buflen, OS_SockAddr
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SocketSendTo(uint32 sock_id, const void *buffer, uint32 buflen, const OS_SockAddr_t *RemoteAddr)
+int32 OS_SocketSendTo(osal_id_t sock_id, const void *buffer, uint32 buflen, const OS_SockAddr_t *RemoteAddr)
 {
    OS_common_record_t *record;
    uint32 local_id;
@@ -451,7 +451,7 @@ int32 OS_SocketSendTo(uint32 sock_id, const void *buffer, uint32 buflen, const O
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SocketGetIdByName (uint32 *sock_id, const char *sock_name)
+int32 OS_SocketGetIdByName (osal_id_t *sock_id, const char *sock_name)
 {
    int32 return_code;
 
@@ -474,7 +474,7 @@ int32 OS_SocketGetIdByName (uint32 *sock_id, const char *sock_name)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_SocketGetInfo (uint32 sock_id, OS_socket_prop_t *sock_prop)
+int32 OS_SocketGetInfo (osal_id_t sock_id, OS_socket_prop_t *sock_prop)
 {
    OS_common_record_t *record;
    uint32 local_id;
diff --git a/src/os/shared/src/osapi-task.c b/src/os/shared/src/osapi-task.c
index a041db4f3..c28a4bf37 100644
--- a/src/os/shared/src/osapi-task.c
+++ b/src/os/shared/src/osapi-task.c
@@ -83,7 +83,7 @@ OS_task_internal_record_t    OS_task_table          [LOCAL_NUM_OBJECTS];
  *
  *
  *-----------------------------------------------------------------*/
-static int32 OS_TaskPrepare(uint32 task_id, osal_task_entry *entrypt)
+static int32 OS_TaskPrepare(osal_id_t task_id, osal_task_entry *entrypt)
 {
    int32 return_code;
    uint32 local_id;
@@ -102,7 +102,7 @@ static int32 OS_TaskPrepare(uint32 task_id, osal_task_entry *entrypt)
       /*
        * Verify that we still appear to own the table entry
        */
-      if (OS_global_task_table[local_id].active_id != task_id)
+      if ( !OS_ObjectIdEqual(OS_global_task_table[local_id].active_id, task_id)  )
       {
           return_code = OS_ERR_INVALID_ID;
       }
@@ -140,7 +140,7 @@ static int32 OS_TaskPrepare(uint32 task_id, osal_task_entry *entrypt)
  *           call the user's intended entry point function.
  *
  *-----------------------------------------------------------------*/
-void OS_TaskEntryPoint(uint32 task_id)
+void OS_TaskEntryPoint(osal_id_t task_id)
 {
     osal_task_entry task_entry;
 
@@ -186,7 +186,7 @@ int32 OS_TaskAPI_Init(void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TaskCreate (uint32 *task_id, const char *task_name, osal_task_entry function_pointer,
+int32 OS_TaskCreate (osal_id_t *task_id, const char *task_name, osal_task_entry function_pointer,
                       uint32 *stack_pointer, uint32 stack_size, uint32 priority, uint32 flags)
 {
    OS_common_record_t *record;
@@ -255,7 +255,7 @@ int32 OS_TaskCreate (uint32 *task_id, const char *task_name, osal_task_entry fun
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TaskDelete (uint32 task_id)
+int32 OS_TaskDelete (osal_id_t task_id)
 {
    OS_common_record_t *record;
    int32             return_code;
@@ -298,7 +298,7 @@ int32 OS_TaskDelete (uint32 task_id)
 void OS_TaskExit()
 {
    OS_common_record_t *record;
-   uint32 task_id;
+   osal_id_t task_id;
    uint32 local_id;
 
    task_id = OS_TaskGetId_Impl();
@@ -338,7 +338,7 @@ int32 OS_TaskDelay(uint32 millisecond)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TaskSetPriority (uint32 task_id, uint32 new_priority)
+int32 OS_TaskSetPriority (osal_id_t task_id, uint32 new_priority)
 {
    OS_common_record_t *record;
    int32             return_code;
@@ -401,11 +401,11 @@ int32 OS_TaskRegister (void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-uint32 OS_TaskGetId (void)
+osal_id_t OS_TaskGetId (void)
 {
    OS_common_record_t *record;
    uint32 local_id;
-   uint32 task_id;
+   osal_id_t task_id;
 
    task_id = OS_TaskGetId_Impl();
 
@@ -413,7 +413,7 @@ uint32 OS_TaskGetId (void)
     * If not it means we have some stale/leftover value */
    if (OS_ObjectIdGetById(OS_LOCK_MODE_NONE, LOCAL_OBJID_TYPE, task_id, &local_id, &record) != OS_SUCCESS)
    {
-      task_id = 0;
+      task_id = OS_OBJECT_ID_UNDEFINED;
    }
 
    return(task_id);
@@ -428,7 +428,7 @@ uint32 OS_TaskGetId (void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TaskGetIdByName (uint32 *task_id, const char *task_name)
+int32 OS_TaskGetIdByName (osal_id_t *task_id, const char *task_name)
 {
    int32 return_code;
 
@@ -452,7 +452,7 @@ int32 OS_TaskGetIdByName (uint32 *task_id, const char *task_name)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TaskGetInfo (uint32 task_id, OS_task_prop_t *task_prop)
+int32 OS_TaskGetInfo (osal_id_t task_id, OS_task_prop_t *task_prop)
 {
    OS_common_record_t *record;
    int32             return_code;
@@ -501,7 +501,7 @@ int32 OS_TaskInstallDeleteHandler(osal_task_entry function_pointer)
    OS_common_record_t *record;
    int32 return_code;
    uint32 local_id;
-   uint32 task_id;
+   osal_id_t task_id;
 
    task_id = OS_TaskGetId_Impl();
    return_code = OS_ObjectIdGetById(OS_LOCK_MODE_GLOBAL, LOCAL_OBJID_TYPE, task_id, &local_id, &record);
@@ -526,7 +526,7 @@ int32 OS_TaskInstallDeleteHandler(osal_task_entry function_pointer)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TaskFindIdBySystemData(uint32 *task_id, const void *sysdata, size_t sysdata_size)
+int32 OS_TaskFindIdBySystemData(osal_id_t *task_id, const void *sysdata, size_t sysdata_size)
 {
     int32 return_code;
     OS_common_record_t *record;
diff --git a/src/os/shared/src/osapi-time.c b/src/os/shared/src/osapi-time.c
index 31b76c8df..f4c4b7300 100644
--- a/src/os/shared/src/osapi-time.c
+++ b/src/os/shared/src/osapi-time.c
@@ -93,7 +93,7 @@ int32 OS_TimerCbAPI_Init(void)
  *  Return:     OS_SUCCESS or error code
  *
  *-----------------------------------------------------------------*/
-static int32 OS_DoTimerAdd(uint32 *timer_id, const char *timer_name, uint32 timebase_ref_id, OS_ArgCallback_t  callback_ptr, void *callback_arg, uint32 flags)
+static int32 OS_DoTimerAdd(osal_id_t *timer_id, const char *timer_name, osal_id_t timebase_ref_id, OS_ArgCallback_t  callback_ptr, void *callback_arg, uint32 flags)
 {
     OS_common_record_t *timebase;
     OS_common_record_t *record;
@@ -101,7 +101,7 @@ static int32 OS_DoTimerAdd(uint32 *timer_id, const char *timer_name, uint32 time
     int32             return_code;
     uint32            local_id;
     uint32            timebase_local_id;
-    uint32            cb_list;
+    osal_id_t         cb_list;
     uint32            attach_id;
 
     /*
@@ -133,7 +133,7 @@ static int32 OS_DoTimerAdd(uint32 *timer_id, const char *timer_name, uint32 time
      * Check our context.  Not allowed to use the timer API from a timer callback.
      * Just interested in the object type returned.
      */
-    local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+    local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
     if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
     {
         return OS_ERR_INCORRECT_OBJ_STATE;
@@ -177,7 +177,7 @@ static int32 OS_DoTimerAdd(uint32 *timer_id, const char *timer_name, uint32 time
        cb_list = OS_timebase_table[timebase_local_id].first_cb;
        OS_timebase_table[timebase_local_id].first_cb = record->active_id;
 
-       if (cb_list != 0)
+       if ( OS_ObjectIdDefined(cb_list) )
        {
            OS_ObjectIdToArrayIndex(OS_OBJECT_TYPE_OS_TIMECB, cb_list, &attach_id);
            local->next_ref = attach_id;
@@ -208,7 +208,7 @@ static int32 OS_DoTimerAdd(uint32 *timer_id, const char *timer_name, uint32 time
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimerAdd(uint32 *timer_id, const char *timer_name, uint32 timebase_ref_id, OS_ArgCallback_t  callback_ptr, void *callback_arg)
+int32 OS_TimerAdd(osal_id_t *timer_id, const char *timer_name, osal_id_t timebase_ref_id, OS_ArgCallback_t  callback_ptr, void *callback_arg)
 {
     return (OS_DoTimerAdd(timer_id, timer_name, timebase_ref_id, callback_ptr, callback_arg, 0));
 } /* end OS_TimerAdd */
@@ -222,7 +222,7 @@ int32 OS_TimerAdd(uint32 *timer_id, const char *timer_name, uint32 timebase_ref_
  *  Purpose: Local helper routine, not part of OSAL API.
  *
  *-----------------------------------------------------------------*/
-static void OS_Timer_NoArgCallback(uint32 objid, void *arg)
+static void OS_Timer_NoArgCallback(osal_id_t objid, void *arg)
 {
     OS_U32ValueWrapper_t Conv;
 
@@ -243,10 +243,10 @@ static void OS_Timer_NoArgCallback(uint32 objid, void *arg)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimerCreate(uint32 *timer_id, const char *timer_name, uint32 *accuracy, OS_TimerCallback_t  callback_ptr)
+int32 OS_TimerCreate(osal_id_t *timer_id, const char *timer_name, uint32 *accuracy, OS_TimerCallback_t  callback_ptr)
 {
     int32             return_code;
-    uint32            timebase_ref_id;
+    osal_id_t         timebase_ref_id;
     OS_U32ValueWrapper_t Conv;
 
     /*
@@ -316,15 +316,15 @@ int32 OS_TimerCreate(uint32 *timer_id, const char *timer_name, uint32 *accuracy,
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimerSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
+int32 OS_TimerSet(osal_id_t timer_id, uint32 start_time, uint32 interval_time)
 {
    OS_common_record_t *record;
    OS_timecb_internal_record_t *local;
    int32             return_code;
    uint32            local_id;
-   uint32            dedicated_timebase_id;
+   osal_id_t         dedicated_timebase_id;
 
-   dedicated_timebase_id = 0;
+   dedicated_timebase_id = OS_OBJECT_ID_UNDEFINED;
 
    if (start_time >= (UINT32_MAX/2) || interval_time >= (UINT32_MAX/2))
    {
@@ -340,7 +340,7 @@ int32 OS_TimerSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
     * Check our context.  Not allowed to use the timer API from a timer callback.
     * Just interested in the object type returned.
     */
-   local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+   local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
    if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
    {
        return OS_ERR_INCORRECT_OBJ_STATE;
@@ -381,7 +381,7 @@ int32 OS_TimerSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
     * will get applied before the old timer expires.  Therefore by definition an application
     * MUST be able to handle a possible "spurious" callback in these circumstances.
     */
-   if (return_code == OS_SUCCESS && dedicated_timebase_id != 0)
+   if (return_code == OS_SUCCESS && OS_ObjectIdDefined(dedicated_timebase_id))
    {
        return_code = OS_TimeBaseSet(dedicated_timebase_id, start_time, interval_time);
    }
@@ -398,22 +398,22 @@ int32 OS_TimerSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimerDelete(uint32 timer_id)
+int32 OS_TimerDelete(osal_id_t timer_id)
 {
     OS_timecb_internal_record_t *local;
     OS_common_record_t *record;
     OS_common_record_t *timebase = NULL;
     int32             return_code;
     uint32            local_id;
-    uint32            dedicated_timebase_id;
+    osal_id_t         dedicated_timebase_id;
 
-    dedicated_timebase_id = 0;
+    dedicated_timebase_id = OS_OBJECT_ID_UNDEFINED;
 
     /*
      * Check our context.  Not allowed to use the timer API from a timer callback.
      * Just interested in the object type returned.
      */
-    local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+    local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
     if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
     {
         return OS_ERR_INCORRECT_OBJ_STATE;
@@ -439,7 +439,7 @@ int32 OS_TimerDelete(uint32 timer_id)
         /*
          * Now we need to remove it from the time base callback ring
          */
-        if (OS_timebase_table[local->timebase_ref].first_cb == timer_id)
+        if (OS_ObjectIdEqual(OS_timebase_table[local->timebase_ref].first_cb, timer_id))
         {
             if (local->next_ref != local_id)
             {
@@ -450,7 +450,7 @@ int32 OS_TimerDelete(uint32 timer_id)
                 /*
                  * consider the list empty
                  */
-                OS_timebase_table[local->timebase_ref].first_cb = 0;
+                OS_timebase_table[local->timebase_ref].first_cb = OS_OBJECT_ID_UNDEFINED;
             }
         }
 
@@ -475,7 +475,7 @@ int32 OS_TimerDelete(uint32 timer_id)
     if (return_code == OS_SUCCESS)
     {
         OS_ObjectIdRefcountDecr(timebase);
-        if (dedicated_timebase_id != 0)
+        if ( OS_ObjectIdDefined(dedicated_timebase_id) )
         {
             OS_TimeBaseDelete(dedicated_timebase_id);
         }
@@ -493,7 +493,7 @@ int32 OS_TimerDelete(uint32 timer_id)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimerGetIdByName (uint32 *timer_id, const char *timer_name)
+int32 OS_TimerGetIdByName (osal_id_t *timer_id, const char *timer_name)
 {
     int32 return_code;
     uint32 local_id;
@@ -507,7 +507,7 @@ int32 OS_TimerGetIdByName (uint32 *timer_id, const char *timer_name)
      * Check our context.  Not allowed to use the timer API from a timer callback.
      * Just interested in the object type returned.
      */
-    local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+    local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
     if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
     {
         return OS_ERR_INCORRECT_OBJ_STATE;
@@ -528,7 +528,7 @@ int32 OS_TimerGetIdByName (uint32 *timer_id, const char *timer_name)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimerGetInfo (uint32 timer_id, OS_timer_prop_t *timer_prop)
+int32 OS_TimerGetInfo (osal_id_t timer_id, OS_timer_prop_t *timer_prop)
 {
     OS_common_record_t *record;
     int32             return_code;
@@ -544,7 +544,7 @@ int32 OS_TimerGetInfo (uint32 timer_id, OS_timer_prop_t *timer_prop)
      * Check our context.  Not allowed to use the timer API from a timer callback.
      * Just interested in the object type returned.
      */
-    local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+    local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
     if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
     {
         return OS_ERR_INCORRECT_OBJ_STATE;
diff --git a/src/os/shared/src/osapi-timebase.c b/src/os/shared/src/osapi-timebase.c
index 44b5d9f97..e1bd46dae 100644
--- a/src/os/shared/src/osapi-timebase.c
+++ b/src/os/shared/src/osapi-timebase.c
@@ -103,7 +103,7 @@ int32 OS_TimeBaseAPI_Init(void)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimeBaseCreate(uint32 *timer_id, const char *timebase_name, OS_TimerSync_t external_sync)
+int32 OS_TimeBaseCreate(osal_id_t *timer_id, const char *timebase_name, OS_TimerSync_t external_sync)
 {
     OS_common_record_t *record;
     int32             return_code;
@@ -135,7 +135,7 @@ int32 OS_TimeBaseCreate(uint32 *timer_id, const char *timebase_name, OS_TimerSyn
      * Check our context.  Not allowed to use the timer API from a timer callback.
      * Just interested in the object type returned.
      */
-    local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+    local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
     if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
     {
         return OS_ERR_INCORRECT_OBJ_STATE;
@@ -178,7 +178,7 @@ int32 OS_TimeBaseCreate(uint32 *timer_id, const char *timebase_name, OS_TimerSyn
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimeBaseSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
+int32 OS_TimeBaseSet(osal_id_t timer_id, uint32 start_time, uint32 interval_time)
 {
     OS_common_record_t *record;
     int32             return_code;
@@ -201,7 +201,7 @@ int32 OS_TimeBaseSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
      * Check our context.  Not allowed to use the timer API from a timer callback.
      * Just interested in the object type returned.
      */
-    local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+    local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
     if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
     {
         return OS_ERR_INCORRECT_OBJ_STATE;
@@ -239,7 +239,7 @@ int32 OS_TimeBaseSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimeBaseDelete(uint32 timer_id)
+int32 OS_TimeBaseDelete(osal_id_t timer_id)
 {
     OS_common_record_t *record;
     int32             return_code;
@@ -249,7 +249,7 @@ int32 OS_TimeBaseDelete(uint32 timer_id)
      * Check our context.  Not allowed to use the timer API from a timer callback.
      * Just interested in the object type returned.
      */
-    local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+    local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
     if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
     {
         return OS_ERR_INCORRECT_OBJ_STATE;
@@ -276,7 +276,7 @@ int32 OS_TimeBaseDelete(uint32 timer_id)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimeBaseGetIdByName (uint32 *timer_id, const char *timebase_name)
+int32 OS_TimeBaseGetIdByName (osal_id_t *timer_id, const char *timebase_name)
 {
     int32 return_code;
     uint32 local_id;
@@ -290,7 +290,7 @@ int32 OS_TimeBaseGetIdByName (uint32 *timer_id, const char *timebase_name)
      * Check our context.  Not allowed to use the timer API from a timer callback.
      * Just interested in the object type returned.
      */
-    local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+    local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
     if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
     {
         return OS_ERR_INCORRECT_OBJ_STATE;
@@ -311,7 +311,7 @@ int32 OS_TimeBaseGetIdByName (uint32 *timer_id, const char *timebase_name)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimeBaseGetInfo (uint32 timebase_id, OS_timebase_prop_t *timebase_prop)
+int32 OS_TimeBaseGetInfo (osal_id_t timebase_id, OS_timebase_prop_t *timebase_prop)
 {
     OS_common_record_t *record;
     int32             return_code;
@@ -327,7 +327,7 @@ int32 OS_TimeBaseGetInfo (uint32 timebase_id, OS_timebase_prop_t *timebase_prop)
      * Check our context.  Not allowed to use the timer API from a timer callback.
      * Just interested in the object type returned.
      */
-    local_id = OS_TaskGetId_Impl() >> OS_OBJECT_TYPE_SHIFT;
+    local_id = OS_ObjectIdToType_Impl(OS_TaskGetId_Impl());
     if (local_id == OS_OBJECT_TYPE_OS_TIMEBASE)
     {
         return OS_ERR_INCORRECT_OBJ_STATE;
@@ -361,7 +361,7 @@ int32 OS_TimeBaseGetInfo (uint32 timebase_id, OS_timebase_prop_t *timebase_prop)
  *           See description in API and header file for detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TimeBaseGetFreeRun     (uint32 timebase_id, uint32 *freerun_val)
+int32 OS_TimeBaseGetFreeRun     (osal_id_t timebase_id, uint32 *freerun_val)
 {
     OS_common_record_t *record;
     int32             return_code;
@@ -396,7 +396,7 @@ int32 OS_TimeBaseGetFreeRun     (uint32 timebase_id, uint32 *freerun_val)
  *          available C library calls are very limited in that context.
  *
  *-----------------------------------------------------------------*/
-void OS_TimeBase_CallbackThread(uint32 timebase_id)
+void OS_TimeBase_CallbackThread(osal_id_t timebase_id)
 {
     OS_TimerSync_t syncfunc;
     OS_timebase_internal_record_t *timebase;
@@ -405,7 +405,7 @@ void OS_TimeBase_CallbackThread(uint32 timebase_id)
     uint32 local_id;
     uint32 timer_id;
     uint32 curr_cb_local_id;
-    uint32 curr_cb_public_id;
+    osal_id_t curr_cb_public_id;
     uint32 tick_time;
     uint32 spin_cycles;
     int32 saved_wait_time;
@@ -485,7 +485,7 @@ void OS_TimeBase_CallbackThread(uint32 timebase_id)
          * After waiting, check that our ID still matches
          * If not then it means this time base got deleted....
          */
-        if (timebase_id != record->active_id)
+        if ( !OS_ObjectIdEqual(timebase_id, record->active_id) )
         {
             OS_TimeBaseUnlock_Impl(local_id);
             break;
diff --git a/src/os/vxworks/inc/os-vxworks.h b/src/os/vxworks/inc/os-vxworks.h
index ecd310533..0cfe299f5 100644
--- a/src/os/vxworks/inc/os-vxworks.h
+++ b/src/os/vxworks/inc/os-vxworks.h
@@ -59,6 +59,19 @@ typedef struct
     SEM_ID vxid;
 } VxWorks_GlobalMutex_t;
 
+/*
+ * Union to facilitate passing an osal_id_t through
+ * a function/api designed to take an "int"
+ *
+ * This relies on sizeof(int) >= sizeof(osal_id_t)
+ */
+typedef union
+{
+    osal_id_t id;
+    int arg;
+} VxWorks_ID_Buffer_t;
+
+
 /****************************************************************************************
                                    GLOBAL DATA
 ****************************************************************************************/
diff --git a/src/os/vxworks/src/os-impl-shell.c b/src/os/vxworks/src/os-impl-shell.c
index ad3379d97..42219f943 100644
--- a/src/os/vxworks/src/os-impl-shell.c
+++ b/src/os/vxworks/src/os-impl-shell.c
@@ -32,6 +32,7 @@
 #include "os-vxworks.h"
 #include "os-impl-io.h"
 #include "os-shared-shell.h"
+#include "os-shared-file.h"
 
 #include <shellLib.h>
 #include <taskLib.h>
@@ -57,16 +58,16 @@ int32 OS_ShellOutputToFile_Impl(uint32 file_id, const char *Cmd)
 {
     int32 ReturnCode = OS_ERROR;
     int32 Result = ERROR;
-    int32 fdCmd;
+    osal_id_t fdCmd;
     uint32 cmdidx;
     char * shellName;
 
     /* Create a file to write the command to (or write over the old one) */
-    fdCmd = OS_creat(OS_SHELL_CMD_INPUT_FILE_NAME,OS_READ_WRITE);
+    Result = OS_OpenCreate(&fdCmd, OS_SHELL_CMD_INPUT_FILE_NAME, OS_FILE_FLAG_CREATE | OS_FILE_FLAG_TRUNCATE, OS_READ_WRITE);
 
-    if (fdCmd < OS_SUCCESS)
+    if (Result < OS_SUCCESS)
     {
-        return OS_ERROR;
+        return Result;
     }
 
     if (OS_ConvertToArrayIndex(fdCmd, &cmdidx) == OS_SUCCESS)
diff --git a/src/os/vxworks/src/os-impl-tasks.c b/src/os/vxworks/src/os-impl-tasks.c
index a764e5423..8998f92ae 100644
--- a/src/os/vxworks/src/os-impl-tasks.c
+++ b/src/os/vxworks/src/os-impl-tasks.c
@@ -82,7 +82,12 @@ OS_impl_task_internal_record_t  OS_impl_task_table      [OS_MAX_TASKS];
 ---------------------------------------------------------------------------------------*/
 int OS_VxWorks_TaskEntry(int arg)
 {
-    OS_TaskEntryPoint((uint32)arg);
+    VxWorks_ID_Buffer_t id;
+
+    id.arg = arg;
+
+    OS_TaskEntryPoint(id.id);
+
     return 0;
 } /* end OS_VxWorksEntry */
 
@@ -124,6 +129,7 @@ int32 OS_TaskCreate_Impl (uint32 task_id, uint32 flags)
     long userstackbase;
     long actualstackbase;
     OS_impl_task_internal_record_t *lrec;
+    VxWorks_ID_Buffer_t id;
 
     lrec = &OS_impl_task_table[task_id];
 
@@ -236,6 +242,7 @@ int32 OS_TaskCreate_Impl (uint32 task_id, uint32 flags)
     actualstackbase  += actualsz;         /* move to last byte of stack block */
 #endif
 
+    id.id = OS_global_task_table[task_id].active_id;
     status = taskInit(
             &lrec->tcb,                 /* address of new task's TCB */
             (char*)OS_global_task_table[task_id].name_entry,
@@ -244,7 +251,7 @@ int32 OS_TaskCreate_Impl (uint32 task_id, uint32 flags)
             (char *)actualstackbase,    /* base of new task's stack */
             actualsz,                   /* size (bytes) of stack needed */
             (FUNCPTR)OS_VxWorks_TaskEntry,           /* entry point of new task */
-            OS_global_task_table[task_id].active_id, /* 1st arg is ID */
+            id.arg,                     /* 1st arg is ID */
             0,0,0,0,0,0,0,0,0);
 
     if (status != OK)
@@ -380,7 +387,7 @@ int32 OS_TaskMatch_Impl(uint32 task_id)
  *           See prototype for argument/return detail
  *
  *-----------------------------------------------------------------*/
-int32 OS_TaskRegister_Impl (uint32 global_task_id)
+int32 OS_TaskRegister_Impl (osal_id_t global_task_id)
 {
     return OS_SUCCESS;
 } /* end OS_TaskRegister_Impl */
@@ -394,13 +401,13 @@ int32 OS_TaskRegister_Impl (uint32 global_task_id)
  *           See prototype for argument/return detail
  *
  *-----------------------------------------------------------------*/
-uint32 OS_TaskGetId_Impl (void)
+osal_id_t OS_TaskGetId_Impl (void)
 {
     OS_impl_task_internal_record_t *lrec;
     size_t index;
-    uint32 id;
+    osal_id_t id;
 
-    id = 0;
+    id = OS_OBJECT_ID_UNDEFINED;
     lrec = (OS_impl_task_internal_record_t *)taskTcb(taskIdSelf());
 
     if (lrec != NULL)
diff --git a/src/os/vxworks/src/os-impl-timebase.c b/src/os/vxworks/src/os-impl-timebase.c
index 1ffa53e0d..9c618aebf 100644
--- a/src/os/vxworks/src/os-impl-timebase.c
+++ b/src/os/vxworks/src/os-impl-timebase.c
@@ -150,7 +150,7 @@ uint32 OS_VxWorks_SigWait(uint32 local_id)
 {
     OS_impl_timebase_internal_record_t *local;
     OS_common_record_t *global;
-    uint32 active_id;
+    osal_id_t active_id;
     uint32 tick_time;
     int signo;
     int ret;
@@ -160,7 +160,7 @@ uint32 OS_VxWorks_SigWait(uint32 local_id)
     active_id = global->active_id;
     tick_time = 0;
 
-    if (active_id != 0 && local->assigned_signal > 0)
+    if (OS_ObjectIdDefined(active_id) && local->assigned_signal > 0)
     {
         /*
          * Pend for the tick arrival
@@ -186,7 +186,7 @@ uint32 OS_VxWorks_SigWait(uint32 local_id)
          * are generally not comparable.
          */
         if (ret == OK && signo == local->assigned_signal &&
-                global->active_id == active_id)
+                OS_ObjectIdEqual(global->active_id, active_id))
         {
             if (local->reset_flag)
             {
@@ -262,12 +262,14 @@ void OS_VxWorks_RegisterTimer(uint32 local_id)
  *-----------------------------------------------------------------*/
 int OS_VxWorks_TimeBaseTask(int arg)
 {
+    VxWorks_ID_Buffer_t id;
     uint32 local_id;
 
-    if (OS_ConvertToArrayIndex(arg, &local_id) == OS_SUCCESS)
+    id.arg = arg;
+    if (OS_ConvertToArrayIndex(id.id, &local_id) == OS_SUCCESS)
     {
         OS_VxWorks_RegisterTimer(local_id);
-        OS_TimeBase_CallbackThread(arg);
+        OS_TimeBase_CallbackThread(id.id);
     }
 
     return 0;
@@ -349,7 +351,7 @@ int32 OS_TimeBaseCreate_Impl(uint32 timer_id)
     int signo;
     sigset_t inuse;
     uint32 i;
-
+    VxWorks_ID_Buffer_t idbuf;
 
     return_code = OS_SUCCESS;
     local = &OS_impl_timebase_table[timer_id];
@@ -383,7 +385,7 @@ int32 OS_TimeBaseCreate_Impl(uint32 timer_id)
 
         for(i = 0; i < OS_MAX_TIMEBASES; ++i)
         {
-            if (OS_global_timebase_table[i].active_id != 0 &&
+            if (OS_ObjectIdDefined(OS_global_timebase_table[i].active_id) &&
                     OS_impl_timebase_table[i].assigned_signal > 0)
             {
                 /* mark signal as in-use */
@@ -459,13 +461,14 @@ int32 OS_TimeBaseCreate_Impl(uint32 timer_id)
      */
     if (return_code == OS_SUCCESS)
     {
+        idbuf.id = global->active_id;
         local->handler_task = taskSpawn(
                 (char*)global->name_entry,
                 OSAL_TIMEBASE_TASK_PRIORITY,    /* priority */
                 OSAL_TIMEBASE_TASK_OPTION_WORD, /* task option word */
                 OSAL_TIMEBASE_TASK_STACK_SIZE,  /* size (bytes) of stack needed */
                 (FUNCPTR)OS_VxWorks_TimeBaseTask,
-                global->active_id, /* 1st arg is ID */
+                idbuf.arg,                      /* 1st arg is ID */
                 0,0,0,0,0,0,0,0,0);
 
         /* check if taskSpawn failed */
diff --git a/src/tests/bin-sem-flush-test/bin-sem-flush-test.c b/src/tests/bin-sem-flush-test/bin-sem-flush-test.c
index df9b55914..cd98c9733 100644
--- a/src/tests/bin-sem-flush-test/bin-sem-flush-test.c
+++ b/src/tests/bin-sem-flush-test/bin-sem-flush-test.c
@@ -39,21 +39,21 @@ void BinSemFlushTeardown(void);
 #define TASK_3_PRIORITY  120
 
 uint32 task_1_stack[TASK_STACK_SIZE];
-uint32 task_1_id; 
+osal_id_t task_1_id;
 uint32 task_1_failures;
 uint32 task_1_work;
 
 uint32 task_2_stack[TASK_STACK_SIZE];
-uint32 task_2_id; 
+osal_id_t task_2_id;
 uint32 task_2_failures;
 uint32 task_2_work;
 
 uint32 task_3_stack[TASK_STACK_SIZE];
-uint32 task_3_id;
+osal_id_t task_3_id;
 uint32 task_3_failures;
 uint32 task_3_work;
 
-uint32 bin_sem_id;
+osal_id_t bin_sem_id;
 
 void task_1(void)
 {
@@ -209,7 +209,8 @@ void BinSemFlushSetup(void)
    ** Create the binary semaphore
    */
    status = OS_BinSemCreate( &bin_sem_id, "BinSem1", 1, 0);
-   UtAssert_True(status == OS_SUCCESS, "BinSem1 create Id=%u Rc=%d", (unsigned int)bin_sem_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "BinSem1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(bin_sem_id), (int)status);
 
    status = OS_BinSemGetInfo (bin_sem_id, &bin_sem_prop);
    UtAssert_True(status == OS_SUCCESS, "BinSem1 value=%d Rc=%d", (int)bin_sem_prop.value, (int)status);
@@ -226,13 +227,16 @@ void BinSemFlushSetup(void)
    ** Create the tasks
    */
    status = OS_TaskCreate( &task_1_id, "Task 1", task_1, task_1_stack, TASK_STACK_SIZE, TASK_1_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%u Rc=%d", (unsigned int)task_1_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_1_id), (int)status);
 
    status = OS_TaskCreate( &task_2_id, "Task 2", task_2, task_2_stack, TASK_STACK_SIZE, TASK_2_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 2 create Id=%u Rc=%d", (unsigned int)task_2_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 2 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_2_id), (int)status);
  
    status = OS_TaskCreate( &task_3_id, "Task 3", task_3, task_3_stack, TASK_STACK_SIZE, TASK_3_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 3 create Id=%u Rc=%d", (unsigned int)task_3_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 3 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_3_id), (int)status);
 
    /* 
    ** Delay, then check the status
diff --git a/src/tests/bin-sem-test/bin-sem-test.c b/src/tests/bin-sem-test/bin-sem-test.c
index 03ac84850..916d9ae2d 100644
--- a/src/tests/bin-sem-test/bin-sem-test.c
+++ b/src/tests/bin-sem-test/bin-sem-test.c
@@ -46,16 +46,16 @@ void BinSemCheck(void);
 #define TASK_EXIT   0x004
 
 uint32 task_1_stack[TASK_1_STACK_SIZE];
-uint32 task_1_id;
+osal_id_t task_1_id;
 uint32 task_1_failures;
 uint32 task_2_stack[TASK_2_STACK_SIZE];
-uint32 task_2_id;
+osal_id_t task_2_id;
 uint32 timer_failures;
 
-uint32 bin_sem_id;
+osal_id_t bin_sem_id;
 
 uint32 timer_counter;
-uint32 timer_id;
+osal_id_t timer_id;
 uint32 timer_start = 1000;
 uint32 timer_interval = 10000; /* 1000 = 1000 hz, 10000 == 100 hz */
 uint32 timer_accuracy;
@@ -68,7 +68,7 @@ int    counter = 0;
  *
  * On RTEMS even a call to BinSemGetInfo has very ill effects.
  */
-void TimerFunction(uint32 timer_id)
+void TimerFunction(osal_id_t timer_id)
 {
    int32              status;
   
@@ -211,7 +211,8 @@ void BinSemSetup(void)
     ** Create the binary semaphore
     */
     status = OS_BinSemCreate( &bin_sem_id, "BinSem1", 1, 0);
-    UtAssert_True(status == OS_SUCCESS, "BinSem1 create Id=%u Rc=%d", (unsigned int)bin_sem_id, (int)status);
+    UtAssert_True(status == OS_SUCCESS, "BinSem1 create Id=%lx Rc=%d",
+            OS_ObjectIdToInteger(bin_sem_id), (int)status);
 
     status = OS_BinSemGetInfo (bin_sem_id, &bin_sem_prop);
     UtAssert_True(status == OS_SUCCESS, "BinSem1 value=%d Rc=%d", (int)bin_sem_prop.value, (int)status);
@@ -228,13 +229,15 @@ void BinSemSetup(void)
     ** Create the "consumer" task.
     */
     status = OS_TaskCreate( &task_1_id, "Task 1", task_1, task_1_stack, TASK_1_STACK_SIZE, TASK_1_PRIORITY, 0);
-    UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%u Rc=%d", (unsigned int)task_1_id, (int)status);
+    UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%lx Rc=%d",
+            OS_ObjectIdToInteger(task_1_id), (int)status);
 
     /*
     ** Create a timer
     */
     status = OS_TimerCreate(&timer_id, "Timer 1", &accuracy, &(TimerFunction));
-    UtAssert_True(status == OS_SUCCESS, "Timer 1 create Id=%u Rc=%d", (unsigned int)timer_id, (int)status);
+    UtAssert_True(status == OS_SUCCESS, "Timer 1 create Id=%lx Rc=%d",
+            OS_ObjectIdToInteger(timer_id), (int)status);
     UtPrintf("Timer Accuracy = %u microseconds \n",(unsigned int)accuracy);
 
     /*
diff --git a/src/tests/bin-sem-timeout-test/bin-sem-timeout-test.c b/src/tests/bin-sem-timeout-test/bin-sem-timeout-test.c
index 6a4dd65b4..fc7d4dc05 100644
--- a/src/tests/bin-sem-timeout-test/bin-sem-timeout-test.c
+++ b/src/tests/bin-sem-timeout-test/bin-sem-timeout-test.c
@@ -40,17 +40,17 @@ void BinSemTimeoutCheck(void);
 #define TASK_2_PRIORITY   50
 
 uint32 task_1_stack[TASK_1_STACK_SIZE];
-uint32 task_1_id; 
+osal_id_t task_1_id;
 uint32 task_1_timeouts;
 uint32 task_1_work;
 uint32 task_1_failures;
 uint32 task_2_stack[TASK_2_STACK_SIZE];
-uint32 task_2_id;
+osal_id_t task_2_id;
 
-uint32 bin_sem_id;
+osal_id_t bin_sem_id;
 
 uint32 timer_counter;
-uint32 timer_id;
+osal_id_t timer_id;
 uint32 timer_start    = 1000000;
 uint32 timer_interval = 2000000; /* 2 second period */
 uint32 timer_accuracy;
@@ -64,7 +64,7 @@ int    counter = 0;
  *
  * On RTEMS even a call to BinSemGetInfo has very ill effects.
  */
-void TimerFunction(uint32 timer_id)
+void TimerFunction(osal_id_t timer_id)
 {
    int32              status;
 
@@ -201,7 +201,8 @@ void BinSemTimeoutSetup(void)
    ** Create the binary semaphore
    */
    status = OS_BinSemCreate( &bin_sem_id, "BinSem1", 1, 0);
-   UtAssert_True(status == OS_SUCCESS, "BinSem1 create Id=%u Rc=%d", (unsigned int)bin_sem_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "BinSem1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(bin_sem_id), (int)status);
 
    status = OS_BinSemGetInfo (bin_sem_id, &bin_sem_prop);
    UtAssert_True(status == OS_SUCCESS, "BinSem1 value=%d Rc=%d", (int)bin_sem_prop.value, (int)status);
@@ -218,13 +219,15 @@ void BinSemTimeoutSetup(void)
    ** Create the "consumer" task.
    */
    status = OS_TaskCreate( &task_1_id, "Task 1", task_1, task_1_stack, TASK_1_STACK_SIZE, TASK_1_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%u Rc=%d", (unsigned int)task_1_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_1_id), (int)status);
 
    /*
    ** Create a timer
    */
    status = OS_TimerCreate(&timer_id, "Timer 1", &accuracy, &(TimerFunction));
-   UtAssert_True(status == OS_SUCCESS, "Timer 1 create Id=%u Rc=%d", (unsigned int)timer_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Timer 1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(timer_id), (int)status);
    UtPrintf("Timer Accuracy = %u microseconds \n",(unsigned int)accuracy);
 
    /*
diff --git a/src/tests/count-sem-test/count-sem-test.c b/src/tests/count-sem-test/count-sem-test.c
index 6a0be769d..ebdcccc68 100644
--- a/src/tests/count-sem-test/count-sem-test.c
+++ b/src/tests/count-sem-test/count-sem-test.c
@@ -38,21 +38,21 @@ void CountSemCheck(void);
 #define TASK_3_PRIORITY  120
 
 uint32 task_1_stack[TASK_STACK_SIZE];
-uint32 task_1_id; 
+osal_id_t task_1_id;
 uint32 task_1_failures;
 uint32 task_1_work;
 
 uint32 task_2_stack[TASK_STACK_SIZE];
-uint32 task_2_id; 
+osal_id_t task_2_id;
 uint32 task_2_failures;
 uint32 task_2_work;
 
 uint32 task_3_stack[TASK_STACK_SIZE];
-uint32 task_3_id; 
+osal_id_t task_3_id;
 uint32 task_3_failures;
 uint32 task_3_work;
 
-uint32 count_sem_id;
+osal_id_t count_sem_id;
 
 void task_1(void)
 {
@@ -178,7 +178,8 @@ void CountSemSetup(void)
    ** Create the Counting semaphore
    */
    status = OS_CountSemCreate( &count_sem_id, "CountSem1", 2, 0);
-   UtAssert_True(status == OS_SUCCESS, "CountSem1 create Id=%u Rc=%d", (unsigned int)count_sem_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "CountSem1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(count_sem_id), (int)status);
 
    /*
    ** Take the semaphore so the value is 0 and the next SemTake call should block
@@ -193,13 +194,16 @@ void CountSemSetup(void)
    ** Create the tasks
    */
    status = OS_TaskCreate( &task_1_id, "Task 1", task_1, task_1_stack, TASK_STACK_SIZE, TASK_1_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%u Rc=%d", (unsigned int)task_1_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_1_id), (int)status);
 
    status = OS_TaskCreate( &task_2_id, "Task 2", task_2, task_2_stack, TASK_STACK_SIZE, TASK_2_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 2 create Id=%u Rc=%d", (unsigned int)task_2_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 2 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_2_id), (int)status);
  
    status = OS_TaskCreate( &task_3_id, "Task 3", task_3, task_3_stack, TASK_STACK_SIZE, TASK_3_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 3 create Id=%u Rc=%d", (unsigned int)task_3_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 3 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_3_id), (int)status);
 
    /*
     * Time-limited execution
diff --git a/src/tests/file-api-test/file-api-test.c b/src/tests/file-api-test/file-api-test.c
index 385c0b513..28d5b27f3 100644
--- a/src/tests/file-api-test/file-api-test.c
+++ b/src/tests/file-api-test/file-api-test.c
@@ -47,7 +47,7 @@ os_err_name_t errname;
 
 void UtTest_Setup(void)
 {
-    uint32 fs_id;
+    osal_id_t fs_id;
 
     errname[0] = 0;
 
@@ -86,7 +86,7 @@ void UtTest_Setup(void)
 
 void TestMkfsMount(void)
 {
-    int status;
+    int32 status;
 
     /* Make the file system */
     status = OS_mkfs(0,"/ramdev0","RAM",512,200);
@@ -98,7 +98,7 @@ void TestMkfsMount(void)
 
 void TestUnmountRemount(void)
 {
-    int status;
+    int32 status;
 
     /*
     ** try unmounting the drive, and then remounting it with a different name 
@@ -125,8 +125,8 @@ void TestCreatRemove(void)
     char filename [OS_MAX_PATH_LEN];
     char maxfilename[OS_MAX_PATH_LEN];
     char longfilename [OS_MAX_PATH_LEN + 10];
-    int  status;
-    int  fd;
+    int32  status;
+    osal_id_t  fd;
     int  i;
  
     /* Short file name */
@@ -147,16 +147,22 @@ void TestCreatRemove(void)
     }
     
     /* create a file with short name */
-    fd = OS_creat(filename,OS_READ_WRITE);
-    UtAssert_True(fd >= 0, "fd after creat short name length file = %d",(int)fd);
+    status = OS_creat(filename,OS_READ_WRITE);
+    UtAssert_True(status >= 0, "fd after creat short name length file = %d",(int)status);
+
+    /* conversion to osal_id_t */
+    fd = OS_ObjectIdFromInteger(status);
 
     /* close the first file */
     status = OS_close(fd);
     UtAssert_True(status == OS_SUCCESS, "status after close short name length file = %d",(int)status);
 
     /* create a file with max name size */
-    fd = OS_creat(maxfilename,OS_READ_WRITE);
-    UtAssert_True(fd >= 0, "fd after creat max name length file = %d",(int)fd);
+    status = OS_creat(maxfilename,OS_READ_WRITE);
+    UtAssert_True(status >= 0, "fd after creat max name length file = %d",(int)status);
+
+    /* conversion to osal_id_t */
+    fd = OS_ObjectIdFromInteger(status);
 
     /* close the second file */
     status = OS_close(fd);
@@ -194,8 +200,8 @@ void TestCreatRemove(void)
 void TestOpenClose(void)
 {
     char filename [OS_MAX_PATH_LEN];
-    int status;
-    int fd;
+    int32 status;
+    osal_id_t fd;
 
     strncpy(filename,"/drive0/Filename1", sizeof(filename) - 1);
     filename[sizeof(filename) - 1] = 0;
@@ -204,8 +210,9 @@ void TestOpenClose(void)
     status = OS_creat(filename,OS_READ_WRITE);
     UtAssert_True(status >= OS_SUCCESS, "status after creat = %d",(int)status);
         
-    fd = status;
-   
+    /* conversion to osal_id_t */
+    fd = OS_ObjectIdFromInteger(status);
+
     /*
     ** try to close the file
     */
@@ -216,7 +223,8 @@ void TestOpenClose(void)
     status = OS_open(filename,OS_READ_WRITE,0644);
     UtAssert_True(status >= OS_SUCCESS, "status after reopen = %d",(int)status);
 
-    fd = status;
+    /* conversion to osal_id_t */
+    fd = OS_ObjectIdFromInteger(status);
    
     /*
     ** try to close the file again
@@ -231,7 +239,7 @@ void TestOpenClose(void)
     UtAssert_True(status != OS_SUCCESS, "status after close = %d",(int)status);
     
     /*try to close a file not on the system. Should Fail */
-    status = OS_close(43);
+    status = OS_close(OS_OBJECT_ID_UNDEFINED);
     UtAssert_True(status != OS_SUCCESS, "status after close = %d",(int)status);
 
     /*  open a file that was never in the system */
@@ -255,8 +263,8 @@ void TestReadWriteLseek(void)
     char newbuffer[30];
     int offset;
     int size;
-    int status;
-    int fd;
+    int32 status;
+    osal_id_t fd;
 
     strncpy(filename,"/drive0/Filename1", sizeof(filename) - 1);
     filename[sizeof(filename) - 1] = 0;
@@ -274,7 +282,8 @@ void TestReadWriteLseek(void)
     status = OS_creat(filename,OS_READ_WRITE);
     UtAssert_True(status >= OS_SUCCESS, "status after creat = %d",(int)status);
     
-    fd = status;
+    /* conversion to osal_id_t */
+    fd = OS_ObjectIdFromInteger(status);
     size = strlen(buffer);
     
     /* test write portion of R/W mode */
@@ -304,7 +313,9 @@ void TestReadWriteLseek(void)
     status = OS_open(filename,OS_READ_ONLY,0644);
     UtAssert_True(status >= OS_SUCCESS, "status after reopen = %d",(int)status);
 
-    fd = status;
+    /* conversion to osal_id_t */
+    fd = OS_ObjectIdFromInteger(status);
+
     /* test write in READ ONLY mode */
     status = OS_write(fd, (void*)buffer, size);
     UtAssert_True(status < OS_SUCCESS, "status after write = %d",(int)status);
@@ -341,7 +352,8 @@ void TestReadWriteLseek(void)
     status = OS_open(filename,OS_WRITE_ONLY,0644);
     UtAssert_True(status >= OS_SUCCESS, "status after reopen = %d",(int)status);
 
-    fd = status;
+    /* conversion to osal_id_t */
+    fd = OS_ObjectIdFromInteger(status);
 
     /* test write in WRITE ONLY mode */
     status = OS_write(fd, (void*)buffer, size);
@@ -373,7 +385,7 @@ void TestReadWriteLseek(void)
 ---------------------------------------------------------------------------------------*/
 void TestMkRmDirFreeBytes(void)
 {
-    int status;
+    int32 status;
     char filename1[OS_MAX_PATH_LEN];
     char filename2[OS_MAX_PATH_LEN];
     char dir1 [OS_MAX_PATH_LEN];
@@ -382,8 +394,8 @@ void TestMkRmDirFreeBytes(void)
     char buffer2 [OS_MAX_PATH_LEN];
     char copybuffer1 [OS_MAX_PATH_LEN];
     char copybuffer2 [OS_MAX_PATH_LEN];
-    int fd1;
-    int fd2;
+    osal_id_t fd1;
+    osal_id_t fd2;
     int size;
 
     /* make the directory names for testing, as well as the filenames and the buffers
@@ -414,12 +426,14 @@ void TestMkRmDirFreeBytes(void)
     status = OS_creat(filename1,OS_READ_WRITE);
     UtAssert_True(status >= OS_SUCCESS, "status after creat 1 = %d",(int)status);
     
-    fd1 = status;
+    /* conversion to osal_id_t */
+    fd1 = OS_ObjectIdFromInteger(status);
 
     status = OS_creat(filename2,OS_READ_WRITE);
     UtAssert_True(status >= OS_SUCCESS, "status after creat 2 = %d",(int)status);
     
-    fd2 = status;
+    /* conversion to osal_id_t */
+    fd2 = OS_ObjectIdFromInteger(status);
 
     /* write the propper buffers into each of the files */
     size = strlen(buffer1);
@@ -489,7 +503,7 @@ void TestMkRmDirFreeBytes(void)
 ---------------------------------------------------------------------------------------*/
 void TestOpenReadCloseDir(void)
 {
-    int status;
+    int32 status;
     char filename1[OS_MAX_PATH_LEN];
     char filename2[OS_MAX_PATH_LEN];
     char dir0 [OS_MAX_PATH_LEN];
@@ -498,9 +512,9 @@ void TestOpenReadCloseDir(void)
     char buffer1 [OS_MAX_PATH_LEN];
     char buffer2 [OS_MAX_PATH_LEN];
     int size;
-    int fd1;
-    int fd2;
-    uint32 dirh;
+    osal_id_t fd1;
+    osal_id_t fd2;
+    osal_id_t dirh;
     os_dirent_t dirent;
     
     /* make the directory names for testing, as well as the filenames and the buffers
@@ -526,15 +540,16 @@ void TestOpenReadCloseDir(void)
     status = OS_creat(filename1,OS_READ_WRITE);
     UtAssert_True(status >= OS_SUCCESS, "status after creat 1 = %d",(int)status);
     
-    fd1 = status;
+    /* conversion to osal_id_t */
+    fd1 = OS_ObjectIdFromInteger(status);
 
     status = OS_creat(filename2,OS_READ_WRITE);
     UtAssert_True(status >= OS_SUCCESS, "status after creat 2 = %d",(int)status);
     
-    fd2 = status;
+    /* conversion to osal_id_t */
+    fd2 = OS_ObjectIdFromInteger(status);
 
-    /* write the propper buffers into each of the files */
-    
+    /* write the proper buffers into each of the files */
     size = strlen(buffer1);
     status = OS_write(fd1, buffer1, size);
     UtAssert_True(status == size, "status after write 1 = %d size = %d",(int)status, (int)size);
@@ -559,7 +574,8 @@ void TestOpenReadCloseDir(void)
     /* New version of test 1 - uses full abstraction API */
 
     status = OS_DirectoryOpen(&dirh, dir0);
-    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen Id=%u Rc=%d",(unsigned int)dirh,(int)status);
+    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen Id=%lx Rc=%d",
+            OS_ObjectIdToInteger(dirh),(int)status);
     
     /* try to read the two folders that are in the "/" */
     /* Have to make it a loop to see if we can find the directories in question */
@@ -592,7 +608,8 @@ void TestOpenReadCloseDir(void)
     /* New version of test 2 - uses full abstraction API */
 
     status = OS_DirectoryOpen(&dirh, dir0);
-    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen Id=%u Rc=%d",(unsigned int)dirh,(int)status);
+    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen Id=%lx Rc=%d",
+            OS_ObjectIdToInteger(dirh),(int)status);
 
     while (true)
     {
@@ -619,7 +636,8 @@ void TestOpenReadCloseDir(void)
     
     /* New version of test 4 - uses full abstraction API */
     status = OS_DirectoryOpen(&dirh, dir1);
-    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen Id=%u Rc=%d",(unsigned int)dirh,(int)status);
+    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen Id=%lx Rc=%d",
+            OS_ObjectIdToInteger(dirh),(int)status);
     
    
     /* try to read the next file within the first directory "MyFile1" */
@@ -647,7 +665,8 @@ void TestOpenReadCloseDir(void)
 
     /* New version of test 5 - uses full abstraction API */
     status = OS_DirectoryOpen(&dirh, dir2);
-    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen Id=%u Rc=%d",(unsigned int)dirh,(int)status);
+    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen Id=%lx Rc=%d",
+            OS_ObjectIdToInteger(dirh),(int)status);
  
     /* try to read the next file within the first directory "MyFile2" */
     while (true)
@@ -675,7 +694,8 @@ void TestOpenReadCloseDir(void)
      * is able to be opened.  This should not require a trailing
      * slash (i.e. /test rather than /test/) */
     status = OS_DirectoryOpen(&dirh, "/test");
-    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen /test Id=%u Rc=%d",(unsigned int)dirh,(int)status);
+    UtAssert_True(status >= OS_SUCCESS, "OS_DirectoryOpen /test Id=%lx Rc=%d",
+            OS_ObjectIdToInteger(dirh),(int)status);
 
     /*Close the file */
     status = OS_DirectoryClose(dirh);
@@ -701,7 +721,7 @@ void TestOpenReadCloseDir(void)
 ---------------------------------------------------------------------------------------*/
 void TestRename(void)
 {
-    int status;
+    int32 status;
     char filename1[OS_MAX_PATH_LEN];
     char dir0 [OS_MAX_PATH_LEN];
     char dir1 [OS_MAX_PATH_LEN];
@@ -713,7 +733,7 @@ void TestRename(void)
     char midname1 [OS_MAX_PATH_LEN];
     char newfilename1 [OS_MAX_PATH_LEN];
     
-    int fd1;
+    osal_id_t fd1;
     int size;
     
     /* make the directory names for testing, as well as the filenames and the buffers
@@ -739,7 +759,8 @@ void TestRename(void)
     status = OS_creat(filename1,OS_READ_WRITE);
     UtAssert_True(status >= OS_SUCCESS, "status after creat 1 = %d",(int)status);
     
-    fd1 = status;
+    /* conversion to osal_id_t */
+    fd1 = OS_ObjectIdFromInteger(status);
 
     /* write the propper buffes into  the file */
     
@@ -766,9 +787,12 @@ void TestRename(void)
 
     /* try to read the new file out */
 
-    fd1 = OS_open(newfilename1,OS_READ_ONLY,0644);
+    status = OS_open(newfilename1,OS_READ_ONLY,0644);
     UtAssert_True(status >= OS_SUCCESS, "status after open 1 = %d",(int)status);
     
+    /* conversion to osal_id_t */
+    fd1 = OS_ObjectIdFromInteger(status);
+
     size  = strlen(copybuffer1);
     status = OS_read(fd1,buffer1,size);
     UtAssert_True(status == size, "status after read 1 = %d size = %d",(int)status, (int)size);
@@ -800,7 +824,7 @@ void TestStat(void)
     char        dir1slash[OS_MAX_PATH_LEN];
     char        buffer1 [OS_MAX_PATH_LEN];
     os_fstat_t  StatBuff;
-    int32       fd1;
+    osal_id_t   fd1;
     int         size;
 
     strcpy(dir1,"/drive0/DirectoryName");
@@ -817,7 +841,8 @@ void TestStat(void)
     status = OS_creat(filename1,OS_READ_WRITE);
     UtAssert_True(status >= OS_SUCCESS, "status after creat 1 = %d",(int)status);
     
-    fd1 = status;
+    /* conversion to osal_id_t */
+    fd1 = OS_ObjectIdFromInteger(status);
 
     /* Write some data into the file */
     
diff --git a/src/tests/idmap-api-test/idmap-api-test.c b/src/tests/idmap-api-test/idmap-api-test.c
index c1c9bdecf..c0133c0aa 100644
--- a/src/tests/idmap-api-test/idmap-api-test.c
+++ b/src/tests/idmap-api-test/idmap-api-test.c
@@ -36,14 +36,14 @@
 #include "utbsp.h"
 
 
-uint32 task_id;
-uint32 queue_id;
-uint32 count_sem_id;
-uint32 bin_sem_id;
-uint32 mutex_id1;
-uint32 mutex_id2;
-uint32 mutex_id3;
-uint32 time_base_id;
+osal_id_t task_id;
+osal_id_t queue_id;
+osal_id_t count_sem_id;
+osal_id_t bin_sem_id;
+osal_id_t mutex_id1;
+osal_id_t mutex_id2;
+osal_id_t mutex_id3;
+osal_id_t time_base_id;
 
 #define UT_EXIT_LOOP_MAX    100
 
@@ -60,7 +60,7 @@ typedef struct
     uint32 OtherCount;
 } Test_OS_ObjTypeCount_t;
 
-static void ObjTypeCounter(uint32 object_id, void *arg)
+static void ObjTypeCounter(osal_id_t object_id, void *arg)
 {
     Test_OS_ObjTypeCount_t *count = arg;
 
@@ -95,7 +95,7 @@ static void ObjTypeCounter(uint32 object_id, void *arg)
 */
 void Test_Void_Fn(void)
 {
-    uint32 bin_sem_id_my_task;
+    osal_id_t bin_sem_id_my_task;
     OS_BinSemCreate( &bin_sem_id_my_task, "BinSemTaskMyTask", 1, 0);
     OS_TaskDelay(5);
 
@@ -145,8 +145,15 @@ void TestIdMapApi(void)
     uint32 TestArrayIndex; 
     uint32 TestMutex1Index; 
     uint32 TestMutex2Index; 
+    osal_id_t badid;
     Test_OS_ObjTypeCount_t Count;
 
+    /*
+     * manufacture a "bad" ID value which is neither valid
+     * nor equivalent to OS_OBJECT_ID_UNDEFINED
+     */
+    memset(&badid, 0xFF, sizeof(badid));
+
     /*
      * NOTE: The following objects were not created and tested:
      * OS_OBJECT_TYPE_OS_STREAM
@@ -195,8 +202,8 @@ void TestIdMapApi(void)
      * here.  The only check is that the function doesn't return
      * an error when called
      */
-    OS_IdentifyObject(0x00000); 
-    OS_IdentifyObject(0xFFFFFFFF); 
+    OS_IdentifyObject(OS_OBJECT_ID_UNDEFINED);
+    OS_IdentifyObject(badid);
 
     /*
      * Test Case For:
@@ -247,11 +254,11 @@ void TestIdMapApi(void)
      * Test with extreme cases using invalid inputs and checking
      * for an error return code 
      */
-    actual   = OS_ConvertToArrayIndex(0x0000, &TestArrayIndex);
+    actual   = OS_ConvertToArrayIndex(OS_OBJECT_ID_UNDEFINED, &TestArrayIndex);
     expected = OS_ERR_INVALID_ID;
     UtAssert_True(actual == expected , "OS_ConvertToArrayIndex() (%ld) == %ld ", (long)actual, (long)expected );
 
-    actual   = OS_ConvertToArrayIndex(0xFFFFFFFF, &TestArrayIndex);
+    actual   = OS_ConvertToArrayIndex(badid, &TestArrayIndex);
     expected = OS_ERR_INVALID_ID;
     UtAssert_True(actual == expected , "OS_ConvertToArrayIndex() (%ld) == %ld ", (long)actual, (long)expected );
 
@@ -261,7 +268,7 @@ void TestIdMapApi(void)
      */
     memset(&Count, 0, sizeof(Count));
 
-    OS_ForEachObject (0, &ObjTypeCounter, &Count);
+    OS_ForEachObject (OS_OBJECT_CREATOR_ANY, &ObjTypeCounter, &Count);
 
     /* Verify Outputs */
     UtAssert_True(Count.TaskCount == 0, "OS_ForEachObject() TaskCount (%lu) == 0", (unsigned long)Count.TaskCount);
@@ -285,7 +292,7 @@ void TestIdMapApi(void)
      */
     memset(&Count, 0, sizeof(Count));
     OS_DeleteAllObjects();
-    OS_ForEachObject (0, &ObjTypeCounter, &Count);
+    OS_ForEachObject (OS_OBJECT_CREATOR_ANY, &ObjTypeCounter, &Count);
 
     /* Verify Outputs */
     UtAssert_True(Count.TaskCount == 0, "OS_ForEachObject() TaskCount After Delete (%lu) == 0", (unsigned long)Count.TaskCount);
@@ -298,7 +305,7 @@ void TestIdMapApi(void)
     /*
      * Pass an invalid input, and verify that object counts are not increased
      */
-    OS_ForEachObject (0xFFFFFFFF, &ObjTypeCounter, &Count); 
+    OS_ForEachObject (badid, &ObjTypeCounter, &Count);
 
     /* Verify Outputs */
     UtAssert_True(Count.TaskCount == 0, "OS_ForEachObject() TaskCount Invalid Input (%lu) == 0", (unsigned long)Count.TaskCount);
diff --git a/src/tests/mutex-test/mutex-test.c b/src/tests/mutex-test/mutex-test.c
index 41bfd9ef2..e13e563bb 100644
--- a/src/tests/mutex-test/mutex-test.c
+++ b/src/tests/mutex-test/mutex-test.c
@@ -38,18 +38,19 @@ void MutexCheck(void);
 #define TASK_3_PRIORITY  120
 
 uint32 task_1_stack[TASK_STACK_SIZE];
-uint32 task_1_id; 
+osal_id_t task_1_id;
 uint32 task_1_failures;
 
 uint32 task_2_stack[TASK_STACK_SIZE];
-uint32 task_2_id; 
+osal_id_t task_2_id;
 uint32 task_2_failures;
 
 uint32 task_3_stack[TASK_STACK_SIZE];
-uint32 task_3_id; 
+osal_id_t task_3_id;
 uint32 task_3_failures;
 
-uint32 mut_sem_id;
+osal_id_t mut_sem_id;
+
 uint32 shared_obj_owner;
 
 int    counter = 0;
@@ -239,7 +240,8 @@ void MutexSetup(void)
    ** Create the mutex 
    */
    status = OS_MutSemCreate( &mut_sem_id, "MutSem1", 0);
-   UtAssert_True(status == OS_SUCCESS, "MutSem1 create Id=%u Rc=%d", (unsigned int)mut_sem_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "MutSem1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(mut_sem_id), (int)status);
 
    /*
    ** Test the mutex to see if it supports nesting 
@@ -260,13 +262,16 @@ void MutexSetup(void)
    ** Create the tasks
    */
    status = OS_TaskCreate( &task_1_id, "Task 1", task_1, task_1_stack, TASK_STACK_SIZE, TASK_1_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%u Rc=%d", (unsigned int)task_1_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_1_id), (int)status);
 
    status = OS_TaskCreate( &task_2_id, "Task 2", task_2, task_2_stack, TASK_STACK_SIZE, TASK_2_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 2 create Id=%u Rc=%d", (unsigned int)task_2_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 2 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_2_id), (int)status);
  
    status = OS_TaskCreate( &task_3_id, "Task 3", task_3, task_3_stack, TASK_STACK_SIZE, TASK_3_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 3 create Id=%u Rc=%d", (unsigned int)task_3_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 3 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_3_id), (int)status);
 
    /*
     * Time limited execution
diff --git a/src/tests/osal-core-test/osal-core-test.c b/src/tests/osal-core-test/osal-core-test.c
index 772970ec5..13dc303b0 100644
--- a/src/tests/osal-core-test/osal-core-test.c
+++ b/src/tests/osal-core-test/osal-core-test.c
@@ -37,7 +37,7 @@
 typedef struct
 {
     uint32 NumInvocations;
-    uint32 ObjList[OSAL_UT_MAX_CALLBACKS];
+    osal_id_t ObjList[OSAL_UT_MAX_CALLBACKS];
 } TestCallbackState_t;
 
 
@@ -54,7 +54,7 @@ void TestGetInfos(void);
 void TestGenericQueries(void);
 
 /* helper function for "OS_ForEachObject" test cases */
-static void TestForEachCallback(uint32 object_id, void *arg)
+static void TestForEachCallback(osal_id_t object_id, void *arg)
 {
     TestCallbackState_t *State = (TestCallbackState_t*)arg;
     if (State->NumInvocations < OSAL_UT_MAX_CALLBACKS)
@@ -108,16 +108,16 @@ void task_generic_with_exit(void)
 
 typedef struct
 {
-   uint32 task_id;
+   osal_id_t task_id;
    uint32 task_stack[TASK_0_STACK_SIZE];
 } TestTaskData;
 /* ********************************************** TASKS******************************* */
 void TestTasks(void)
 {
-    int status;
+    int32 status;
     char taskname[OS_MAX_API_NAME];
     int tasknum;
-    uint32 saved_task0_id;
+    osal_id_t saved_task0_id;
     static TestTaskData TaskData[OS_MAX_TASKS + 1];
     OS_task_prop_t taskprop;
     int loopcnt;
@@ -132,7 +132,8 @@ void TestTasks(void)
        status = OS_TaskCreate( &TaskData[tasknum].task_id, taskname, task_generic_no_exit, TaskData[tasknum].task_stack,
                                TASK_0_STACK_SIZE, (250 - OS_MAX_TASKS) + tasknum, 0);
 
-       UtDebug("Create %s Status = %d, Id = %d\n",taskname,(int)status,(int)TaskData[tasknum].task_id);
+       UtDebug("Create %s Status = %d, Id = %lx\n",taskname,(int)status,
+               OS_ObjectIdToInteger(TaskData[tasknum].task_id));
 
        UtAssert_True((tasknum < OS_MAX_TASKS && status == OS_SUCCESS) ||
              (tasknum >= OS_MAX_TASKS && status != OS_SUCCESS), "OS_TaskCreate, nominal");
@@ -147,7 +148,8 @@ void TestTasks(void)
        snprintf(taskname,sizeof(taskname), "Task %d", tasknum);
        status = OS_TaskDelete( TaskData[tasknum].task_id );
 
-       UtDebug("Delete Status = %d, Id = %d\n",(int)status,(int)TaskData[tasknum].task_id);
+       UtDebug("Delete Status = %d, Id = %lx\n",(int)status,
+               OS_ObjectIdToInteger(TaskData[tasknum].task_id));
 
        UtAssert_True((tasknum < OS_MAX_TASKS && status == OS_SUCCESS) ||
              (tasknum >= OS_MAX_TASKS && status != OS_SUCCESS), "OS_TaskDelete, nominal");
@@ -166,7 +168,8 @@ void TestTasks(void)
        status = OS_TaskCreate( &TaskData[tasknum].task_id, taskname, task_generic_with_exit, TaskData[tasknum].task_stack,
                                TASK_0_STACK_SIZE, (250 - OS_MAX_TASKS) + tasknum, 0);
 
-       UtDebug("Create %s Status = %d, Id = %d\n",taskname,(int)status,(int)TaskData[tasknum].task_id);
+       UtDebug("Create %s Status = %d, Id = %lx\n",taskname,(int)status,
+               OS_ObjectIdToInteger(TaskData[tasknum].task_id));
 
        UtAssert_True(status == OS_SUCCESS, "OS_TaskCreate, self exiting task");
 
@@ -177,7 +180,8 @@ void TestTasks(void)
           OS_TaskDelay(10);
           loopcnt++;
        }
-       UtDebug("Looped %d times waiting for child task Id %d to exit\n", loopcnt, (int)TaskData[tasknum].task_id);
+       UtDebug("Looped %d times waiting for child task Id %lx to exit\n", loopcnt,
+               OS_ObjectIdToInteger(TaskData[tasknum].task_id));
        UtAssert_True(loopcnt < UT_EXIT_LOOP_MAX, "Looped %d times without self-exiting task exiting", loopcnt);
 
        /*
@@ -185,7 +189,8 @@ void TestTasks(void)
         */
        status = OS_TaskDelete( TaskData[tasknum].task_id );
 
-       UtDebug("Delete Status = %d, Id = %d\n",(int)status,(int)TaskData[tasknum].task_id);
+       UtDebug("Delete Status = %d, Id = %lx\n",(int)status,
+               OS_ObjectIdToInteger(TaskData[tasknum].task_id));
 
        UtAssert_True(status != OS_SUCCESS, "OS_TaskDelete, self exiting task");
 
@@ -252,11 +257,11 @@ void TestTasks(void)
 
 void TestQueues(void)
 {
-    int status;
+    int32 status;
     char qname[OS_MAX_API_NAME];
     int qnum;
-    uint32 saved_queue0_id;
-    static uint32 msgq_ids[OS_MAX_QUEUES + 1];
+    osal_id_t saved_queue0_id;
+    static osal_id_t msgq_ids[OS_MAX_QUEUES + 1];
 
     InitializeQIds();
     memset(msgq_ids,0xFF,sizeof(msgq_ids));
@@ -346,11 +351,11 @@ void TestQueues(void)
 /* *************************************************************************** */
 void TestBinaries(void)
 {
-    int status;
+    int32 status;
     char bname[OS_MAX_API_NAME];
     int bnum;
-    uint32 saved_bin0_id;
-    static uint32 binsem_ids[OS_MAX_BIN_SEMAPHORES + 1];
+    osal_id_t saved_bin0_id;
+    static osal_id_t binsem_ids[OS_MAX_BIN_SEMAPHORES + 1];
 
 
     memset(binsem_ids,0xFF,sizeof(binsem_ids));
@@ -441,11 +446,11 @@ void TestBinaries(void)
 /* ************************************************************************************ */
 void TestMutexes(void)
 {
-    int status;
+    int32 status;
     char mname[OS_MAX_API_NAME];
     int mnum;
-    uint32 saved_mut0_id;
-    static uint32 mutex_ids[OS_MAX_MUTEXES + 1];
+    osal_id_t saved_mut0_id;
+    static osal_id_t mutex_ids[OS_MAX_MUTEXES + 1];
 
 
     memset(mutex_ids,0xFF,sizeof(mutex_ids));
@@ -538,12 +543,27 @@ void TestMutexes(void)
 void InitializeTaskIds(void)
 {
 
-task_0_id = 99;  task_1_id = 99;  task_2_id = 99;  task_3_id = 99; 
-     task_4_id = 99;  task_5_id = 99;  task_6_id = 99;  task_7_id = 99; 
-     task_8_id = 99;  task_9_id = 99; task_10_id = 99; task_11_id = 99;   
-    task_12_id = 99; task_13_id = 99; task_14_id = 99; task_15_id = 99;
-    task_16_id = 99; task_17_id = 99; task_18_id = 99; task_19_id = 99; 
-    task_20_id = 99;
+    task_0_id = OS_OBJECT_ID_UNDEFINED;
+    task_1_id = OS_OBJECT_ID_UNDEFINED;
+    task_2_id = OS_OBJECT_ID_UNDEFINED;
+    task_3_id = OS_OBJECT_ID_UNDEFINED;
+    task_4_id = OS_OBJECT_ID_UNDEFINED;
+    task_5_id = OS_OBJECT_ID_UNDEFINED;
+    task_6_id = OS_OBJECT_ID_UNDEFINED;
+    task_7_id = OS_OBJECT_ID_UNDEFINED;
+    task_8_id = OS_OBJECT_ID_UNDEFINED;
+    task_9_id = OS_OBJECT_ID_UNDEFINED;
+    task_10_id = OS_OBJECT_ID_UNDEFINED;
+    task_11_id = OS_OBJECT_ID_UNDEFINED;
+    task_12_id = OS_OBJECT_ID_UNDEFINED;
+    task_13_id = OS_OBJECT_ID_UNDEFINED;
+    task_14_id = OS_OBJECT_ID_UNDEFINED;
+    task_15_id = OS_OBJECT_ID_UNDEFINED;
+    task_16_id = OS_OBJECT_ID_UNDEFINED;
+    task_17_id = OS_OBJECT_ID_UNDEFINED;
+    task_18_id = OS_OBJECT_ID_UNDEFINED;
+    task_19_id = OS_OBJECT_ID_UNDEFINED;
+    task_20_id = OS_OBJECT_ID_UNDEFINED;
 
     return;
 } /* end InitializeTaskIds */
@@ -552,9 +572,18 @@ task_0_id = 99;  task_1_id = 99;  task_2_id = 99;  task_3_id = 99;
 /* **************************************************************************** */
 void InitializeQIds(void)
 {
-    msgq_0 = 99; msgq_1 = 99; msgq_2 = 99; msgq_3 = 99; msgq_4 = 99; 
-    msgq_5 = 99; msgq_6 = 99; msgq_7 = 99; msgq_8 = 99; msgq_9 = 99; msgq_10 = 99; 
-    msgq_id = 99;
+    msgq_0 = OS_OBJECT_ID_UNDEFINED;
+    msgq_1 = OS_OBJECT_ID_UNDEFINED;
+    msgq_2 = OS_OBJECT_ID_UNDEFINED;
+    msgq_3 = OS_OBJECT_ID_UNDEFINED;
+    msgq_4 = OS_OBJECT_ID_UNDEFINED;
+    msgq_5 = OS_OBJECT_ID_UNDEFINED;
+    msgq_6 = OS_OBJECT_ID_UNDEFINED;
+    msgq_7 = OS_OBJECT_ID_UNDEFINED;
+    msgq_8 = OS_OBJECT_ID_UNDEFINED;
+    msgq_9 = OS_OBJECT_ID_UNDEFINED;
+    msgq_10 = OS_OBJECT_ID_UNDEFINED;
+    msgq_id = OS_OBJECT_ID_UNDEFINED;
     
     return;
 } /* end InitializeQIds */  
@@ -563,8 +592,17 @@ void InitializeQIds(void)
 /* ***************************************************************************** */
 void InitializeBinIds(void)
 {
-    bin_0 = 99; bin_1 = 99; bin_2 = 99; bin_3 = 99; bin_4 = 99; bin_5 = 99; 
-    bin_6 = 99; bin_7 = 99; bin_8 = 99; bin_9 = 99; bin_10 = 99;
+    bin_0 = OS_OBJECT_ID_UNDEFINED;
+    bin_1 = OS_OBJECT_ID_UNDEFINED;
+    bin_2 = OS_OBJECT_ID_UNDEFINED;
+    bin_3 = OS_OBJECT_ID_UNDEFINED;
+    bin_4 = OS_OBJECT_ID_UNDEFINED;
+    bin_5 = OS_OBJECT_ID_UNDEFINED;
+    bin_6 = OS_OBJECT_ID_UNDEFINED;
+    bin_7 = OS_OBJECT_ID_UNDEFINED;
+    bin_8 = OS_OBJECT_ID_UNDEFINED;
+    bin_9 = OS_OBJECT_ID_UNDEFINED;
+    bin_10 = OS_OBJECT_ID_UNDEFINED;
     return;
 } /* end InitializeBinIds */
 
@@ -572,8 +610,17 @@ void InitializeBinIds(void)
 /* ***************************************************************************** */
 void InitializeMutIds(void)
 {
-    mut_0 = 99; mut_1 = 99; mut_2 = 99; mut_3 = 99; mut_4 = 99; mut_5 = 99;
-    mut_6 = 99; mut_7 = 99; mut_8 = 99; mut_9 = 99; mut_10 = 99;
+    mut_0 = OS_OBJECT_ID_UNDEFINED;
+    mut_1 = OS_OBJECT_ID_UNDEFINED;
+    mut_2 = OS_OBJECT_ID_UNDEFINED;
+    mut_3 = OS_OBJECT_ID_UNDEFINED;
+    mut_4 = OS_OBJECT_ID_UNDEFINED;
+    mut_5 = OS_OBJECT_ID_UNDEFINED;
+    mut_6 = OS_OBJECT_ID_UNDEFINED;
+    mut_7 = OS_OBJECT_ID_UNDEFINED;
+    mut_8 = OS_OBJECT_ID_UNDEFINED;
+    mut_9 = OS_OBJECT_ID_UNDEFINED;
+    mut_10 = OS_OBJECT_ID_UNDEFINED;
     return;
 } /* end InitializeMutIds */
 /* ***************************************************************************** */
@@ -663,14 +710,14 @@ void TestGenericQueries(void)
     memset(&State, 0, sizeof(State));
     OS_ForEachObjectOfType(OS_OBJECT_TYPE_OS_TASK, OS_OBJECT_CREATOR_ANY, TestForEachCallback, &State);
     UtAssert_True(State.NumInvocations == 1, "Task NumInvocations (%lu) == 1", (unsigned long)State.NumInvocations);
-    UtAssert_True(State.ObjList[0] == task_0_id, "Task ObjList[0] (%lx) == %lx",
-            (unsigned long)State.ObjList[0], (unsigned long)task_0_id);
+    UtAssert_True(OS_ObjectIdEqual(State.ObjList[0], task_0_id), "Task ObjList[0] (%lx) == %lx",
+            OS_ObjectIdToInteger(State.ObjList[0]), OS_ObjectIdToInteger(task_0_id));
 
     memset(&State, 0, sizeof(State));
     OS_ForEachObjectOfType(OS_OBJECT_TYPE_OS_BINSEM, OS_OBJECT_CREATOR_ANY, TestForEachCallback, &State);
     UtAssert_True(State.NumInvocations == 1, "BinSem NumInvocations (%lu) == 1", (unsigned long)State.NumInvocations);
-    UtAssert_True(State.ObjList[0] == bin_0, "BinSem ObjList[0] (%lx) == %lx",
-            (unsigned long)State.ObjList[0], (unsigned long)bin_0);
+    UtAssert_True(OS_ObjectIdEqual(State.ObjList[0], bin_0), "BinSem ObjList[0] (%lx) == %lx",
+            OS_ObjectIdToInteger(State.ObjList[0]), OS_ObjectIdToInteger(bin_0));
 
     memset(&State, 0, sizeof(State));
     OS_ForEachObjectOfType(OS_OBJECT_TYPE_OS_COUNTSEM, OS_OBJECT_CREATOR_ANY, TestForEachCallback, &State);
@@ -690,17 +737,21 @@ void TestGenericQueries(void)
 
     /* Test the OS_GetResourceName() API function */
     status = OS_GetResourceName(mut_0, ResourceName, 0);
-    UtAssert_True(status == OS_INVALID_POINTER, "OS_GetResourceName (%lx,%ld) == OS_INVALID_POINTER", (unsigned long)mut_0, (long)status);
+    UtAssert_True(status == OS_INVALID_POINTER, "OS_GetResourceName (%lx,%ld) == OS_INVALID_POINTER",
+            OS_ObjectIdToInteger(mut_0), (long)status);
 
     status = OS_GetResourceName(msgq_0, ResourceName, sizeof(ResourceName));
-    UtAssert_True(status == OS_SUCCESS, "OS_GetResourceName (%lx,%ld) == OS_SUCCESS", (unsigned long)msgq_0, (long)status);
+    UtAssert_True(status == OS_SUCCESS, "OS_GetResourceName (%lx,%ld) == OS_SUCCESS",
+            OS_ObjectIdToInteger(msgq_0), (long)status);
     UtAssert_StrCmp(ResourceName, "q 0", "Output value correct");
 
-    status = OS_GetResourceName(0, ResourceName, sizeof(ResourceName));
-    UtAssert_True(status == OS_ERR_INVALID_ID, "OS_GetResourceName (%lx,%ld) == OS_ERR_INVALID_ID", (unsigned long)msgq_0, (long)status);
+    status = OS_GetResourceName(OS_OBJECT_ID_UNDEFINED, ResourceName, sizeof(ResourceName));
+    UtAssert_True(status == OS_ERR_INVALID_ID, "OS_GetResourceName (%lx,%ld) == OS_ERR_INVALID_ID",
+            OS_ObjectIdToInteger(OS_OBJECT_ID_UNDEFINED), (long)status);
 
     status = OS_GetResourceName(bin_0, ResourceName, 1);
-    UtAssert_True(status == OS_ERR_NAME_TOO_LONG, "OS_GetResourceName (%lx,%ld) == OS_ERR_NAME_TOO_LONG", (unsigned long)bin_0, (long)status);
+    UtAssert_True(status == OS_ERR_NAME_TOO_LONG, "OS_GetResourceName (%lx,%ld) == OS_ERR_NAME_TOO_LONG",
+            OS_ObjectIdToInteger(bin_0), (long)status);
 
     /* The OS_DeleteAllObjects() should clean up every object created here. */
     OS_DeleteAllObjects();
diff --git a/src/tests/osal-core-test/osal-core-test.h b/src/tests/osal-core-test/osal-core-test.h
index 3c51a7d4a..fc3d3c114 100644
--- a/src/tests/osal-core-test/osal-core-test.h
+++ b/src/tests/osal-core-test/osal-core-test.h
@@ -221,29 +221,29 @@ void task_20(void);
 /* Global Data */
 
 /* Task Id's for testing the number of tasks that can be created */
-uint32 task_0_id, task_1_id, task_2_id, task_3_id, task_4_id, task_5_id;
-uint32 task_6_id, task_7_id, task_8_id, task_9_id, task_10_id, task_11_id;
-uint32 task_12_id, task_13_id, task_14_id, task_15_id, task_16_id, task_17_id;
-uint32 task_18_id, task_19_id, task_20_id;
+osal_id_t task_0_id, task_1_id, task_2_id, task_3_id, task_4_id, task_5_id;
+osal_id_t task_6_id, task_7_id, task_8_id, task_9_id, task_10_id, task_11_id;
+osal_id_t task_12_id, task_13_id, task_14_id, task_15_id, task_16_id, task_17_id;
+osal_id_t task_18_id, task_19_id, task_20_id;
 /* uint32 extra_id; */
 
-uint32 mutex_id; 
+osal_id_t mutex_id;
 
 /* Queue ID for testing the number of queues that can be created */
-uint32 msgq_0, msgq_1, msgq_2, msgq_3, msgq_4, msgq_5, msgq_6;
-uint32 msgq_7, msgq_8, msgq_9;
-uint32 msgq_10;
+osal_id_t msgq_0, msgq_1, msgq_2, msgq_3, msgq_4, msgq_5, msgq_6;
+osal_id_t msgq_7, msgq_8, msgq_9;
+osal_id_t msgq_10;
 
-uint32 msgq_id;
+osal_id_t msgq_id;
 
 
-uint32 bin_0, bin_1, bin_2, bin_3, bin_4,bin_5, bin_6;
-uint32 bin_7, bin_8, bin_9, bin_10;
+osal_id_t bin_0, bin_1, bin_2, bin_3, bin_4,bin_5, bin_6;
+osal_id_t bin_7, bin_8, bin_9, bin_10;
 
 
-uint32 mut_0, mut_1, mut_2, mut_3, mut_4,mut_5, mut_6;
-uint32 mut_7, mut_8 ,mut_9, mut_10;
-uint32 mutex_id;
+osal_id_t mut_0, mut_1, mut_2, mut_3, mut_4,mut_5, mut_6;
+osal_id_t mut_7, mut_8 ,mut_9, mut_10;
+osal_id_t mutex_id;
 
 uint32 shared_resource_x;
 
diff --git a/src/tests/queue-timeout-test/queue-timeout-test.c b/src/tests/queue-timeout-test/queue-timeout-test.c
index 0336c5fdb..c5e31be72 100644
--- a/src/tests/queue-timeout-test/queue-timeout-test.c
+++ b/src/tests/queue-timeout-test/queue-timeout-test.c
@@ -32,40 +32,38 @@
 void QueueTimeoutSetup(void);
 void QueueTimeoutCheck(void);
 
-#define MSGQ_ID           1
 #define MSGQ_DEPTH        50
 #define MSGQ_SIZE         4
 
 /* Task 1 */
-#define TASK_1_ID         1
 #define TASK_1_STACK_SIZE 1024
 #define TASK_1_PRIORITY   101
 #define TASK_2_STACK_SIZE 1024
 #define TASK_2_PRIORITY   50
 
 uint32 task_1_stack[TASK_1_STACK_SIZE];
-uint32 task_1_id; 
+osal_id_t task_1_id;
 uint32 task_1_failures;
 uint32 task_1_timeouts;
 uint32 task_1_messages;
 uint32 task_2_stack[TASK_2_STACK_SIZE];
-uint32 task_2_id;
-uint32 msgq_id;
+osal_id_t task_2_id;
+osal_id_t msgq_id;
 
 uint32 timer_counter;
-uint32 timer_id;
+osal_id_t timer_id;
 uint32 timer_start = 10000;
 uint32 timer_interval = 100000; /* 1000 = 1000 hz, 10000 == 100 hz */
 uint32 timer_accuracy;
 
-void TimerFunction(uint32 timer_id)
+void TimerFunction(osal_id_t timer_id)
 {
    timer_counter++;
 }
 
 void task_1(void)
 {
-    uint32             status;
+    int32              status;
     uint32             data_received;
     uint32             data_size;
 
@@ -153,19 +151,22 @@ void QueueTimeoutSetup(void)
    task_1_timeouts = 0;
 
    status = OS_QueueCreate( &msgq_id, "MsgQ", MSGQ_DEPTH, MSGQ_SIZE, 0);
-   UtAssert_True(status == OS_SUCCESS, "MsgQ create Id=%u Rc=%d", (unsigned int)msgq_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "MsgQ create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(msgq_id), (int)status);
 
    /*
    ** Create the "consumer" task.
    */
    status = OS_TaskCreate( &task_1_id, "Task 1", task_1, task_1_stack, TASK_1_STACK_SIZE, TASK_1_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%u Rc=%d", (unsigned int)task_1_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_1_id), (int)status);
 
    /*
    ** Create a timer
    */
    status = OS_TimerCreate(&timer_id, "Timer 1", &accuracy, &(TimerFunction));
-   UtAssert_True(status == OS_SUCCESS, "Timer 1 create Id=%u Rc=%d", (unsigned int)timer_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Timer 1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(timer_id), (int)status);
    UtPrintf("Timer Accuracy = %u microseconds \n",(unsigned int)accuracy);
 
    /*
diff --git a/src/tests/sem-speed-test/sem-speed-test.c b/src/tests/sem-speed-test/sem-speed-test.c
index 02843dacc..e9f5abace 100644
--- a/src/tests/sem-speed-test/sem-speed-test.c
+++ b/src/tests/sem-speed-test/sem-speed-test.c
@@ -83,14 +83,14 @@ void SemRun(void);
  */
 #define SEMOP(op)           SEMCALL(Count,op)
 
-uint32 task_1_id; 
+osal_id_t task_1_id;
 uint32 task_1_work;
 
-uint32 task_2_id; 
+osal_id_t task_2_id;
 uint32 task_2_work;
 
-uint32 sem_id_1;
-uint32 sem_id_2;
+osal_id_t sem_id_1;
+osal_id_t sem_id_2;
 
 void task_1(void)
 {
@@ -170,18 +170,22 @@ void SemSetup(void)
    ** Create the Bin semaphore
    */
    status = SEMOP(Create)( &sem_id_1, "Sem1", 0, 0);
-   UtAssert_True(status == OS_SUCCESS, "Sem 1 create Id=%u Rc=%d", (unsigned int)sem_id_1, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Sem 1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(sem_id_1), (int)status);
    status = SEMOP(Create)( &sem_id_2, "Sem2", 0, 0);
-   UtAssert_True(status == OS_SUCCESS, "Sem 2 create Id=%u Rc=%d", (unsigned int)sem_id_2, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Sem 2 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(sem_id_2), (int)status);
 
    /*
    ** Create the tasks
    */
    status = OS_TaskCreate( &task_1_id, "Task 1", task_1, NULL, 4096, SEMTEST_TASK_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%u Rc=%d", (unsigned int)task_1_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 1 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_1_id), (int)status);
 
    status = OS_TaskCreate( &task_2_id, "Task 2", task_2, NULL, 4096, SEMTEST_TASK_PRIORITY, 0);
-   UtAssert_True(status == OS_SUCCESS, "Task 2 create Id=%u Rc=%d", (unsigned int)task_2_id, (int)status);
+   UtAssert_True(status == OS_SUCCESS, "Task 2 create Id=%lx Rc=%d",
+           OS_ObjectIdToInteger(task_2_id), (int)status);
 
    /* A small delay just to allow the tasks
     * to start and pend on the sem */
diff --git a/src/tests/time-base-api-test/time-base-api-test.c b/src/tests/time-base-api-test/time-base-api-test.c
index e15b4a710..3ebbfde6b 100644
--- a/src/tests/time-base-api-test/time-base-api-test.c
+++ b/src/tests/time-base-api-test/time-base-api-test.c
@@ -51,10 +51,10 @@ void TestTimeBaseApi(void)
     int32 TimeBaseNum;
     int32 tbc_results[OS_MAX_TIMEBASES];
     uint32 freerun;
-    uint32 objid;
-    uint32 time_base_id; 
-    uint32 time_base_id2; 
-    uint32 tb_id[OS_MAX_TIMEBASES];
+    osal_id_t objid;
+    osal_id_t time_base_id;
+    osal_id_t time_base_id2;
+    osal_id_t tb_id[OS_MAX_TIMEBASES];
     char overMaxTimeBase[12];
     char TimeBaseIter[OS_MAX_TIMEBASES][12];
     OS_timebase_prop_t timebase_prop;
@@ -77,7 +77,7 @@ void TestTimeBaseApi(void)
     UtAssert_True(actual == expected, "OS_TimeBaseCreate() (%ld) == OS_SUCCESS", (long)actual);
 
     /* Test for nominal, max/min cases */
-    objid = 0xFFFFFFFF;
+    objid = OS_OBJECT_ID_UNDEFINED;
     actual = OS_TimeBaseCreate(&objid, "TimeBaseD", 0);
     UtAssert_True(actual == expected, "OS_TimeBaseCreate() (%ld) == OS_SUCCESS", (long)actual);
 
@@ -157,7 +157,7 @@ void TestTimeBaseApi(void)
     UtAssert_True(actual == expected, "OS_TimeBaseSet() (%ld) == OS_TIMER_ERR_INVALID_ARGS", (long)actual);
 
     expected = OS_ERR_INVALID_ID;
-    actual = OS_TimeBaseSet(0, 1000, 1000);
+    actual = OS_TimeBaseSet(OS_OBJECT_ID_UNDEFINED, 1000, 1000);
     UtAssert_True(actual == expected, "OS_TimeBaseSet() (%ld) == OS_ERR_INVALID_ID", (long)actual);
 
 
@@ -173,11 +173,7 @@ void TestTimeBaseApi(void)
 
     /* Test for invalid inputs */
     expected = OS_ERR_INVALID_ID;
-    actual = OS_TimeBaseDelete(0x0000000);
-    UtAssert_True(actual == expected, "OS_TimeBaseDelete() (%ld) == OS_ERR_INVALID_ID", (long)actual);
-
-    expected = OS_ERR_INVALID_ID;
-    actual = OS_TimeBaseDelete(0xFFFFFFF);
+    actual = OS_TimeBaseDelete(OS_OBJECT_ID_UNDEFINED);
     UtAssert_True(actual == expected, "OS_TimeBaseDelete() (%ld) == OS_ERR_INVALID_ID", (long)actual);
 
     /*
@@ -188,18 +184,20 @@ void TestTimeBaseApi(void)
     /* Test for nominal inputs */
     /* Note: TimeBase2 was created above using TimeBaseCreate and id was set to time_base_id2 */
     expected = OS_SUCCESS;
-    objid = 0;
+    objid = OS_OBJECT_ID_UNDEFINED;
     actual = OS_TimeBaseGetIdByName(&objid, "TimeBaseB");
     UtAssert_True(actual == expected, "OS_TimeBaseGetIdByName() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid == time_base_id2, "OS_TimeBaseGetIdByName() objid (%lu) Matches!", (unsigned long)objid);
+    UtAssert_True(OS_ObjectIdEqual(objid, time_base_id2), "OS_TimeBaseGetIdByName() objid (%lu) Matches!",
+            OS_ObjectIdToInteger(objid));
 
 
     /* Test for invalid inputs */
     expected = OS_ERR_NAME_NOT_FOUND;
-    objid = 0;
+    objid = OS_OBJECT_ID_UNDEFINED;
     actual = OS_TimeBaseGetIdByName(&objid, "NF");
     UtAssert_True(actual == expected, "OS_TimeBaseGetIdByName() (%ld) == OS_ERR_NAME_NOT_FOUND",(long)actual);
-    UtAssert_True(objid == 0, "OS_TimeBaseGetIdByName() objid (%lu) still 0", (unsigned long)objid);
+    UtAssert_True(!OS_ObjectIdDefined(objid), "OS_TimeBaseGetIdByName() objid (%lu) still OS_OBJECT_ID_UNDEFINED",
+            OS_ObjectIdToInteger(objid));
 
     expected = OS_INVALID_POINTER;
     actual = OS_TimeBaseGetIdByName(NULL, NULL);
@@ -216,19 +214,14 @@ void TestTimeBaseApi(void)
     /* Note: TimeBase2 was created above using TimeBaseCreate */
 
     /* Initializing timebase_prop values to something other than time_base_id2 to ensure they have changed */
-    timebase_prop.creator = 1111;
-    strncpy(timebase_prop.name, "ABC", sizeof(
-timebase_prop.name));
-    timebase_prop.nominal_interval_time = 2222;
-    timebase_prop.freerun_time = 3333;
-    timebase_prop.accuracy = 0;
+    memset(&timebase_prop, 0x55, sizeof(timebase_prop));
 
     actual = OS_TimeBaseGetInfo(time_base_id2, &timebase_prop);
 
     UtAssert_True(actual == expected, "OS_TimeBaseGetInfo() (%ld) == OS_SUCCESS", (long)actual);
 
-    UtAssert_True(timebase_prop.creator == 0, "timebase_prop.creator (%lu) == 0",
-            (unsigned long)timebase_prop.creator);
+    UtAssert_True(!OS_ObjectIdDefined(timebase_prop.creator), "timebase_prop.creator (%lu) undefined",
+            OS_ObjectIdToInteger(timebase_prop.creator));
     UtAssert_True(strcmp(timebase_prop.name, "TimeBaseB") == 0, "timebase_prop.name (%s) == TimeBase2",
             timebase_prop.name);
     UtAssert_True(timebase_prop.nominal_interval_time == 0,
@@ -243,7 +236,7 @@ timebase_prop.name));
 
     /* Test for invalid inputs */
     expected = OS_ERR_INVALID_ID;
-    actual = OS_TimeBaseGetInfo(1, &timebase_prop);
+    actual = OS_TimeBaseGetInfo(OS_OBJECT_ID_UNDEFINED, &timebase_prop);
     UtAssert_True(actual == expected, "OS_TimeBaseGetInfo() (%ld) == OS_ERR_INVALID_ID", (long)actual);
 
     expected = OS_INVALID_POINTER;
@@ -270,7 +263,7 @@ timebase_prop.name));
     /* Test for invalid inputs */
     expected = OS_ERR_INVALID_ID;
     freerun = 0xFFFFFFFF;
-    actual = OS_TimeBaseGetFreeRun(1, &freerun);
+    actual = OS_TimeBaseGetFreeRun(OS_OBJECT_ID_UNDEFINED, &freerun);
     UtAssert_True(actual == expected, "OS_TimeBaseGetFreeRun() (%ld) == OS_SUCCESS", (long)actual);
 
 
diff --git a/src/tests/timer-add-api-test/timer-add-api-test.c b/src/tests/timer-add-api-test/timer-add-api-test.c
index 07de70437..807e8640d 100644
--- a/src/tests/timer-add-api-test/timer-add-api-test.c
+++ b/src/tests/timer-add-api-test/timer-add-api-test.c
@@ -36,7 +36,6 @@
 #include "utbsp.h"
 
 #define NUMBER_OF_TIMERS 4
-#define TASK_1_ID         1
 #define TASK_1_STACK_SIZE 4096
 #define TASK_1_PRIORITY   101
 
@@ -49,13 +48,13 @@ uint32 TimerTestTaskStack[TASK_1_STACK_SIZE];
 uint32 timer_counter[NUMBER_OF_TIMERS];
 
 
-void counter_func(uint32 timer_id , void *arg)
+void counter_func(osal_id_t timer_id , void *arg)
 {
    uint32 *counter = arg;
    ++(*counter);
 }
 
-void null_func(uint32 timer_id , void *arg)
+void null_func(osal_id_t timer_id , void *arg)
 {
 
 }
@@ -73,11 +72,11 @@ void TestTimerAddApi(void)
     int32    expected;
     int32    tbc_ret_val;
     int32    tbs_ret_val;
-    uint32   timer_id;
-    uint32   time_base_id;
+    osal_id_t   timer_id;
+    osal_id_t   time_base_id;
     int      i = 0;
     int32    TimerStatus[NUMBER_OF_TIMERS];
-    uint32   TimerID[NUMBER_OF_TIMERS];
+    osal_id_t   TimerID[NUMBER_OF_TIMERS];
     char     TimerName[NUMBER_OF_TIMERS][20] = {"TIMER1","TIMER2","TIMER3","TIMER4"};
     uint32   microsecs;
 
@@ -95,7 +94,8 @@ void TestTimerAddApi(void)
    for ( i = 0; i < NUMBER_OF_TIMERS; i++ )
    {
       TimerStatus[i] = OS_TimerAdd(&TimerID[i], TimerName[i], time_base_id, &counter_func, &timer_counter[i]);
-      UtAssert_True(TimerStatus[i] == OS_SUCCESS, "Timer %d Created RC=%d ID=%d", i, (int)TimerStatus[i], (int)TimerID[i]);
+      UtAssert_True(TimerStatus[i] == OS_SUCCESS, "Timer %d Created RC=%d ID=%lx", i, (int)TimerStatus[i],
+              OS_ObjectIdToInteger(TimerID[i]));
 
    }
 
@@ -188,7 +188,7 @@ void TestTimerAddApi(void)
     UtAssert_True(actual == expected, "OS_TimerAdd() (%ld) == OS_INVALID_POINTER", (long)actual);
 
     expected = OS_ERR_INVALID_ID;
-    actual = OS_TimerAdd(&timer_id, "Timer", 1, null_func, NULL);
+    actual = OS_TimerAdd(&timer_id, "Timer", OS_OBJECT_ID_UNDEFINED, null_func, NULL);
     UtAssert_True(actual == expected, "OS_TimerAdd() (%ld) == OS_ERR_INVALID_ID", (long)actual);
 
     expected = OS_TIMER_ERR_INVALID_ARGS;
diff --git a/src/tests/timer-test/timer-test.c b/src/tests/timer-test/timer-test.c
index 6d7e23597..6781894c4 100644
--- a/src/tests/timer-test/timer-test.c
+++ b/src/tests/timer-test/timer-test.c
@@ -60,10 +60,11 @@ uint32 timer_idlookup[OS_MAX_TIMERS];
  * Note: For some Host OSs, this is the equivalent of an ISR, so the calls available are limited.
  * For example, Linux and vxWorks can call functions like printf, but RTEMS cannot.
  */
-void test_func(uint32 timer_id)
+void test_func(osal_id_t timer_id)
 {
-   OS_ConvertToArrayIndex(timer_id, &timer_id);
-   timer_counter[timer_idlookup[timer_id]]++;
+   uint32 indx;
+   OS_ConvertToArrayIndex(timer_id, &indx);
+   timer_counter[timer_idlookup[indx]]++;
 }
 
 
@@ -86,7 +87,7 @@ void UtTest_Setup(void)
 void TimerTestSetup(void)
 {
     int32  status;
-    uint32 TimerTestTaskId;
+    osal_id_t TimerTestTaskId;
 
     /*
      * In the new versions of OSAL, timers do NOT work in the "main" thread,
@@ -116,7 +117,7 @@ void TimerTestTask(void)
    int              i = 0;
    int32            TimerStatus[NUMBER_OF_TIMERS];
    uint32           TableId;
-   uint32           TimerID[NUMBER_OF_TIMERS];
+   osal_id_t        TimerID[NUMBER_OF_TIMERS];
    char             TimerName[NUMBER_OF_TIMERS][20] = {"TIMER1","TIMER2","TIMER3","TIMER4"};
    uint32           ClockAccuracy;
 
@@ -124,7 +125,8 @@ void TimerTestTask(void)
    for ( i = 0; i < NUMBER_OF_TIMERS && i < OS_MAX_TIMERS; i++ )
    {
       TimerStatus[i] = OS_TimerCreate(&TimerID[i], TimerName[i], &ClockAccuracy, &(test_func));
-      UtAssert_True(TimerStatus[i] == OS_SUCCESS, "Timer %d Created RC=%d ID=%d", i, (int)TimerStatus[i], (int)TimerID[i]);
+      UtAssert_True(TimerStatus[i] == OS_SUCCESS, "Timer %d Created RC=%d ID=%lx", i,
+              (int)TimerStatus[i], OS_ObjectIdToInteger(TimerID[i]));
 
       UtPrintf("Timer %d Accuracy = %d microseconds \n",i ,(int)ClockAccuracy);
 
diff --git a/src/unit-test-coverage/shared/src/coveragetest-binsem.c b/src/unit-test-coverage/shared/src/coveragetest-binsem.c
index c9adf822e..251c8efde 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-binsem.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-binsem.c
@@ -56,11 +56,11 @@ void Test_OS_BinSemCreate(void)
      *          uint32 sem_initial_value, uint32 options)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 actual = OS_BinSemCreate(&objid, "UT", 0,0);
 
     UtAssert_True(actual == expected, "OS_BinSemCreate() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
 
     OSAPI_TEST_FUNCTION_RC(OS_BinSemCreate(NULL, NULL, 0, 0), OS_INVALID_POINTER);
     UT_SetForceFail(UT_KEY(OCS_strlen), 10 + OS_MAX_API_NAME);
@@ -76,7 +76,7 @@ void Test_OS_BinSemDelete(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_BinSemDelete(1);
+    actual = OS_BinSemDelete(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_BinSemDelete() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -90,7 +90,7 @@ void Test_OS_BinSemGive(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_BinSemGive(1);
+    actual = OS_BinSemGive(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_BinSemGive() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -105,7 +105,7 @@ void Test_OS_BinSemTake(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_BinSemTake(1);
+    actual = OS_BinSemTake(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_BinSemTake() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -119,7 +119,7 @@ void Test_OS_BinSemFlush(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_BinSemFlush(1);
+    actual = OS_BinSemFlush(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_BinSemFlush() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -133,7 +133,7 @@ void Test_OS_BinSemTimedWait(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_BinSemTimedWait(1,1);
+    actual = OS_BinSemTimedWait(UT_OBJID_1,1);
 
     UtAssert_True(actual == expected, "OS_BinSemTimedWait() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -147,12 +147,12 @@ void Test_OS_BinSemGetIdByName(void)
      */
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
-    uint32 objid = 0;
+    osal_id_t objid;
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdFindByName), OS_SUCCESS);
     actual = OS_BinSemGetIdByName(&objid, "UT");
     UtAssert_True(actual == expected, "OS_BinSemGetIdByName() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "OS_BinSemGetIdByName() objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdFindByName));
 
     expected = OS_ERR_NAME_NOT_FOUND;
@@ -177,20 +177,19 @@ void Test_OS_BinSemGetInfo(void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 111;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_BinSemGetInfo(1, &prop);
+    actual = OS_BinSemGetInfo(UT_OBJID_1, &prop);
 
     UtAssert_True(actual == expected, "OS_BinSemGetInfo() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(prop.creator == 111, "prop.creator (%lu) == 111",
-            (unsigned long)prop.creator);
+    OSAPI_TEST_OBJID(prop.creator,==,UT_OBJID_OTHER);
     UtAssert_True(strcmp(prop.name, "ABC") == 0, "prop.name (%s) == ABC",
             prop.name);
 
 
-    OSAPI_TEST_FUNCTION_RC(OS_BinSemGetInfo(0, NULL), OS_INVALID_POINTER);
+    OSAPI_TEST_FUNCTION_RC(OS_BinSemGetInfo(UT_OBJID_1, NULL), OS_INVALID_POINTER);
 }
 
 
diff --git a/src/unit-test-coverage/shared/src/coveragetest-common.c b/src/unit-test-coverage/shared/src/coveragetest-common.c
index e7cf04612..a999d0b5e 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-common.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-common.c
@@ -36,7 +36,7 @@
 ** It is not exposed in the public API as it is not intended to be called directly.
 ** However the coverage test case needs to invoke it directly to test it.
 */
-extern void OS_CleanUpObject(uint32 object_id, void *arg);
+extern void OS_CleanUpObject(osal_id_t object_id, void *arg);
 
 
 int32 Test_MicroSecPerTick = 0;
@@ -200,7 +200,7 @@ void Test_OS_CleanUpObject(void)
              * the goal is simply to defeat the default
              * check that the objid was valid (it isn't) */
             UT_SetForceFail(delhandler, OS_ERROR);
-            OS_CleanUpObject(0, &ActualObjs);
+            OS_CleanUpObject(OS_OBJECT_ID_UNDEFINED, &ActualObjs);
 
             CallCount = UT_GetStubCount(delhandler);
             UtAssert_True(CallCount == 1, "Objtype %lu call count (%lu) == 1",
@@ -208,7 +208,7 @@ void Test_OS_CleanUpObject(void)
         }
         else
         {
-            OS_CleanUpObject(0, &ActualObjs);
+            OS_CleanUpObject(OS_OBJECT_ID_UNDEFINED, &ActualObjs);
         }
         ++objtype;
         ++ExpObjs;
diff --git a/src/unit-test-coverage/shared/src/coveragetest-countsem.c b/src/unit-test-coverage/shared/src/coveragetest-countsem.c
index 5c33dd3c4..aeebf5ec3 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-countsem.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-countsem.c
@@ -56,11 +56,13 @@ void Test_OS_CountSemCreate(void)
      *          uint32 sem_initial_value, uint32 options)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 actual = OS_CountSemCreate(&objid, "UT", 0,0);
 
     UtAssert_True(actual == expected, "OS_CountSemCreate() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
+#ifdef jphfix
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
+#endif
 
     OSAPI_TEST_FUNCTION_RC(OS_CountSemCreate(NULL, NULL, 0, 0), OS_INVALID_POINTER);
     UT_SetForceFail(UT_KEY(OCS_strlen), 10 + OS_MAX_API_NAME);
@@ -76,7 +78,7 @@ void Test_OS_CountSemDelete(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_CountSemDelete(1);
+    actual = OS_CountSemDelete(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_CountSemDelete() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -90,7 +92,7 @@ void Test_OS_CountSemGive(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_CountSemGive(1);
+    actual = OS_CountSemGive(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_CountSemGive() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -105,7 +107,7 @@ void Test_OS_CountSemTake(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_CountSemTake(1);
+    actual = OS_CountSemTake(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_CountSemTake() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -119,7 +121,7 @@ void Test_OS_CountSemTimedWait(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_CountSemTimedWait(1,1);
+    actual = OS_CountSemTimedWait(UT_OBJID_1,1);
 
     UtAssert_True(actual == expected, "OS_CountSemTimedWait() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -133,12 +135,12 @@ void Test_OS_CountSemGetIdByName(void)
      */
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdFindByName), OS_SUCCESS);
     actual = OS_CountSemGetIdByName(&objid, "UT");
     UtAssert_True(actual == expected, "OS_CountSemGetIdByName() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "OS_CountSemGetIdByName() objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdFindByName));
 
 
@@ -165,19 +167,21 @@ void Test_OS_CountSemGetInfo(void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 111;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_CountSemGetInfo(1, &prop);
+    actual = OS_CountSemGetInfo(UT_OBJID_1, &prop);
 
     UtAssert_True(actual == expected, "OS_CountSemGetInfo() (%ld) == OS_SUCCESS", (long)actual);
+#ifdef jphfix
     UtAssert_True(prop.creator == 111, "prop.creator (%lu) == 111",
             (unsigned long)prop.creator);
+#endif
     UtAssert_True(strcmp(prop.name, "ABC") == 0, "prop.name (%s) == ABC",
             prop.name);
 
-    OSAPI_TEST_FUNCTION_RC(OS_CountSemGetInfo(0, NULL), OS_INVALID_POINTER);
+    OSAPI_TEST_FUNCTION_RC(OS_CountSemGetInfo(UT_OBJID_1, NULL), OS_INVALID_POINTER);
 }
 
 
diff --git a/src/unit-test-coverage/shared/src/coveragetest-dir.c b/src/unit-test-coverage/shared/src/coveragetest-dir.c
index 1d57d4a27..aecf0c723 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-dir.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-dir.c
@@ -66,11 +66,11 @@ void Test_OS_DirectoryOpen(void)
      * int32 OS_DirectoryOpen(uint32 *dir_id, const char *path)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 actual = OS_DirectoryOpen(&objid, "Dir");
 
     UtAssert_True(actual == expected, "OS_DirectoryOpen() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
 
     OSAPI_TEST_FUNCTION_RC(OS_DirectoryOpen(NULL, NULL), OS_INVALID_POINTER);
 }
@@ -83,7 +83,7 @@ void Test_OS_DirectoryClose(void)
      * int32 OS_DirectoryClose(uint32 dir_id)
      */
     int32 expected = OS_SUCCESS;
-    int32 actual = OS_DirectoryClose(1);
+    int32 actual = OS_DirectoryClose(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_DirectoryClose() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -98,11 +98,11 @@ void Test_OS_DirectoryRead(void)
     int32 expected = OS_SUCCESS;
     os_dirent_t dirent;
 
-    int32 actual = OS_DirectoryRead(1, &dirent);
+    int32 actual = OS_DirectoryRead(UT_OBJID_1, &dirent);
 
     UtAssert_True(actual == expected, "OS_DirectoryRead() (%ld) == OS_SUCCESS", (long)actual);
 
-    OSAPI_TEST_FUNCTION_RC(OS_DirectoryRead(1, NULL), OS_INVALID_POINTER);
+    OSAPI_TEST_FUNCTION_RC(OS_DirectoryRead(UT_OBJID_1, NULL), OS_INVALID_POINTER);
 }
 
 
@@ -113,7 +113,7 @@ void Test_OS_DirectoryRewind(void)
      * int32 OS_DirectoryRewind(uint32 dir_id)
      */
     int32 expected = OS_SUCCESS;
-    int32 actual = OS_DirectoryRewind(1);
+    int32 actual = OS_DirectoryRewind(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_DirectoryRewind() (%ld) == OS_SUCCESS", (long)actual);
 }
diff --git a/src/unit-test-coverage/shared/src/coveragetest-file.c b/src/unit-test-coverage/shared/src/coveragetest-file.c
index 06a1291e7..ccb8973fd 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-file.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-file.c
@@ -90,7 +90,7 @@ void Test_OS_close(void)
      * int32 OS_close (uint32 filedes)
      */
     int32 expected = OS_SUCCESS;
-    int32 actual = OS_close(1);
+    int32 actual = OS_close(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_close() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -108,13 +108,13 @@ void Test_OS_TimedRead(void)
     int32 actual = 0;
 
     UT_SetDataBuffer(UT_KEY(OS_GenericRead_Impl), SrcBuf, sizeof(SrcBuf), false);
-    actual = OS_TimedRead(1, Buf, sizeof(Buf), 10);
+    actual = OS_TimedRead(UT_OBJID_1, Buf, sizeof(Buf), 10);
     UtAssert_True(actual == expected, "OS_TimedRead() (%ld) == %ld",
             (long)actual, (long)expected);
     UtAssert_True(memcmp(Buf,SrcBuf,actual) == 0, "buffer content match");
 
     expected = OS_INVALID_POINTER;
-    actual = OS_TimedRead(1, NULL, sizeof(Buf), 10);
+    actual = OS_TimedRead(UT_OBJID_1, NULL, sizeof(Buf), 10);
     UtAssert_True(actual == expected, "OS_TimedRead() (%ld) == %ld",
             (long)actual, (long)expected);
 }
@@ -132,14 +132,14 @@ void Test_OS_TimedWrite(void)
     int32 actual = 0;
 
     UT_SetDataBuffer(UT_KEY(OS_GenericWrite_Impl), DstBuf, sizeof(DstBuf), false);
-    actual = OS_TimedWrite(1, Buf, sizeof(Buf), 10);
+    actual = OS_TimedWrite(UT_OBJID_1, Buf, sizeof(Buf), 10);
 
     UtAssert_True(actual == expected, "OS_TimedWrite() (%ld) == %ld",
             (long)actual, (long)expected);
     UtAssert_True(memcmp(Buf,DstBuf,actual) == 0, "buffer content match");
 
     expected = OS_INVALID_POINTER;
-    actual = OS_TimedWrite(1, NULL, sizeof(Buf), 10);
+    actual = OS_TimedWrite(UT_OBJID_1, NULL, sizeof(Buf), 10);
     UtAssert_True(actual == expected, "OS_TimedWrite() (%ld) == %ld",
             (long)actual, (long)expected);
 }
@@ -157,7 +157,7 @@ void Test_OS_read(void)
     int32 actual = 0;
 
     UT_SetDataBuffer(UT_KEY(OS_GenericRead_Impl), SrcBuf, sizeof(SrcBuf), false);
-    actual = OS_read(1, Buf, sizeof(Buf));
+    actual = OS_read(UT_OBJID_1, Buf, sizeof(Buf));
     UtAssert_True(actual == expected, "OS_read() (%ld) == %ld",
             (long)actual, (long)expected);
     UtAssert_True(memcmp(Buf,SrcBuf,actual) == 0, "buffer content match");
@@ -176,7 +176,7 @@ void Test_OS_write(void)
     int32 actual = 0;
 
     UT_SetDataBuffer(UT_KEY(OS_GenericWrite_Impl), DstBuf, sizeof(DstBuf), false);
-    actual = OS_write(1, Buf, sizeof(Buf));
+    actual = OS_write(UT_OBJID_1, Buf, sizeof(Buf));
 
     UtAssert_True(actual == expected, "OS_write() (%ld) == %ld",
             (long)actual, (long)expected);
@@ -223,7 +223,7 @@ void Test_OS_lseek(void)
      * int32 OS_lseek  (uint32  filedes, int32 offset, uint32 whence)
      */
     int32 expected = OS_SUCCESS;
-    int32 actual = OS_lseek(1, 0, 0);
+    int32 actual = OS_lseek(UT_OBJID_1, 0, 0);
 
     UtAssert_True(actual == expected, "OS_lseek() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -251,7 +251,7 @@ void Test_OS_rename(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    OS_global_stream_table[1].active_id = 1;
+    OS_global_stream_table[1].active_id = UT_OBJID_1;
     strncpy(OS_stream_table[1].stream_name, "/cf/file1",
             sizeof(OS_stream_table[1].stream_name));
     actual = OS_rename("/cf/file1", "/cf/file2");
@@ -337,20 +337,22 @@ void Test_OS_FDGetInfo(void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 111;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_FDGetInfo(1, &file_prop);
+    actual = OS_FDGetInfo(UT_OBJID_1, &file_prop);
 
     UtAssert_True(actual == expected, "OS_FDGetInfo() (%ld) == OS_SUCCESS", (long)actual);
+#ifdef jphfix
     UtAssert_True(file_prop.User == 111, "file_prop.User (%lu) == 111",
             (unsigned long)file_prop.User);
+#endif
     UtAssert_True(strcmp(file_prop.Path, "ABC") == 0, "file_prop.Path (%s) == ABC",
             file_prop.Path);
 
     expected = OS_INVALID_POINTER;
-    actual = OS_FDGetInfo(1, NULL);
+    actual = OS_FDGetInfo(UT_OBJID_1, NULL);
     UtAssert_True(actual == expected, "OS_FDGetInfo() (%ld) == OS_INVALID_POINTER", (long)actual);
 
 }
@@ -366,7 +368,7 @@ void Test_OS_FileOpenCheck(void)
 
     UtAssert_True(actual == expected, "OS_FileOpenCheck() (%ld) == OS_ERROR", (long)actual);
 
-    OS_global_stream_table[0].active_id = 1;
+    OS_global_stream_table[0].active_id = UT_OBJID_1;
     UT_SetForceFail(UT_KEY(OCS_strcmp), 0);
     expected = OS_SUCCESS;
     actual = OS_FileOpenCheck("/cf/file");
@@ -393,7 +395,7 @@ void Test_OS_CloseFileByName(void)
 
     /* setup for success */
     expected = OS_SUCCESS;
-    OS_global_stream_table[0].active_id = 1;
+    OS_global_stream_table[0].active_id = UT_OBJID_1;
     UT_SetForceFail(UT_KEY(OCS_strcmp), 0);
     actual = OS_CloseFileByName("/cf/file");
     UtAssert_True(actual == expected, "OS_CloseFileByName() (%ld) == OS_SUCCESS", (long)actual);
@@ -414,8 +416,8 @@ void Test_OS_CloseAllFiles(void)
     int32 expected = -222;
     int32 actual;
 
-    OS_global_stream_table[0].active_id = 1;
-    OS_global_stream_table[1].active_id = 2;
+    OS_global_stream_table[0].active_id = UT_OBJID_1;
+    OS_global_stream_table[1].active_id = UT_OBJID_2;
     UT_SetDeferredRetcode(UT_KEY(OS_GenericClose_Impl), 1, expected);
     actual = OS_CloseAllFiles();
 
diff --git a/src/unit-test-coverage/shared/src/coveragetest-filesys.c b/src/unit-test-coverage/shared/src/coveragetest-filesys.c
index 318772f14..63a8c6728 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-filesys.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-filesys.c
@@ -53,7 +53,7 @@ void Test_OS_FileSysAddFixedMap(void)
      * Test Case For:
      * int32 OS_FileSysAddFixedMap(uint32 *filesys_id, const char *phys_path, const char *virt_path)
      */
-    uint32 id;
+    osal_id_t id;
 
     OSAPI_TEST_FUNCTION_RC(OS_FileSysAddFixedMap(&id, "/phys", "/virt"), OS_SUCCESS);
     OSAPI_TEST_FUNCTION_RC(OS_FileSysAddFixedMap(&id, NULL, NULL), OS_INVALID_POINTER);
diff --git a/src/unit-test-coverage/shared/src/coveragetest-idmap.c b/src/unit-test-coverage/shared/src/coveragetest-idmap.c
index 59932758b..13d86afed 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-idmap.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-idmap.c
@@ -45,7 +45,7 @@ static bool TestAlwaysMatch(void *ref, uint32 local_id, const OS_common_record_t
     return true;
 }
 
-static void ObjTypeCounter(uint32 object_id, void *arg)
+static void ObjTypeCounter(osal_id_t object_id, void *arg)
 {
     Test_OS_ObjTypeCount_t *count = arg;
 
@@ -118,7 +118,8 @@ void Test_OS_ObjectIdConvertLock(void)
     int32 actual;
     uint32 array_index;
     OS_common_record_t *record;
-    uint32 objid;
+    osal_id_t objid;
+    UT_idbuf_t corrupt_objid;
 
     /* get a valid (fake) OSAL ID to start with */
     OS_ObjectIdAllocateNew(OS_OBJECT_TYPE_OS_TASK, "ut", &array_index, &record);
@@ -128,8 +129,10 @@ void Test_OS_ObjectIdConvertLock(void)
      * Attempt to obtain a lock for the same record with a non-matching ID
      * This should return an error.
      */
+    corrupt_objid.id = objid;
+    corrupt_objid.val ^= 0x10; /* flip a bit */
     actual = OS_ObjectIdConvertLock(OS_LOCK_MODE_NONE, OS_OBJECT_TYPE_OS_TASK,
-            objid + 123, record);
+            corrupt_objid.id, record);
     expected = OS_ERR_INVALID_ID;
 
     UtAssert_True(actual == expected, "OS_ObjectIdConvertLock() (%ld) == OS_ERR_INVALID_ID (%ld)", (long)actual, (long)expected);
@@ -172,11 +175,11 @@ void Test_OS_ObjectIdGetBySearch(void)
     int32 actual;
     OS_common_record_t *record;
 
-    OS_global_task_table[0].active_id = 0x11111;
+    OS_global_task_table[0].active_id = UT_OBJID_OTHER;
     actual = OS_ObjectIdGetBySearch(OS_LOCK_MODE_NONE, OS_OBJECT_TYPE_OS_TASK,
             TestAlwaysMatch, NULL, &record);
     expected = OS_SUCCESS;
-    OS_global_task_table[0].active_id = 0;
+    OS_global_task_table[0].active_id = OS_OBJECT_ID_UNDEFINED;
 
     UtAssert_True(actual == expected, "OS_ObjectIdGetBySearch() (%ld) == OS_SUCCESS (%ld)", (long)actual, (long)expected);
 
@@ -260,7 +263,7 @@ void Test_OS_ObjectIdToArrayIndex(void)
      * different test case.  The only additional test here is to provide a value
      * which is out of range.
      */
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     uint32 local_idx = 0xFFFFFFFF;
     int32 expected = OS_SUCCESS;
     int32 actual   = ~OS_SUCCESS;
@@ -275,7 +278,7 @@ void Test_OS_ObjectIdToArrayIndex(void)
 
     /* coverage for off-nominal case */
     expected = OS_ERR_INVALID_ID;
-    actual   = OS_ObjectIdToArrayIndex(0xFFFFFFFF, 0xFFFFFFFF, &local_idx);
+    actual   = OS_ObjectIdToArrayIndex(0xFFFFFFFF, UT_OBJID_OTHER, &local_idx);
     UtAssert_True(actual == expected, "OS_ObjectIdToArrayIndex() (%ld) == OS_ERR_INVALID_ID", (long)actual);
 }
 
@@ -289,7 +292,7 @@ void Test_OS_ObjectIdFindByName (void)
      * Setting up a special matching entry should yield OS_SUCCESS
      */
     char TaskName[] = "UT_find";
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 expected = OS_ERR_NAME_NOT_FOUND;
     int32 actual   = OS_ObjectIdFindByName(OS_OBJECT_TYPE_UNDEFINED, NULL, NULL);
 
@@ -318,11 +321,11 @@ void Test_OS_ObjectIdFindByName (void)
     /*
      * Set up for the ObjectIdSearch function to return success
      */
-    OS_global_task_table[0].active_id = 0x11111;
+    OS_global_task_table[0].active_id = UT_OBJID_OTHER;
     OS_global_task_table[0].name_entry = TaskName;
     actual = OS_ObjectIdFindByName(OS_OBJECT_TYPE_OS_TASK, TaskName, &objid);
     expected = OS_SUCCESS;
-    OS_global_task_table[0].active_id = 0;
+    OS_global_task_table[0].active_id = OS_OBJECT_ID_UNDEFINED;
     OS_global_task_table[0].name_entry = NULL;
 
     UtAssert_True(actual == expected, "OS_ObjectFindIdByName(%s) (%ld) == OS_SUCCESS", TaskName, (long)actual);
@@ -338,13 +341,13 @@ void Test_OS_ObjectIdGetById(void)
      */
     int32 actual   = ~OS_SUCCESS;
     int32 expected = OS_SUCCESS;
-    uint32 refobjid = 0xFFFFFFFF;
+    osal_id_t refobjid;
     uint32 local_idx = 0xFFFFFFFF;
     OS_common_record_t *rptr = NULL;
 
     /* verify that the call returns ERROR when not initialized */
     OS_SharedGlobalVars.Initialized = false;
-    actual = OS_ObjectIdGetById(OS_LOCK_MODE_NONE, 0, 0, &local_idx, &rptr);
+    actual = OS_ObjectIdGetById(OS_LOCK_MODE_NONE, 0, OS_OBJECT_ID_UNDEFINED, &local_idx, &rptr);
     expected = OS_ERROR;
     UtAssert_True(actual == expected, "OS_ObjectIdGetById(uninitialized) (%ld) == OS_ERROR", (long)actual);
 
@@ -418,9 +421,10 @@ void Test_OS_ObjectIdFindNext(void)
     int32 actual;
     OS_common_record_t *rec1;
     OS_common_record_t *rec2;
-    uint32 id1;
-    uint32 id2;
-    uint32 saved_id;
+    osal_id_t id1;
+    osal_id_t id2;
+    UT_idbuf_t check_id;
+    UT_idbuf_t saved_id;
     uint32 i;
 
     /* Need to first obtain a valid ID to finalize */
@@ -429,54 +433,50 @@ void Test_OS_ObjectIdFindNext(void)
     UtAssert_True(actual == expected, "OS_ObjectIdFindNext() (%ld) == OS_SUCCESS", (long)actual);
 
     /* nominal case (success) */
-    id1 = ~rec1->active_id;
+    id1 = OS_OBJECT_ID_UNDEFINED;
     actual = OS_ObjectIdFinalizeNew(OS_SUCCESS, rec1, &id1);
 
     /* Verify Outputs */
     UtAssert_True(actual == expected, "OS_ObjectIdFinalizeNew() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(id1 == rec1->active_id, "OS_ObjectIdFinalizeNew() id (%lx) == %lx",
-            (unsigned long)id1, (unsigned long)rec1->active_id);
+    OSAPI_TEST_OBJID(id1,==,rec1->active_id);
 
     /* Allocate another ID (should be different!) */
     actual = OS_ObjectIdFindNext(OS_OBJECT_TYPE_OS_TASK, NULL, &rec2);
     UtAssert_True(actual == expected, "OS_ObjectIdFindNext() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(rec2->active_id != rec1->active_id, "OS_ObjectIdFindNext() id (%lx) != %lx",
-            (unsigned long)rec2->active_id, (unsigned long)rec1->active_id);
+    OSAPI_TEST_OBJID(rec2->active_id,!=,rec1->active_id);
 
     /* Failure to initialize the second one.
      * Verify the error code passes thru */
     expected = -1234;
-    saved_id = rec2->active_id;
-    id2 = ~rec2->active_id;
+    saved_id.id = rec2->active_id;
+    id2 = OS_OBJECT_ID_UNDEFINED;
     actual = OS_ObjectIdFinalizeNew(expected, rec2, &id2);
 
     /* Verify Outputs */
     UtAssert_True(actual == expected, "OS_ObjectIdFinalizeNew() (%ld) == %ld", (long)actual, (long)expected);
-    UtAssert_True(id2 == 0, "OS_ObjectIdFinalizeNew() id (%lx) == 0", (unsigned long)id2);
-    UtAssert_True(rec2->active_id == 0, "OS_ObjectIdFinalizeNew() active_id cleared");
+    OSAPI_TEST_OBJID(id2,==,OS_OBJECT_ID_UNDEFINED);
+    OSAPI_TEST_OBJID(rec2->active_id,==,OS_OBJECT_ID_UNDEFINED);
 
     /* next call should re-issue the same id because init failed */
     expected = OS_SUCCESS;
     actual = OS_ObjectIdFindNext(OS_OBJECT_TYPE_OS_TASK, NULL, &rec2);
     UtAssert_True(actual == expected, "OS_ObjectIdFindNext() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(rec2->active_id == saved_id, "OS_ObjectIdFindNext() id (%lx) != %lx",
-            (unsigned long)rec2->active_id, (unsigned long)saved_id);
-
+    OSAPI_TEST_OBJID(rec2->active_id,==,saved_id.id);
 
     /* test invalid case*/
-    rec2->active_id = 0;
+    rec2->active_id = OS_OBJECT_ID_UNDEFINED;
     expected = OS_ERR_INVALID_ID;
     actual = OS_ObjectIdFinalizeNew(OS_SUCCESS, rec2, &id2);
     UtAssert_True(actual == expected, "OS_ObjectIdFinalizeNew() (%ld) == %ld", (long)actual, (long)expected);
-    UtAssert_True(id2 == 0, "OS_ObjectIdFinalizeNew() id (%lx) == 0", (unsigned long)id2);
-    UtAssert_True(rec2->active_id == 0, "OS_ObjectIdFinalizeNew() active_id cleared");
+    OSAPI_TEST_OBJID(id2,==,OS_OBJECT_ID_UNDEFINED);
+    OSAPI_TEST_OBJID(rec2->active_id,==,OS_OBJECT_ID_UNDEFINED);
 
     /*
      * Finally - test the wrap-around function to verify that object IDs
      * will continue to allocate correctly after OS_OBJECT_INDEX_MASK
      */
     expected = OS_SUCCESS;
-    saved_id = 0;
+    saved_id.id = OS_OBJECT_ID_UNDEFINED;
     for (i=0; i < (OS_OBJECT_INDEX_MASK+2); ++i)
     {
         actual = OS_ObjectIdFindNext(OS_OBJECT_TYPE_OS_TASK, NULL, &rec2);
@@ -495,16 +495,17 @@ void Test_OS_ObjectIdFindNext(void)
         }
 
         /* should always be different than the previous ID */
-        if (saved_id == rec2->active_id)
+        if (OS_ObjectIdEqual(saved_id.id, rec2->active_id))
         {
-            UtAssert_Failed("OS_ObjectIdFindNext() re-issued ID (%lx)",(unsigned long)saved_id);
+            UtAssert_Failed("OS_ObjectIdFindNext() re-issued ID (%lx)",(unsigned long)saved_id.val);
             break;
         }
 
         /* it also should never be id1, which was previously allocated */
-        if (id1 == rec2->active_id)
+        check_id.id = id1;
+        if (OS_ObjectIdEqual(check_id.id, rec2->active_id))
         {
-            UtAssert_Failed("OS_ObjectIdFindNext() duplicate ID (%lx)",(unsigned long)id1);
+            UtAssert_Failed("OS_ObjectIdFindNext() duplicate ID (%lx)",(unsigned long)check_id.val);
             break;
         }
         if (rec1 == rec2)
@@ -514,15 +515,16 @@ void Test_OS_ObjectIdFindNext(void)
         }
 
         /* Find the wrap.  Once this occurs the test is successful. */
-        if (saved_id > rec2->active_id)
+        check_id.id = rec2->active_id;
+        if (saved_id.val > check_id.val)
         {
             /* Success */
             break;
         }
 
         /* clear the entry for re-use */
-        saved_id = rec2->active_id;
-        rec2->active_id = 0;
+        saved_id.id = rec2->active_id;
+        rec2->active_id = OS_OBJECT_ID_UNDEFINED;
     }
 
     /* verify that the wrap occurred */
@@ -541,32 +543,32 @@ void Test_OS_ObjectIdAllocateNew(void)
      */
     int32 expected = OS_SUCCESS;
     int32 actual   = ~OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    uint32 indx;
     OS_common_record_t *rptr = NULL;
 
-    actual = OS_ObjectIdAllocateNew(OS_OBJECT_TYPE_OS_TASK, "UT_alloc", &objid, &rptr);
+    actual = OS_ObjectIdAllocateNew(OS_OBJECT_TYPE_OS_TASK, "UT_alloc", &indx, &rptr);
 
     /* Verify Outputs */
     UtAssert_True(actual == expected, "OS_ObjectIdAllocate() (%ld) == OS_SUCCESS", (long)actual);
     UtAssert_True(rptr != NULL, "rptr (%p) != NULL", (void*)rptr);
 
     /* Passing a NULL name also should work here (used for internal objects) */
-    actual = OS_ObjectIdAllocateNew(OS_OBJECT_TYPE_OS_TASK, NULL, &objid, &rptr);
+    actual = OS_ObjectIdAllocateNew(OS_OBJECT_TYPE_OS_TASK, NULL, &indx, &rptr);
     UtAssert_True(actual == expected, "OS_ObjectIdAllocate(NULL) (%ld) == OS_SUCCESS", (long)actual);
 
     rptr->name_entry = "UT_alloc";
     expected = OS_ERR_NAME_TAKEN;
-    actual = OS_ObjectIdAllocateNew(OS_OBJECT_TYPE_OS_TASK, "UT_alloc", &objid, &rptr);
+    actual = OS_ObjectIdAllocateNew(OS_OBJECT_TYPE_OS_TASK, "UT_alloc", &indx, &rptr);
     UtAssert_True(actual == expected, "OS_ObjectIdAllocate() (%ld) == OS_ERR_NAME_TAKEN", (long)actual);
 
     OS_SharedGlobalVars.ShutdownFlag = OS_SHUTDOWN_MAGIC_NUMBER;
     expected = OS_ERROR;
-    actual = OS_ObjectIdAllocateNew(OS_OBJECT_TYPE_OS_TASK, "UT_alloc", &objid, &rptr);
+    actual = OS_ObjectIdAllocateNew(OS_OBJECT_TYPE_OS_TASK, "UT_alloc", &indx, &rptr);
     OS_SharedGlobalVars.ShutdownFlag = 0;
     UtAssert_True(actual == expected, "OS_ObjectIdAllocate() (%ld) == OS_ERR_NAME_TAKEN", (long)actual);
 
     expected = OS_ERR_INCORRECT_OBJ_TYPE;
-    actual = OS_ObjectIdAllocateNew(0xFFFFFFFF, "UT_alloc", &objid, &rptr);
+    actual = OS_ObjectIdAllocateNew(0xFFFFFFFF, "UT_alloc", &indx, &rptr);
     UtAssert_True(actual == expected, "OS_ObjectIdAllocate() (%ld) == OS_ERR_INCORRECT_OBJ_TYPE", (long)actual);
 
 }
@@ -593,7 +595,7 @@ void Test_OS_ConvertToArrayIndex(void)
             (unsigned long)local_idx1, (unsigned long)local_idx2);
 
     expected = OS_ERR_INVALID_ID;
-    actual = OS_ConvertToArrayIndex(0, &local_idx2);
+    actual = OS_ConvertToArrayIndex(OS_OBJECT_ID_UNDEFINED, &local_idx2);
     UtAssert_True(actual == expected, "OS_ConvertToArrayIndex() (%ld) == OS_ERR_INVALID_ID", (long)actual);
 }
 
@@ -606,10 +608,10 @@ void Test_OS_ForEachObject(void)
     uint32 objtype = OS_OBJECT_TYPE_UNDEFINED;
     OS_common_record_t *rptr = NULL;
     uint32 local_idx = 0xFFFFFFFF;
-    uint32 self_id;
+    UT_idbuf_t self_id;
     Test_OS_ObjTypeCount_t Count;
 
-    self_id = OS_TaskGetId();
+    self_id.id = OS_TaskGetId();
 
     memset(&Count, 0, sizeof(Count));
 
@@ -619,7 +621,7 @@ void Test_OS_ForEachObject(void)
         ++objtype;
     }
 
-    OS_ForEachObject (0, &ObjTypeCounter, &Count);
+    OS_ForEachObject (OS_OBJECT_ID_UNDEFINED, &ObjTypeCounter, &Count);
 
     /* Verify Outputs */
     UtAssert_True(Count.TaskCount == 1, "OS_ForEachObject() TaskCount (%lu) == 1", (unsigned long)Count.TaskCount);
@@ -627,12 +629,13 @@ void Test_OS_ForEachObject(void)
     UtAssert_True(Count.MutexCount == 1, "OS_ForEachObject() MutexCount (%lu) == 1", (unsigned long)Count.MutexCount);
     UtAssert_True(Count.OtherCount == 9, "OS_ForEachObject() OtherCount (%lu) == 9", (unsigned long)Count.OtherCount);
 
-    OS_ForEachObjectOfType(OS_OBJECT_TYPE_OS_QUEUE, self_id, ObjTypeCounter, &Count);
-    UtAssert_True(Count.TaskCount == 1, "OS_ForEachObjectOfType(), creator %08lx TaskCount (%lu) == 1", (unsigned long)self_id, (unsigned long)Count.TaskCount);
+    OS_ForEachObjectOfType(OS_OBJECT_TYPE_OS_QUEUE, self_id.id, ObjTypeCounter, &Count);
+    UtAssert_True(Count.TaskCount == 1, "OS_ForEachObjectOfType(), creator %08lx TaskCount (%lu) == 1", (unsigned long)self_id.val, (unsigned long)Count.TaskCount);
     UtAssert_True(Count.QueueCount == 2, "OS_ForEachObjectOfType() QueueCount (%lu) == 2", (unsigned long)Count.QueueCount);
     UtAssert_True(Count.MutexCount == 1, "OS_ForEachObjectOfType() MutexCount (%lu) == 1", (unsigned long)Count.MutexCount);
 
-    OS_ForEachObjectOfType(OS_OBJECT_TYPE_OS_QUEUE, self_id ^ 1, ObjTypeCounter, &Count);
+    self_id.val ^= 0x01;
+    OS_ForEachObjectOfType(OS_OBJECT_TYPE_OS_QUEUE, self_id.id, ObjTypeCounter, &Count);
     UtAssert_True(Count.TaskCount == 1, "OS_ForEachObjectOfType(), non-matching creator TaskCount (%lu) == 1", (unsigned long)Count.TaskCount);
     UtAssert_True(Count.QueueCount == 2, "OS_ForEachObjectOfType() QueueCount (%lu) == 2", (unsigned long)Count.QueueCount);
     UtAssert_True(Count.MutexCount == 1, "OS_ForEachObjectOfType() MutexCount (%lu) == 1", (unsigned long)Count.MutexCount);
diff --git a/src/unit-test-coverage/shared/src/coveragetest-module.c b/src/unit-test-coverage/shared/src/coveragetest-module.c
index a6f71562b..64a9d415c 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-module.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-module.c
@@ -75,13 +75,13 @@ void Test_OS_ModuleLoad(void)
      * int32 OS_ModuleLoad ( uint32 *module_id, const char *module_name, const char *filename )
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 actual = OS_ModuleLoad(&objid, "UT", "File");
 
     UtAssert_True(actual == expected, "OS_ModuleLoad() (%ld) == OS_SUCCESS", (long)actual);
     actual = UT_GetStubCount(UT_KEY(OS_ModuleLoad_Impl));
     UtAssert_True(actual == 1, "OS_ModuleLoad_Impl() called (%ld) == 1", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
 
 
     /* for a static module, it should also return a valid objid, but should NOT invoke OS_ModuleLoad_Impl */
@@ -89,7 +89,7 @@ void Test_OS_ModuleLoad(void)
     UtAssert_True(actual == expected, "OS_ModuleLoad() (%ld) == OS_SUCCESS", (long)actual);
     actual = UT_GetStubCount(UT_KEY(OS_ModuleLoad_Impl));
     UtAssert_True(actual == 1, "OS_ModuleLoad_Impl() called (%ld) == 1", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
 
     /* error cases */
     actual = OS_ModuleLoad(NULL,NULL,NULL);
@@ -119,7 +119,7 @@ void Test_OS_ModuleUnload(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_ModuleUnload(1);
+    actual = OS_ModuleUnload(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_ModuleDelete() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -241,12 +241,12 @@ void Test_OS_ModuleGetInfo(void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 111;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     strncpy(OS_module_table[1].file_name, "DEF", sizeof(OS_module_table[1].file_name));
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_ModuleInfo(1, &module_prop);
+    actual = OS_ModuleInfo(UT_OBJID_1, &module_prop);
 
     UtAssert_True(actual == expected, "OS_ModuleGetInfo() (%ld) == OS_SUCCESS", (long)actual);
     UtAssert_True(strcmp(module_prop.filename, "DEF") == 0, "module_prop.filename (%s) == DEF",
@@ -255,7 +255,7 @@ void Test_OS_ModuleGetInfo(void)
             module_prop.name);
 
 
-    actual = OS_ModuleInfo(1, NULL);
+    actual = OS_ModuleInfo(UT_OBJID_1, NULL);
     expected = OS_INVALID_POINTER;
     UtAssert_True(actual == expected, "OS_ModuleGetInfo(NULL) (%ld) == OS_INVALID_POINTER", (long)actual);
 }
diff --git a/src/unit-test-coverage/shared/src/coveragetest-mutex.c b/src/unit-test-coverage/shared/src/coveragetest-mutex.c
index ce9f865e2..c970eb1a9 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-mutex.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-mutex.c
@@ -55,11 +55,11 @@ void Test_OS_MutSemCreate(void)
      * int32 OS_MutSemCreate (uint32 *sem_id, const char *sem_name, uint32 options)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 actual = OS_MutSemCreate(&objid, "UT", 0);
 
     UtAssert_True(actual == expected, "OS_MutSemCreate() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
 
     OSAPI_TEST_FUNCTION_RC(OS_MutSemCreate(NULL, NULL, 0), OS_INVALID_POINTER);
     UT_SetForceFail(UT_KEY(OCS_strlen), 10 + OS_MAX_API_NAME);
@@ -75,7 +75,7 @@ void Test_OS_MutSemDelete(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_MutSemDelete(1);
+    actual = OS_MutSemDelete(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_MutSemDelete() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -89,7 +89,7 @@ void Test_OS_MutSemGive(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_MutSemGive(1);
+    actual = OS_MutSemGive(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_MutSemGive() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -104,7 +104,7 @@ void Test_OS_MutSemTake(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_MutSemTake(1);
+    actual = OS_MutSemTake(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_MutSemTake() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -117,12 +117,12 @@ void Test_OS_MutSemGetIdByName(void)
      */
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
-    uint32 objid = 0;
+    osal_id_t objid;
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdFindByName), OS_SUCCESS);
     actual = OS_MutSemGetIdByName(&objid, "UT");
     UtAssert_True(actual == expected, "OS_MutSemGetIdByName() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "OS_MutSemGetIdByName() objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdFindByName));
 
     expected = OS_ERR_NAME_NOT_FOUND;
@@ -148,19 +148,18 @@ void Test_OS_MutSemGetInfo(void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 111;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_MutSemGetInfo(1, &prop);
+    actual = OS_MutSemGetInfo(UT_OBJID_1, &prop);
 
     UtAssert_True(actual == expected, "OS_MutSemGetInfo() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(prop.creator == 111, "prop.creator (%lu) == 111",
-            (unsigned long)prop.creator);
+    OSAPI_TEST_OBJID(prop.creator,==,UT_OBJID_OTHER);
     UtAssert_True(strcmp(prop.name, "ABC") == 0, "prop.name (%s) == ABC",
             prop.name);
 
-    OSAPI_TEST_FUNCTION_RC(OS_MutSemGetInfo(0, NULL), OS_INVALID_POINTER);
+    OSAPI_TEST_FUNCTION_RC(OS_MutSemGetInfo(UT_OBJID_1, NULL), OS_INVALID_POINTER);
 
 }
 
diff --git a/src/unit-test-coverage/shared/src/coveragetest-printf.c b/src/unit-test-coverage/shared/src/coveragetest-printf.c
index 12b08f128..6469d906f 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-printf.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-printf.c
@@ -62,7 +62,7 @@ void Test_OS_printf(void)
     uint32 CallCount = 0;
 
     /* catch case where OS_printf called before init */
-    OS_SharedGlobalVars.PrintfConsoleId = 0;
+    OS_SharedGlobalVars.PrintfConsoleId = OS_OBJECT_ID_UNDEFINED;
     OS_SharedGlobalVars.Initialized = false;
     OS_printf("UnitTest1");
     UtAssert_True(OS_console_table[0].WritePos == 0, "WritePos (%lu) >= 0", (unsigned long)OS_console_table[0].WritePos);
diff --git a/src/unit-test-coverage/shared/src/coveragetest-queue.c b/src/unit-test-coverage/shared/src/coveragetest-queue.c
index 3f1626128..c322ff5bd 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-queue.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-queue.c
@@ -54,11 +54,10 @@ void Test_OS_QueueCreate(void)
      * int32 OS_QueueCreate (uint32 *queue_id, const char *queue_name, uint32 queue_depth, uint32 data_size, uint32 flags)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 actual = OS_QueueCreate(&objid, "UT", 0, 0,0);
 
     UtAssert_True(actual == expected, "OS_QueueCreate() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
 
     /* test error cases */
     expected = OS_INVALID_POINTER;
@@ -85,7 +84,7 @@ void Test_OS_QueueDelete(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
 
-    actual = OS_QueueDelete(1);
+    actual = OS_QueueDelete(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_QueueDelete() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -101,18 +100,18 @@ void Test_OS_QueueGet(void)
     uint32 actual_size;
     char Buf[4];
 
-    actual = OS_QueueGet(1, Buf, sizeof(Buf), &actual_size, 0);
+    actual = OS_QueueGet(UT_OBJID_1, Buf, sizeof(Buf), &actual_size, 0);
 
     UtAssert_True(actual == expected, "OS_QueueGet() (%ld) == OS_SUCCESS", (long)actual);
 
     /* test error cases */
     expected = OS_INVALID_POINTER;
-    actual = OS_QueueGet(1, NULL, sizeof(Buf), &actual_size, 0);
+    actual = OS_QueueGet(UT_OBJID_1, NULL, sizeof(Buf), &actual_size, 0);
     UtAssert_True(actual == expected, "OS_QueueGet() (%ld) == OS_INVALID_POINTER", (long)actual);
 
     OS_queue_table[1].max_size = sizeof(Buf) + 10;
     expected = OS_QUEUE_INVALID_SIZE;
-    actual = OS_QueueGet(1, Buf, sizeof(Buf), &actual_size, 0);
+    actual = OS_QueueGet(UT_OBJID_1, Buf, sizeof(Buf), &actual_size, 0);
     UtAssert_True(actual == expected, "OS_QueueGet() (%ld) == OS_QUEUE_INVALID_SIZE", (long)actual);
 }
 
@@ -127,13 +126,13 @@ void Test_OS_QueuePut(void)
     int32 actual = ~OS_SUCCESS;
     const char Data[4] = "xyz";
 
-    actual = OS_QueuePut(1, Data, sizeof(Data), 0);
+    actual = OS_QueuePut(UT_OBJID_1, Data, sizeof(Data), 0);
 
     UtAssert_True(actual == expected, "OS_QueuePut() (%ld) == OS_SUCCESS", (long)actual);
 
     /* test error cases */
     expected = OS_INVALID_POINTER;
-    actual = OS_QueuePut(1, NULL, sizeof(Data), 0);
+    actual = OS_QueuePut(UT_OBJID_1, NULL, sizeof(Data), 0);
     UtAssert_True(actual == expected, "OS_QueuePut() (%ld) == OS_INVALID_POINTER", (long)actual);
 
 }
@@ -147,12 +146,11 @@ void Test_OS_QueueGetIdByName(void)
      */
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
-    uint32 objid = 0;
+    osal_id_t objid;
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdFindByName), OS_SUCCESS);
     actual = OS_QueueGetIdByName(&objid, "UT");
     UtAssert_True(actual == expected, "OS_QueueGetIdByName() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "OS_QueueGetIdByName() objid (%lu) != 0", (unsigned long)objid);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdFindByName));
 
     expected = OS_ERR_NAME_NOT_FOUND;
@@ -175,25 +173,26 @@ void Test_OS_QueueGetInfo(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
     OS_queue_prop_t queue_prop;
+    osal_id_t id;
     uint32 local_index = 1;
     OS_common_record_t utrec;
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 111;
+    id = UT_OBJID_OTHER;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_QueueGetInfo(1, &queue_prop);
+    actual = OS_QueueGetInfo(UT_OBJID_1, &queue_prop);
 
     UtAssert_True(actual == expected, "OS_QueueGetInfo() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(queue_prop.creator == 111, "queue_prop.creator (%lu) == 111",
-            (unsigned long)queue_prop.creator);
+    UtAssert_MemCmp(&queue_prop.creator, &id, sizeof(osal_id_t), "queue_prop.creator == UT_OBJID_OTHER");
     UtAssert_True(strcmp(queue_prop.name, "ABC") == 0, "queue_prop.name (%s) == ABC",
             queue_prop.name);
 
     expected = OS_INVALID_POINTER;
-    actual = OS_QueueGetInfo(1, NULL);
+    actual = OS_QueueGetInfo(UT_OBJID_1, NULL);
     UtAssert_True(actual == expected, "OS_QueueGetInfo() (%ld) == OS_INVALID_POINTER", (long)actual);
 }
 
diff --git a/src/unit-test-coverage/shared/src/coveragetest-select.c b/src/unit-test-coverage/shared/src/coveragetest-select.c
index ffcfd2b20..c493c9d2c 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-select.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-select.c
@@ -43,7 +43,7 @@ void Test_OS_SelectSingle(void)
      */
     int32 expected = OS_SUCCESS;
     uint32 StateFlags = 0;
-    int32 actual = OS_SelectSingle(1, &StateFlags, 0);
+    int32 actual = OS_SelectSingle(UT_OBJID_1, &StateFlags, 0);
 
     /* Verify Outputs */
     UtAssert_True(actual == expected, "OS_SelectSingle() (%ld) == OS_SUCCESS", (long)actual);
@@ -88,37 +88,37 @@ void Test_OS_SelectFdAddClearOps(void)
     UtAssert_True(actual == expected, "OS_SelectSingle() (%ld) == OS_SUCCESS", (long)actual);
     CallCount = UT_GetStubCount(UT_KEY(OCS_memset));
     UtAssert_True(CallCount == 1, "memset() call count (%lu) == 1", (unsigned long)CallCount);
-    UtAssert_True(!OS_SelectFdIsSet(&UtSet, 1), "OS_SelectFdIsSet(1) == false");
-    UtAssert_True(!OS_SelectFdIsSet(&UtSet, 2), "OS_SelectFdIsSet(2) == false");
+    UtAssert_True(!OS_SelectFdIsSet(&UtSet, UT_OBJID_1), "OS_SelectFdIsSet(1) == false");
+    UtAssert_True(!OS_SelectFdIsSet(&UtSet, UT_OBJID_2), "OS_SelectFdIsSet(2) == false");
 
     expected = OS_SUCCESS;
-    actual = OS_SelectFdAdd(&UtSet, 1);
+    actual = OS_SelectFdAdd(&UtSet, UT_OBJID_1);
     UtAssert_True(actual == expected, "OS_SelectFdAdd() (%ld) == %ld", (long)actual, (long)expected);
-    UtAssert_True(OS_SelectFdIsSet(&UtSet, 1), "OS_SelectFdIsSet(1) == true");
-    UtAssert_True(!OS_SelectFdIsSet(&UtSet, 2), "OS_SelectFdIsSet(2) == false");
-    actual = OS_SelectFdAdd(&UtSet, 2);
+    UtAssert_True(OS_SelectFdIsSet(&UtSet, UT_OBJID_1), "OS_SelectFdIsSet(1) == true");
+    UtAssert_True(!OS_SelectFdIsSet(&UtSet, UT_OBJID_2), "OS_SelectFdIsSet(2) == false");
+    actual = OS_SelectFdAdd(&UtSet, UT_OBJID_2);
     UtAssert_True(actual == expected, "OS_SelectFdAdd() (%ld) == %ld", (long)actual, (long)expected);
-    UtAssert_True(OS_SelectFdIsSet(&UtSet, 1), "OS_SelectFdIsSet(1) == true");
-    UtAssert_True(OS_SelectFdIsSet(&UtSet, 2), "OS_SelectFdIsSet(2) == true");
+    UtAssert_True(OS_SelectFdIsSet(&UtSet, UT_OBJID_1), "OS_SelectFdIsSet(1) == true");
+    UtAssert_True(OS_SelectFdIsSet(&UtSet, UT_OBJID_2), "OS_SelectFdIsSet(2) == true");
 
-    actual = OS_SelectFdClear(&UtSet, 2);
+    actual = OS_SelectFdClear(&UtSet, UT_OBJID_2);
     UtAssert_True(actual == expected, "OS_SelectFdClear() (%ld) == %ld", (long)actual, (long)expected);
-    UtAssert_True(OS_SelectFdIsSet(&UtSet, 1), "OS_SelectFdIsSet(1) == true");
-    UtAssert_True(!OS_SelectFdIsSet(&UtSet, 2), "OS_SelectFdIsSet(2) == false");
+    UtAssert_True(OS_SelectFdIsSet(&UtSet, UT_OBJID_1), "OS_SelectFdIsSet(1) == true");
+    UtAssert_True(!OS_SelectFdIsSet(&UtSet, UT_OBJID_2), "OS_SelectFdIsSet(2) == false");
 
 
     expected = -42;
     UT_SetForceFail(UT_KEY(OS_ObjectIdToArrayIndex), expected);
-    actual = OS_SelectFdAdd(&UtSet, 2);
+    actual = OS_SelectFdAdd(&UtSet, UT_OBJID_2);
     UtAssert_True(actual == expected, "OS_SelectFdAdd() (%ld) == %ld", (long)actual, (long)expected);
-    actual = OS_SelectFdClear(&UtSet, 1);
+    actual = OS_SelectFdClear(&UtSet, UT_OBJID_1);
     UtAssert_True(actual == expected, "OS_SelectFdClear() (%ld) == %ld", (long)actual, (long)expected);
-    UtAssert_True(!OS_SelectFdIsSet(&UtSet, 1), "OS_SelectFdIsSet(1) == false");
-    UtAssert_True(!OS_SelectFdIsSet(&UtSet, 2), "OS_SelectFdIsSet(2) == false");
+    UtAssert_True(!OS_SelectFdIsSet(&UtSet, UT_OBJID_1), "OS_SelectFdIsSet(1) == false");
+    UtAssert_True(!OS_SelectFdIsSet(&UtSet, UT_OBJID_2), "OS_SelectFdIsSet(2) == false");
 
     UT_ClearForceFail(UT_KEY(OS_ObjectIdToArrayIndex));
-    UtAssert_True(OS_SelectFdIsSet(&UtSet, 1), "OS_SelectFdIsSet(1) == true");
-    UtAssert_True(!OS_SelectFdIsSet(&UtSet, 2), "OS_SelectFdIsSet(2) == false");
+    UtAssert_True(OS_SelectFdIsSet(&UtSet, UT_OBJID_1), "OS_SelectFdIsSet(1) == true");
+    UtAssert_True(!OS_SelectFdIsSet(&UtSet, UT_OBJID_2), "OS_SelectFdIsSet(2) == false");
 }
 
 /* Osapi_Test_Setup
diff --git a/src/unit-test-coverage/shared/src/coveragetest-sockets.c b/src/unit-test-coverage/shared/src/coveragetest-sockets.c
index da75006b7..c55ac1cd8 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-sockets.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-sockets.c
@@ -82,11 +82,11 @@ void Test_OS_SocketOpen(void)
      * int32 OS_SocketOpen(uint32 *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t Type)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 actual = OS_SocketOpen(&objid, OS_SocketDomain_INET, OS_SocketType_STREAM);
 
     UtAssert_True(actual == expected, "OS_SocketOpen() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
 
     expected = OS_INVALID_POINTER;
     actual = OS_SocketOpen(NULL, OS_SocketDomain_INVALID, OS_SocketType_INVALID);
@@ -111,12 +111,12 @@ void Test_OS_SocketBind(void)
 
     OS_stream_table[1].socket_domain = OS_SocketDomain_INET;
     memset(&Addr,0,sizeof(Addr));
-    actual = OS_SocketBind(1, &Addr);
+    actual = OS_SocketBind(UT_OBJID_1, &Addr);
 
     UtAssert_True(actual == expected, "OS_SocketBind() (%ld) == OS_SUCCESS", (long)actual);
 
     expected = OS_INVALID_POINTER;
-    actual = OS_SocketBind(1, NULL);
+    actual = OS_SocketBind(UT_OBJID_1, NULL);
     UtAssert_True(actual == expected, "OS_SocketBind(NULL) (%ld) == OS_INVALID_POINTER", (long)actual);
 
     /*
@@ -124,7 +124,7 @@ void Test_OS_SocketBind(void)
      */
     OS_stream_table[1].socket_domain = OS_SocketDomain_INVALID;
     expected = OS_ERR_INCORRECT_OBJ_TYPE;
-    actual = OS_SocketBind(1, &Addr);
+    actual = OS_SocketBind(UT_OBJID_1, &Addr);
     UtAssert_True(actual == expected, "OS_SocketBind() non-socket (%ld) == OS_ERR_INCORRECT_OBJ_TYPE", (long)actual);
 
     /*
@@ -133,7 +133,7 @@ void Test_OS_SocketBind(void)
     OS_stream_table[1].socket_domain = OS_SocketDomain_INET;
     OS_stream_table[1].stream_state = OS_STREAM_STATE_BOUND;
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_SocketBind(1, &Addr);
+    actual = OS_SocketBind(UT_OBJID_1, &Addr);
     UtAssert_True(actual == expected, "OS_SocketBind() already bound (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
 }
 
@@ -151,21 +151,21 @@ void Test_OS_SocketAccept(void)
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
     uint32 local_id = 0;
-    uint32 connsock_id;
+    osal_id_t connsock_id;
     OS_SockAddr_t Addr;
 
-    connsock_id = 0;
+    connsock_id = OS_OBJECT_ID_UNDEFINED;
 
     OS_stream_table[local_id].socket_type = OS_SocketType_STREAM;
     OS_stream_table[local_id].stream_state = OS_STREAM_STATE_BOUND;
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_id, sizeof(local_id), false);
     memset(&Addr,0,sizeof(Addr));
-    actual = OS_SocketAccept(1, &connsock_id, &Addr, 0);
+    actual = OS_SocketAccept(UT_OBJID_1, &connsock_id, &Addr, 0);
 
     UtAssert_True(actual == expected, "OS_SocketAccept() (%ld) == OS_SUCCESS", (long)actual);
 
     expected = OS_INVALID_POINTER;
-    actual = OS_SocketAccept(1, NULL, NULL, 0);
+    actual = OS_SocketAccept(UT_OBJID_1, NULL, NULL, 0);
     UtAssert_True(actual == expected, "OS_SocketAccept(NULL) (%ld) == OS_INVALID_POINTER", (long)actual);
 
     /*
@@ -173,7 +173,7 @@ void Test_OS_SocketAccept(void)
      */
     OS_stream_table[1].socket_type = OS_SocketType_INVALID;
     expected = OS_ERR_INCORRECT_OBJ_TYPE;
-    actual = OS_SocketAccept(1, &connsock_id, &Addr, 0);
+    actual = OS_SocketAccept(UT_OBJID_1, &connsock_id, &Addr, 0);
     UtAssert_True(actual == expected, "OS_SocketAccept() non-stream (%ld) == OS_ERR_INCORRECT_OBJ_TYPE", (long)actual);
 
     /*
@@ -182,7 +182,7 @@ void Test_OS_SocketAccept(void)
     OS_stream_table[1].socket_type = OS_SocketType_STREAM;
     OS_stream_table[1].stream_state = OS_STREAM_STATE_BOUND|OS_STREAM_STATE_CONNECTED;
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_SocketAccept(1, &connsock_id, &Addr, 0);
+    actual = OS_SocketAccept(UT_OBJID_1, &connsock_id, &Addr, 0);
     UtAssert_True(actual == expected, "OS_SocketAccept() already bound (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
 
     /*
@@ -191,7 +191,7 @@ void Test_OS_SocketAccept(void)
     OS_stream_table[1].stream_state = OS_STREAM_STATE_BOUND;
     expected = -1234;
     UT_SetForceFail(UT_KEY(OS_SocketAccept_Impl), -1234);
-    actual = OS_SocketAccept(1, &connsock_id, &Addr, 0);
+    actual = OS_SocketAccept(UT_OBJID_1, &connsock_id, &Addr, 0);
     UtAssert_True(actual == expected, "OS_SocketAccept() underlying failure (%ld) == -1234", (long)actual);
 }
 
@@ -218,12 +218,12 @@ void Test_OS_SocketConnect(void)
     OS_stream_table[idbuf].socket_type = OS_SocketType_STREAM;
     OS_stream_table[idbuf].stream_state = 0;
 
-    actual = OS_SocketConnect(1, &Addr, 0);
+    actual = OS_SocketConnect(UT_OBJID_1, &Addr, 0);
 
     UtAssert_True(actual == expected, "OS_SocketConnect() (%ld) == OS_SUCCESS", (long)actual);
 
     expected = OS_INVALID_POINTER;
-    actual = OS_SocketConnect(1, NULL, 0);
+    actual = OS_SocketConnect(UT_OBJID_1, NULL, 0);
     UtAssert_True(actual == expected, "OS_SocketConnect(NULL) (%ld) == OS_INVALID_POINTER", (long)actual);
 
     /*
@@ -232,7 +232,7 @@ void Test_OS_SocketConnect(void)
     OS_stream_table[1].socket_domain = OS_SocketDomain_INVALID;
     OS_stream_table[1].socket_type = OS_SocketType_INVALID;
     expected = OS_ERR_INCORRECT_OBJ_TYPE;
-    actual = OS_SocketConnect(1, &Addr, 0);
+    actual = OS_SocketConnect(UT_OBJID_1, &Addr, 0);
     UtAssert_True(actual == expected, "OS_SocketConnect() non-stream (%ld) == OS_ERR_INCORRECT_OBJ_TYPE", (long)actual);
 
     /*
@@ -242,7 +242,7 @@ void Test_OS_SocketConnect(void)
     OS_stream_table[1].socket_type = OS_SocketType_STREAM;
     OS_stream_table[1].stream_state = OS_STREAM_STATE_CONNECTED;
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_SocketConnect(1, &Addr, 0);
+    actual = OS_SocketConnect(UT_OBJID_1, &Addr, 0);
     UtAssert_True(actual == expected, "OS_SocketConnect() already connected (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
 
 }
@@ -269,12 +269,12 @@ void Test_OS_SocketRecvFrom(void)
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById),&idbuf, sizeof(idbuf), false);
     OS_stream_table[idbuf].socket_type = OS_SocketType_DATAGRAM;
     OS_stream_table[idbuf].stream_state = OS_STREAM_STATE_BOUND;
-    actual = OS_SocketRecvFrom(1, &Buf, 1, &Addr, 0);
+    actual = OS_SocketRecvFrom(UT_OBJID_1, &Buf, 1, &Addr, 0);
 
     UtAssert_True(actual == expected, "OS_SocketRecvFrom() (%ld) == OS_SUCCESS", (long)actual);
 
     expected = OS_INVALID_POINTER;
-    actual = OS_SocketRecvFrom(1, NULL, 0, NULL, 0);
+    actual = OS_SocketRecvFrom(UT_OBJID_1, NULL, 0, NULL, 0);
     UtAssert_True(actual == expected, "OS_SocketRecvFrom(NULL) (%ld) == OS_INVALID_POINTER", (long)actual);
 
     /*
@@ -282,7 +282,7 @@ void Test_OS_SocketRecvFrom(void)
      */
     OS_stream_table[1].socket_type = OS_SocketType_INVALID;
     expected = OS_ERR_INCORRECT_OBJ_TYPE;
-    actual = OS_SocketRecvFrom(1, &Buf, 1, &Addr, 0);
+    actual = OS_SocketRecvFrom(UT_OBJID_1, &Buf, 1, &Addr, 0);
     UtAssert_True(actual == expected, "OS_SocketRecvFrom() non-datagram (%ld) == OS_ERR_INCORRECT_OBJ_TYPE", (long)actual);
 
     /*
@@ -291,7 +291,7 @@ void Test_OS_SocketRecvFrom(void)
     OS_stream_table[1].socket_type = OS_SocketType_DATAGRAM;
     OS_stream_table[1].stream_state = 0;
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_SocketRecvFrom(1, &Buf, 1, &Addr, 0);
+    actual = OS_SocketRecvFrom(UT_OBJID_1, &Buf, 1, &Addr, 0);
     UtAssert_True(actual == expected, "OS_SocketRecvFrom() non-bound (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
 }
 
@@ -317,12 +317,12 @@ void Test_OS_SocketSendTo(void)
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById),&idbuf, sizeof(idbuf), false);
     OS_stream_table[idbuf].socket_type = OS_SocketType_DATAGRAM;
     OS_stream_table[idbuf].stream_state = OS_STREAM_STATE_BOUND;
-    actual = OS_SocketSendTo(1, &Buf, 1, &Addr);
+    actual = OS_SocketSendTo(UT_OBJID_1, &Buf, 1, &Addr);
 
     UtAssert_True(actual == expected, "OS_SocketSendTo() (%ld) == OS_SUCCESS", (long)actual);
 
     expected = OS_INVALID_POINTER;
-    actual = OS_SocketSendTo(1, NULL, 0, NULL);
+    actual = OS_SocketSendTo(UT_OBJID_1, NULL, 0, NULL);
     UtAssert_True(actual == expected, "OS_SocketSendTo(NULL) (%ld) == OS_INVALID_POINTER", (long)actual);
 
     /*
@@ -330,7 +330,7 @@ void Test_OS_SocketSendTo(void)
      */
     OS_stream_table[1].socket_type = OS_SocketType_INVALID;
     expected = OS_ERR_INCORRECT_OBJ_TYPE;
-    actual = OS_SocketSendTo(1, &Buf, 1, &Addr);
+    actual = OS_SocketSendTo(UT_OBJID_1, &Buf, 1, &Addr);
     UtAssert_True(actual == expected, "OS_SocketSendTo() non-datagram (%ld) == OS_ERR_INCORRECT_OBJ_TYPE", (long)actual);
 }
 
@@ -348,12 +348,12 @@ void Test_OS_SocketGetIdByName (void)
      */
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
-    uint32 objid = 0;
+    osal_id_t objid;
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdFindByName), OS_SUCCESS);
     actual = OS_SocketGetIdByName(&objid, "UT");
     UtAssert_True(actual == expected, "OS_SocketGetIdByName() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "OS_SocketGetIdByName() objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdFindByName));
 
     expected = OS_ERR_NAME_NOT_FOUND;
@@ -386,20 +386,19 @@ void Test_OS_SocketGetInfo (void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 111;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_SocketGetInfo(1, &prop);
+    actual = OS_SocketGetInfo(UT_OBJID_1, &prop);
 
     UtAssert_True(actual == expected, "OS_SocketGetInfo() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(prop.creator == 111, "prop.creator (%lu) == 111",
-            (unsigned long)prop.creator);
+    OSAPI_TEST_OBJID(prop.creator,==,UT_OBJID_OTHER);
     UtAssert_True(strcmp(prop.name, "ABC") == 0, "prop.name (%s) == ABC",
             prop.name);
 
     expected = OS_INVALID_POINTER;
-    actual = OS_SocketGetInfo(1, NULL);
+    actual = OS_SocketGetInfo(UT_OBJID_1, NULL);
     UtAssert_True(actual == expected, "OS_SocketGetInfo() (%ld) == OS_INVALID_POINTER", (long)actual);
 
 }
diff --git a/src/unit-test-coverage/shared/src/coveragetest-task.c b/src/unit-test-coverage/shared/src/coveragetest-task.c
index 0a01acb8c..e634eb04f 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-task.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-task.c
@@ -56,7 +56,7 @@ void Test_OS_TaskEntryPoint(void)
     uint32 CallCount = 0;
 
     UT_TestHook_Count = 0;
-    OS_TaskEntryPoint(1);
+    OS_TaskEntryPoint(UT_OBJID_1);
     UtAssert_True(UT_TestHook_Count == 0, "UT_TestHook_Count (%lu) == 0",
             (unsigned long)UT_TestHook_Count);
     CallCount = UT_GetStubCount(UT_KEY(OS_TaskMatch_Impl));
@@ -67,10 +67,10 @@ void Test_OS_TaskEntryPoint(void)
     UtAssert_True(CallCount == 0, "OS_TaskRegister_Impl() count (%lu) == 0",
             (unsigned long)CallCount);
 
-    OS_global_task_table[1].active_id = 1;
+    OS_global_task_table[1].active_id = UT_OBJID_1;
     OS_task_table[1].entry_function_pointer = UT_TestHook;
 
-    OS_TaskEntryPoint(1);
+    OS_TaskEntryPoint(UT_OBJID_1);
     UtAssert_True(UT_TestHook_Count == 1, "UT_TestHook_Count (%lu) == 1",
             (unsigned long)UT_TestHook_Count);
     CallCount = UT_GetStubCount(UT_KEY(OS_TaskMatch_Impl));
@@ -81,7 +81,7 @@ void Test_OS_TaskEntryPoint(void)
     UtAssert_True(CallCount == 1, "OS_TaskRegister_Impl() count (%lu) == 1",
             (unsigned long)CallCount);
 
-    OS_global_task_table[1].active_id = 0;
+    OS_global_task_table[1].active_id = OS_OBJECT_ID_UNDEFINED;
     OS_task_table[1].entry_function_pointer = NULL;
 
 }
@@ -112,11 +112,11 @@ void Test_OS_TaskCreate(void)
      *                uint32 *stack_pointer, uint32 stack_size, uint32 priority, uint32 flags)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 actual = OS_TaskCreate(&objid, "UT", UT_TestHook, NULL, 128, 0, 0);
 
     UtAssert_True(actual == expected, "OS_TaskCreate() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
 
     OSAPI_TEST_FUNCTION_RC(OS_TaskCreate(NULL, NULL, NULL, NULL, 0, 0,0), OS_INVALID_POINTER);
     OSAPI_TEST_FUNCTION_RC(OS_TaskCreate(&objid, "UT", UT_TestHook, NULL, 0, 0, 0), OS_ERROR);
@@ -136,14 +136,14 @@ void Test_OS_TaskDelete(void)
 
     UT_TestHook_Count = 0;
     OS_task_table[1].delete_hook_pointer = UT_TestHook;
-    actual = OS_TaskDelete(1);
+    actual = OS_TaskDelete(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_TaskDelete() (%ld) == OS_SUCCESS", (long)actual);
     UtAssert_True(UT_TestHook_Count == 1, "UT_TestHook_Count (%lu) == 1",
             (unsigned long)UT_TestHook_Count);
 
     UT_SetForceFail(UT_KEY(OS_TaskDelete_Impl), OS_ERROR);
-    OSAPI_TEST_FUNCTION_RC(OS_TaskDelete(1), OS_ERROR);
+    OSAPI_TEST_FUNCTION_RC(OS_TaskDelete(UT_OBJID_1), OS_ERROR);
     UtAssert_True(UT_TestHook_Count == 1, "UT_TestHook_Count (%lu) == 1",
             (unsigned long)UT_TestHook_Count);
 
@@ -161,7 +161,7 @@ void Test_OS_TaskExit(void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.active_id = 1;
+    utrec.active_id = UT_OBJID_1;
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
 
@@ -188,11 +188,11 @@ void Test_OS_TaskSetPriority(void)
      * int32 OS_TaskSetPriority (uint32 task_id, uint32 new_priority)
      */
     int32 expected = OS_SUCCESS;
-    int32 actual = OS_TaskSetPriority(1, 1);
+    int32 actual = OS_TaskSetPriority(UT_OBJID_1, 1);
 
     UtAssert_True(actual == expected, "OS_TaskSetPriority() (%ld) == OS_SUCCESS", (long)actual);
 
-    OSAPI_TEST_FUNCTION_RC(OS_TaskSetPriority(1, 10 + OS_MAX_TASK_PRIORITY), OS_ERR_INVALID_PRIORITY);
+    OSAPI_TEST_FUNCTION_RC(OS_TaskSetPriority(UT_OBJID_1, 10 + OS_MAX_TASK_PRIORITY), OS_ERR_INVALID_PRIORITY);
 }
 void Test_OS_TaskRegister(void)
 {
@@ -211,11 +211,17 @@ void Test_OS_TaskGetId(void)
      * Test Case For:
      * uint32 OS_TaskGetId (void)
      */
-    UT_SetForceFail(UT_KEY(OS_TaskGetId_Impl), 5555);
-    OSAPI_TEST_FUNCTION_RC(OS_TaskGetId(), 5555);
+    UT_idbuf_t idbuf;
+    osal_id_t objid;
+
+    idbuf.val = 5555;
+    UT_SetForceFail(UT_KEY(OS_TaskGetId_Impl), idbuf.val);
+    objid = OS_TaskGetId();
+    OSAPI_TEST_OBJID(objid,==,idbuf.id);
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdGetById), OS_ERROR);
-    OSAPI_TEST_FUNCTION_RC(OS_TaskGetId(), 0);
+    objid = OS_TaskGetId();
+    OSAPI_TEST_OBJID(objid,==,OS_OBJECT_ID_UNDEFINED);
 }
 
 void Test_OS_TaskGetIdByName(void)
@@ -226,12 +232,12 @@ void Test_OS_TaskGetIdByName(void)
      */
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
-    uint32 objid = 0;
+    osal_id_t objid = OS_OBJECT_ID_UNDEFINED;
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdFindByName), OS_SUCCESS);
     actual = OS_TaskGetIdByName(&objid, "UT");
     UtAssert_True(actual == expected, "OS_TaskGetIdByName() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "OS_TaskGetIdByName() objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdFindByName));
 
     expected = OS_ERR_NAME_NOT_FOUND;
@@ -256,17 +262,16 @@ void Test_OS_TaskGetInfo(void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 111;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     OS_task_table[1].stack_size = 222;
     OS_task_table[1].priority = 333;
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_TaskGetInfo(1, &task_prop);
+    actual = OS_TaskGetInfo(UT_OBJID_1, &task_prop);
 
     UtAssert_True(actual == expected, "OS_TaskGetInfo() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(task_prop.creator == 111, "task_prop.creator (%lu) == 111",
-            (unsigned long)task_prop.creator);
+    OSAPI_TEST_OBJID(task_prop.creator, ==, UT_OBJID_OTHER);
     UtAssert_True(strcmp(task_prop.name, "ABC") == 0, "task_prop.name (%s) == ABC",
             task_prop.name);
     UtAssert_True(task_prop.stack_size == 222, "task_prop.stack_size (%lu) == 222",
@@ -277,7 +282,7 @@ void Test_OS_TaskGetInfo(void)
     OS_task_table[1].stack_size = 0;
     OS_task_table[1].priority = 0;
 
-    OSAPI_TEST_FUNCTION_RC(OS_TaskGetInfo(0, NULL), OS_INVALID_POINTER);
+    OSAPI_TEST_FUNCTION_RC(OS_TaskGetInfo(OS_OBJECT_ID_UNDEFINED, NULL), OS_INVALID_POINTER);
 }
 
 void Test_OS_TaskInstallDeleteHandler(void)
@@ -308,7 +313,7 @@ void Test_OS_TaskFindIdBySystemData(void)
 
     int32 expected;
     int32 actual;
-    uint32 task_id;
+    osal_id_t task_id;
 
     /*
      * Use a compound data struct for the system data.
diff --git a/src/unit-test-coverage/shared/src/coveragetest-time.c b/src/unit-test-coverage/shared/src/coveragetest-time.c
index 53521ddeb..11d1a2888 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-time.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-time.c
@@ -34,11 +34,11 @@
 static uint32 UT_TimerCount = 0;
 static uint32 UT_TimerArgCount = 0;
 
-void UT_TimerCallback(uint32 timer_id)
+void UT_TimerCallback(osal_id_t timer_id)
 {
     ++UT_TimerCount;
 }
-void UT_TimerArgCallback(uint32 object_id, void *arg)
+void UT_TimerArgCallback(osal_id_t object_id, void *arg)
 {
     ++UT_TimerArgCount;
 }
@@ -68,43 +68,44 @@ void Test_OS_TimerAdd(void)
      * int32 OS_TimerAdd(uint32 *timer_id, const char *timer_name, uint32 timebase_ref_id, OS_ArgCallback_t  callback_ptr, void *callback_arg)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid = OS_OBJECT_ID_UNDEFINED;
     char arg = 'a';
-    int32 actual = OS_TimerAdd(&objid, "UT", 1, UT_TimerArgCallback, &arg);
+
+    int32 actual = OS_TimerAdd(&objid, "UT", UT_OBJID_1, UT_TimerArgCallback, &arg);
 
     UtAssert_True(actual == expected, "OS_TimerAdd() (%ld) == OS_SUCCESS", (long)actual);
 
     /* test error cases */
     expected = OS_INVALID_POINTER;
-    actual = OS_TimerAdd(NULL, "UT", 1, UT_TimerArgCallback, &arg);
+    actual = OS_TimerAdd(NULL, "UT", UT_OBJID_1, UT_TimerArgCallback, &arg);
     UtAssert_True(actual == expected, "OS_TimerAdd() (%ld) == OS_INVALID_POINTER", (long)actual);
 
     UT_SetForceFail(UT_KEY(OCS_strlen), 2 + OS_MAX_API_NAME);
     expected = OS_ERR_NAME_TOO_LONG;
-    actual = OS_TimerAdd(&objid, "UT", 1, UT_TimerArgCallback, &arg);
+    actual = OS_TimerAdd(&objid, "UT", UT_OBJID_1, UT_TimerArgCallback, &arg);
     UtAssert_True(actual == expected, "OS_TimerAdd() (%ld) == OS_ERR_NAME_TOO_LONG", (long)actual);
     UT_ClearForceFail(UT_KEY(OCS_strlen));
 
     expected = OS_TIMER_ERR_INVALID_ARGS;
-    actual = OS_TimerAdd(&objid, "UT", 1, NULL, &arg);
+    actual = OS_TimerAdd(&objid, "UT", UT_OBJID_1, NULL, &arg);
     UtAssert_True(actual == expected, "OS_TimerAdd() (%ld) == OS_TIMER_ERR_INVALID_ARGS", (long)actual);
 
     UT_SetForceFail(UT_KEY(OS_TaskGetId_Impl), 1 | (OS_OBJECT_TYPE_OS_TIMEBASE << OS_OBJECT_TYPE_SHIFT));
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_TimerAdd(&objid, "UT", 1, UT_TimerArgCallback, &arg);
+    actual = OS_TimerAdd(&objid, "UT", UT_OBJID_1, UT_TimerArgCallback, &arg);
     UtAssert_True(actual == expected, "OS_TimerAdd() (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
     UT_ClearForceFail(UT_KEY(OS_TaskGetId_Impl));
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdGetById), OS_ERROR);
     expected = OS_ERROR;
-    actual = OS_TimerAdd(&objid, "UT", 1, UT_TimerArgCallback, &arg);
+    actual = OS_TimerAdd(&objid, "UT", UT_OBJID_1, UT_TimerArgCallback, &arg);
     UtAssert_True(actual == expected, "OS_TimerAdd() (%ld) == OS_ERROR", (long)actual);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdGetById));
 
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdAllocateNew), OS_ERROR);
     expected = OS_ERROR;
-    actual = OS_TimerAdd(&objid, "UT", 1, UT_TimerArgCallback, &arg);
+    actual = OS_TimerAdd(&objid, "UT", UT_OBJID_1, UT_TimerArgCallback, &arg);
     UtAssert_True(actual == expected, "OS_TimerAdd() (%ld) == OS_ERROR", (long)actual);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdAllocateNew));
 }
@@ -116,13 +117,12 @@ void Test_OS_TimerCreate(void)
      * int32 OS_TimerCreate(uint32 *timer_id, const char *timer_name, uint32 *accuracy, OS_TimerCallback_t  callback_ptr)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid = OS_OBJECT_ID_UNDEFINED;
     uint32 local_id = 0xFFFFFFFF;
     uint32 accuracy = 0xFFFFFFFF;
     int32 actual = OS_TimerCreate(&objid, "UT", &accuracy, UT_TimerCallback);
 
     UtAssert_True(actual == expected, "OS_TimerCreate() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "objid (%lu) != 0", (unsigned long)objid);
 
     OS_ObjectIdToArrayIndex(OS_OBJECT_TYPE_OS_TIMECB, objid, &local_id);
 
@@ -171,27 +171,27 @@ void Test_OS_TimerSet(void)
      * int32 OS_TimerSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
      */
     int32 expected = OS_ERROR;
-    int32 actual = OS_TimerSet(1, 0, 0);
+    int32 actual = OS_TimerSet(UT_OBJID_1, 0, 0);
     UtAssert_True(actual == expected, "OS_TimerSet() (%ld) == OS_ERROR", (long)actual);
 
     expected = OS_SUCCESS;
-    actual = OS_TimerSet(1, 0, 1);
+    actual = OS_TimerSet(UT_OBJID_1, 0, 1);
     UtAssert_True(actual == expected, "OS_TimerSet() (%ld) == OS_SUCCESS", (long)actual);
 
     OS_timecb_table[2].timebase_ref = 0;
     OS_timecb_table[2].flags = TIMECB_FLAG_DEDICATED_TIMEBASE;
-    OS_global_timebase_table[0].active_id = 2;
-    actual = OS_TimerSet(2, 0, 1);
+    OS_global_timebase_table[0].active_id = UT_OBJID_2;
+    actual = OS_TimerSet(UT_OBJID_2, 0, 1);
     UtAssert_True(actual == expected, "OS_TimerSet() (%ld) == OS_SUCCESS", (long)actual);
     memset(OS_timecb_table, 0, sizeof(OS_timecb_table));
 
     expected = OS_TIMER_ERR_INVALID_ARGS;
-    actual = OS_TimerSet(2, UINT32_MAX, UINT32_MAX);
+    actual = OS_TimerSet(UT_OBJID_2, UINT32_MAX, UINT32_MAX);
     UtAssert_True(actual == expected, "OS_TimerSet() (%ld) == OS_TIMER_ERR_INVALID_ARGS", (long)actual);
 
     UT_SetForceFail(UT_KEY(OS_TaskGetId_Impl), 1 | (OS_OBJECT_TYPE_OS_TIMEBASE << OS_OBJECT_TYPE_SHIFT));
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_TimerSet(2, 0, 1);
+    actual = OS_TimerSet(UT_OBJID_2, 0, 1);
     UtAssert_True(actual == expected, "OS_TimerSet() (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
     UT_ClearForceFail(UT_KEY(OS_TaskGetId_Impl));
 }
@@ -204,7 +204,7 @@ void Test_OS_TimerDelete(void)
      * int32 OS_TimerDelete(uint32 timer_id)
      */
     int32 expected = OS_SUCCESS;
-    int32 actual = OS_TimerDelete(1);
+    int32 actual = OS_TimerDelete(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_TimerDelete() (%ld) == OS_SUCCESS", (long)actual);
 
@@ -212,12 +212,12 @@ void Test_OS_TimerDelete(void)
     OS_timecb_table[2].timebase_ref = 0;
     OS_timecb_table[2].next_ref = 1;
     OS_timecb_table[1].next_ref = 1;
-    OS_timebase_table[0].first_cb = 2;
-    actual = OS_TimerDelete(2);
+    OS_timebase_table[0].first_cb = UT_OBJID_2;
+    actual = OS_TimerDelete(UT_OBJID_2);
     UtAssert_True(actual == expected, "OS_TimerDelete() (%ld) == OS_SUCCESS", (long)actual);
 
-    OS_timebase_table[0].first_cb = 1;
-    actual = OS_TimerDelete(1);
+    OS_timebase_table[0].first_cb = UT_OBJID_1;
+    actual = OS_TimerDelete(UT_OBJID_1);
     UtAssert_True(actual == expected, "OS_TimerDelete() (%ld) == OS_SUCCESS", (long)actual);
 
     /* verify deletion of the dedicated timebase objects
@@ -225,7 +225,7 @@ void Test_OS_TimerDelete(void)
     OS_TimeBaseCreate(&OS_global_timebase_table[0].active_id,"ut",NULL);
     OS_timecb_table[1].flags = TIMECB_FLAG_DEDICATED_TIMEBASE;
     OS_timecb_table[1].timebase_ref = 0;
-    actual = OS_TimerDelete(1);
+    actual = OS_TimerDelete(UT_OBJID_1);
     UtAssert_True(actual == expected, "OS_TimerDelete() (%ld) == OS_SUCCESS", (long)actual);
     UtAssert_True(UT_GetStubCount(UT_KEY(OS_TimeBaseDelete)) == 1, "OS_TimerDelete() invoked OS_TimeBaseDelete()");
 
@@ -234,7 +234,7 @@ void Test_OS_TimerDelete(void)
 
     UT_SetForceFail(UT_KEY(OS_TaskGetId_Impl), 1 | (OS_OBJECT_TYPE_OS_TIMEBASE << OS_OBJECT_TYPE_SHIFT));
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_TimerDelete(2);
+    actual = OS_TimerDelete(UT_OBJID_2);
     UtAssert_True(actual == expected, "OS_TimerDelete() (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
     UT_ClearForceFail(UT_KEY(OS_TaskGetId_Impl));
 
@@ -249,12 +249,11 @@ void Test_OS_TimerGetIdByName(void)
      */
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
-    uint32 objid = 0;
+    osal_id_t objid;
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdFindByName), OS_SUCCESS);
     actual = OS_TimerGetIdByName(&objid, "UT");
     UtAssert_True(actual == expected, "OS_TimerGetIdByName() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "OS_TimerGetIdByName() objid (%lu) != 0", (unsigned long)objid);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdFindByName));
 
     expected = OS_ERR_NAME_NOT_FOUND;
@@ -291,14 +290,14 @@ void Test_OS_TimerGetInfo(void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 111;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     OS_timecb_table[1].interval_time = 2222;
     OS_timecb_table[1].timebase_ref = 0;
     OS_timebase_table[0].accuracy_usec = 3333;
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_TimerGetInfo(1, &timer_prop);
+    actual = OS_TimerGetInfo(UT_OBJID_1, &timer_prop);
 
     UtAssert_True(actual == expected, "OS_TimerGetInfo() (%ld) == OS_SUCCESS", (long)actual);
     UtAssert_True(strcmp(timer_prop.name, "ABC") == 0, "timer_prop.name (%s) == ABC",
@@ -311,12 +310,12 @@ void Test_OS_TimerGetInfo(void)
             (unsigned long)timer_prop.accuracy);
 
     expected = OS_INVALID_POINTER;
-    actual = OS_TimerGetInfo(1, NULL);
+    actual = OS_TimerGetInfo(UT_OBJID_1, NULL);
     UtAssert_True(actual == expected, "OS_TimerGetInfo() (%ld) == OS_INVALID_POINTER", (long)actual);
 
     UT_SetForceFail(UT_KEY(OS_TaskGetId_Impl), 1 | (OS_OBJECT_TYPE_OS_TIMEBASE << OS_OBJECT_TYPE_SHIFT));
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_TimerGetInfo(1, &timer_prop);
+    actual = OS_TimerGetInfo(UT_OBJID_1, &timer_prop);
     UtAssert_True(actual == expected, "OS_TimerGetInfo() (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
     UT_ClearForceFail(UT_KEY(OS_TaskGetId_Impl));
 
diff --git a/src/unit-test-coverage/shared/src/coveragetest-timebase.c b/src/unit-test-coverage/shared/src/coveragetest-timebase.c
index 511475f30..3d4213897 100644
--- a/src/unit-test-coverage/shared/src/coveragetest-timebase.c
+++ b/src/unit-test-coverage/shared/src/coveragetest-timebase.c
@@ -54,7 +54,7 @@ static int32 ClearObjectsHook(void *UserObj, int32 StubRetcode, uint32 CallCount
     return StubRetcode;
 }
 
-static void UT_TimeCB(uint32 object_id, void *arg)
+static void UT_TimeCB(osal_id_t object_id, void *arg)
 {
     ++TimeCB;
 }
@@ -84,7 +84,7 @@ void Test_OS_TimeBaseCreate(void)
      * int32 OS_TimeBaseCreate(uint32 *timer_id, const char *timebase_name, OS_TimerSync_t external_sync)
      */
     int32 expected = OS_SUCCESS;
-    uint32 objid = 0xFFFFFFFF;
+    osal_id_t objid;
     int32 actual;
 
     actual = OS_TimeBaseCreate(&objid, "UT1", UT_TimerSync);
@@ -117,19 +117,19 @@ void Test_OS_TimeBaseSet(void)
      * int32 OS_TimeBaseSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
      */
     int32 expected = OS_SUCCESS;
-    int32 actual = OS_TimeBaseSet(1, 1000, 1000);
+    int32 actual = OS_TimeBaseSet(UT_OBJID_1, 1000, 1000);
 
     UtAssert_True(actual == expected, "OS_TimeBaseSet() (%ld) == OS_SUCCESS", (long)actual);
 
     /* test error paths: overflow on input */
     expected = OS_TIMER_ERR_INVALID_ARGS;
-    actual = OS_TimeBaseSet(1, UINT32_MAX, UINT32_MAX);
+    actual = OS_TimeBaseSet(UT_OBJID_1, UINT32_MAX, UINT32_MAX);
     UtAssert_True(actual == expected, "OS_TimeBaseSet() (%ld) == OS_TIMER_ERR_INVALID_ARGS", (long)actual);
 
     /* test error paths */
     UT_SetForceFail(UT_KEY(OS_TaskGetId_Impl), 1 | (OS_OBJECT_TYPE_OS_TIMEBASE << OS_OBJECT_TYPE_SHIFT));
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_TimeBaseSet(1, 1000, 1000);
+    actual = OS_TimeBaseSet(UT_OBJID_1, 1000, 1000);
     UtAssert_True(actual == expected, "OS_TimeBaseSet() (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
 
 }
@@ -141,14 +141,14 @@ void Test_OS_TimeBaseDelete(void)
      * int32 OS_TimeBaseDelete(uint32 timer_id)
      */
     int32 expected = OS_SUCCESS;
-    int32 actual = OS_TimeBaseDelete(1);
+    int32 actual = OS_TimeBaseDelete(UT_OBJID_1);
 
     UtAssert_True(actual == expected, "OS_TimeBaseDelete() (%ld) == OS_SUCCESS", (long)actual);
 
     /* test error paths */
     UT_SetForceFail(UT_KEY(OS_TaskGetId_Impl), 1 | (OS_OBJECT_TYPE_OS_TIMEBASE << OS_OBJECT_TYPE_SHIFT));
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_TimeBaseDelete(1);
+    actual = OS_TimeBaseDelete(UT_OBJID_1);
     UtAssert_True(actual == expected, "OS_TimeBaseDelete() (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
 }
 
@@ -160,12 +160,12 @@ void Test_OS_TimeBaseGetIdByName(void)
      */
     int32 expected = OS_SUCCESS;
     int32 actual = ~OS_SUCCESS;
-    uint32 objid = 0;
+    osal_id_t objid;
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdFindByName), OS_SUCCESS);
     actual = OS_TimeBaseGetIdByName(&objid, "UT");
     UtAssert_True(actual == expected, "OS_TimeBaseGetIdByName() (%ld) == OS_SUCCESS", (long)actual);
-    UtAssert_True(objid != 0, "OS_TimeBaseGetIdByName() objid (%lu) != 0", (unsigned long)objid);
+    OSAPI_TEST_OBJID(objid,!=,OS_OBJECT_ID_UNDEFINED);
     UT_ClearForceFail(UT_KEY(OS_ObjectIdFindByName));
 
     expected = OS_ERR_NAME_NOT_FOUND;
@@ -199,19 +199,18 @@ void Test_OS_TimeBaseGetInfo(void)
     OS_common_record_t *rptr = &utrec;
 
     memset(&utrec, 0, sizeof(utrec));
-    utrec.creator = 1111;
+    utrec.creator = UT_OBJID_OTHER;
     utrec.name_entry = "ABC";
     OS_timebase_table[1].nominal_interval_time = 2222;
     OS_timebase_table[1].freerun_time = 3333;
     OS_timebase_table[1].accuracy_usec = 4444;
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &local_index, sizeof(local_index), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById), &rptr, sizeof(rptr), false);
-    actual = OS_TimeBaseGetInfo(1, &timebase_prop);
+    actual = OS_TimeBaseGetInfo(UT_OBJID_1, &timebase_prop);
 
     UtAssert_True(actual == expected, "OS_TimeBaseGetInfo() (%ld) == OS_SUCCESS", (long)actual);
 
-    UtAssert_True(timebase_prop.creator == 1111, "timebase_prop.creator (%lu) == 1111",
-            (unsigned long)timebase_prop.creator);
+    OSAPI_TEST_OBJID(timebase_prop.creator,==,UT_OBJID_OTHER);
     UtAssert_True(strcmp(timebase_prop.name, "ABC") == 0, "timebase_prop.name (%s) == ABC",
             timebase_prop.name);
     UtAssert_True(timebase_prop.nominal_interval_time == 2222,
@@ -226,12 +225,12 @@ void Test_OS_TimeBaseGetInfo(void)
 
     /* test error paths */
     expected = OS_INVALID_POINTER;
-    actual = OS_TimeBaseGetInfo(1, NULL);
+    actual = OS_TimeBaseGetInfo(UT_OBJID_1, NULL);
     UtAssert_True(actual == expected, "OS_TimeBaseGetInfo() (%ld) == OS_INVALID_POINTER", (long)actual);
 
     UT_SetForceFail(UT_KEY(OS_TaskGetId_Impl), 1 | (OS_OBJECT_TYPE_OS_TIMEBASE << OS_OBJECT_TYPE_SHIFT));
     expected = OS_ERR_INCORRECT_OBJ_STATE;
-    actual = OS_TimeBaseGetInfo(1, &timebase_prop);
+    actual = OS_TimeBaseGetInfo(UT_OBJID_1, &timebase_prop);
     UtAssert_True(actual == expected, "OS_TimeBaseGetInfo() (%ld) == OS_ERR_INCORRECT_OBJ_STATE", (long)actual);
 
 }
@@ -244,7 +243,7 @@ void Test_OS_TimeBaseGetFreeRun(void)
      */
     int32 expected = OS_SUCCESS;
     uint32 freerun = 0xFFFFFFFF;
-    int32 actual = OS_TimeBaseGetFreeRun(1, &freerun);
+    int32 actual = OS_TimeBaseGetFreeRun(UT_OBJID_1, &freerun);
 
     UtAssert_True(actual == expected, "OS_TimeBaseGetFreeRun() (%ld) == OS_SUCCESS", (long)actual);
 }
@@ -257,10 +256,10 @@ void Test_OS_TimeBase_CallbackThread(void)
      */
     OS_common_record_t fake_record;
     OS_common_record_t *recptr = &fake_record;
-    uint32 idbuf;
+    osal_id_t idbuf;
 
     memset(&fake_record, 0, sizeof(fake_record));
-    fake_record.active_id = 2;
+    fake_record.active_id = UT_OBJID_2;
 
     OS_timebase_table[2].external_sync = UT_TimerSync;
     OS_timecb_table[0].wait_time = 2000;
@@ -268,30 +267,30 @@ void Test_OS_TimeBase_CallbackThread(void)
     TimerSyncCount = 0;
     TimerSyncRetVal = 0;
     TimeCB = 0;
-    idbuf = 2;
+    idbuf = UT_OBJID_2;
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById),&idbuf, sizeof(idbuf), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById),&recptr, sizeof(recptr), false);
     UT_SetHookFunction(UT_KEY(OS_TimeBaseLock_Impl), ClearObjectsHook, recptr);
-    OS_TimeBase_CallbackThread(2);
+    OS_TimeBase_CallbackThread(UT_OBJID_2);
 
     UtAssert_True(TimerSyncCount == 11, "TimerSyncCount (%lu) == 11", (unsigned long)TimerSyncCount);
 
     UT_ResetState(UT_KEY(OS_TimeBaseLock_Impl));
     TimerSyncCount = 0;
     TimerSyncRetVal = 1000;
-    fake_record.active_id = 2;
-    idbuf = 2;
+    fake_record.active_id = UT_OBJID_2;
+    idbuf = UT_OBJID_2;
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById),&idbuf, sizeof(idbuf), false);
     UT_SetDataBuffer(UT_KEY(OS_ObjectIdGetById),&recptr, sizeof(recptr), false);
     UT_SetHookFunction(UT_KEY(OS_TimeBaseLock_Impl), ClearObjectsHook, recptr);
-    OS_TimeBase_CallbackThread(2);
+    OS_TimeBase_CallbackThread(UT_OBJID_2);
 
     /* Check that the TimeCB function was called */
     UtAssert_True(TimeCB > 0, "TimeCB (%lu) > 0", (unsigned long)TimeCB);
 
 
     UT_SetForceFail(UT_KEY(OS_ObjectIdGetById), OS_ERROR);
-    OS_TimeBase_CallbackThread(2);
+    OS_TimeBase_CallbackThread(UT_OBJID_2);
 }
 
 void Test_OS_Tick2Micros(void)
diff --git a/src/unit-test-coverage/shared/src/os-shared-coveragetest.h b/src/unit-test-coverage/shared/src/os-shared-coveragetest.h
index 2c0d9733c..f847cdd46 100644
--- a/src/unit-test-coverage/shared/src/os-shared-coveragetest.h
+++ b/src/unit-test-coverage/shared/src/os-shared-coveragetest.h
@@ -46,11 +46,37 @@
         #func, (long)rcact, #exp, (long)rcexp);             \
 }
 
+/*
+ * A union type allowing the osal_id_t to be manipulated as a uint32.
+ * Normally application code would NOT do this, but coverage test can
+ * because it has inside knowledge of the ID value structure.
+ */
+typedef union
+{
+    osal_id_t id;
+    uint32    val;
+} UT_idbuf_t;
+
+#define OSAPI_TEST_OBJID(act,op,exp)        \
+{                                           \
+    UT_idbuf_t idexp = { .id = exp };       \
+    UT_idbuf_t idact = { .id = act };       \
+    UtAssert_True(memcmp(&idexp,&idact,sizeof(osal_id_t)) op 0,    \
+        "%s (%lu) %s %s (%lu)",                 \
+        #act, (unsigned long)idact.val, #op,    \
+        #exp, (unsigned long)idexp.val);        \
+}
+
 /*
  * Macro to add a test case to the list of tests to execute
  */
 #define ADD_TEST(test) UtTest_Add((Test_ ## test),Osapi_Test_Setup,Osapi_Test_Teardown, #test)
 
+#define UT_OBJID_1      ((osal_id_t){1})
+#define UT_OBJID_2      ((osal_id_t){2})
+#define UT_OBJID_OTHER  ((osal_id_t){0x12345})
+#define UT_OBJID_MAX    ((osal_id_t){0xFFFFFFFF})
+
 /*
  * Setup function prior to every test
  */
diff --git a/src/unit-test-coverage/ut-stubs/src/osapi-task-impl-stubs.c b/src/unit-test-coverage/ut-stubs/src/osapi-task-impl-stubs.c
index bdf5e1df4..cb163c702 100644
--- a/src/unit-test-coverage/ut-stubs/src/osapi-task-impl-stubs.c
+++ b/src/unit-test-coverage/ut-stubs/src/osapi-task-impl-stubs.c
@@ -48,12 +48,21 @@ void OS_TaskExit_Impl               (void)
 
 UT_DEFAULT_STUB(OS_TaskDelay_Impl,(uint32 millisecond))
 UT_DEFAULT_STUB(OS_TaskSetPriority_Impl,(uint32 task_id, uint32 new_priority))
-uint32 OS_TaskGetId_Impl            (void)
+osal_id_t OS_TaskGetId_Impl            (void)
 {
-    return UT_DEFAULT_IMPL(OS_TaskGetId_Impl);
+    int32 status;
+    osal_id_t id;
+
+    status = UT_DEFAULT_IMPL(OS_TaskGetId_Impl);
+
+    /* convert the int32 status value to an osal_id_t -
+     * (this assumes the types are compatible) */
+    id = OS_ObjectIdFromInteger(status);
+
+    return id;
 }
 UT_DEFAULT_STUB(OS_TaskGetInfo_Impl,(uint32 task_id, OS_task_prop_t *task_prop))
-UT_DEFAULT_STUB(OS_TaskRegister_Impl,(uint32 global_task_id))
+UT_DEFAULT_STUB(OS_TaskRegister_Impl,(osal_id_t global_task_id))
 
 bool OS_TaskIdMatchSystemData_Impl(void *ref, uint32 local_id, const OS_common_record_t *obj)
 {
diff --git a/src/unit-test-coverage/vxworks/src/coveragetest-shell.c b/src/unit-test-coverage/vxworks/src/coveragetest-shell.c
index 1a1a42acf..2824a8981 100644
--- a/src/unit-test-coverage/vxworks/src/coveragetest-shell.c
+++ b/src/unit-test-coverage/vxworks/src/coveragetest-shell.c
@@ -53,7 +53,7 @@ void Test_OS_ShellOutputToFile_Impl(void)
     UtAssert_True(UT_GetStubCount(UT_KEY(OCS_shellGenericInit)) == 1, "shellGenericInit() called");
 
     /* failure to open the output file */
-    UT_SetForceFail(UT_KEY(OS_creat), OS_ERROR);
+    UT_SetForceFail(UT_KEY(OS_OpenCreate), OS_ERROR);
     expected = OS_ERROR;
     actual = OS_ShellOutputToFile_Impl(0, "TestCmd");
     UtAssert_True(actual == expected, "OS_ShellOutputToFile_Impl() (%ld) == OS_ERROR", (long)actual);
diff --git a/src/unit-test-coverage/vxworks/src/coveragetest-tasks.c b/src/unit-test-coverage/vxworks/src/coveragetest-tasks.c
index 1d12e7e78..cd5e67a5e 100644
--- a/src/unit-test-coverage/vxworks/src/coveragetest-tasks.c
+++ b/src/unit-test-coverage/vxworks/src/coveragetest-tasks.c
@@ -167,7 +167,7 @@ void Test_OS_TaskRegister_Impl(void)
      * Test Case For:
      * int32 OS_TaskRegister_Impl(uint32 global_task_id)
      */
-    OSAPI_TEST_FUNCTION_RC(OS_TaskRegister_Impl(0), OS_SUCCESS);
+    OSAPI_TEST_FUNCTION_RC(OS_TaskRegister_Impl(OS_OBJECT_ID_UNDEFINED), OS_SUCCESS);
 }
 
 void Test_OS_TaskGetId_Impl(void)
@@ -177,11 +177,15 @@ void Test_OS_TaskGetId_Impl(void)
      * uint32 OS_TaskGetId_Impl (void)
      */
     OCS_WIND_TCB *TaskTcb;
+    osal_id_t id1;
+    osal_id_t id2;
 
-    OS_global_task_table[1].active_id = 0x12345;
+    memset(&id1, 0x11, sizeof(osal_id_t));
+    OS_global_task_table[1].active_id = id1;
     TaskTcb = UT_TaskTest_GetTaskTcb(1);
     UT_SetDataBuffer(UT_KEY(OCS_taskTcb), &TaskTcb, sizeof(TaskTcb), false);
-    OSAPI_TEST_FUNCTION_RC(OS_TaskGetId_Impl(), 0x12345);
+    id2 = OS_TaskGetId_Impl();
+    UtAssert_MemCmp(&id1, &id2, sizeof(osal_id_t), "OS_TaskGetId_Impl()");
 }
 
 void Test_OS_TaskGetInfo_Impl(void)
diff --git a/src/unit-test-coverage/vxworks/src/coveragetest-timebase.c b/src/unit-test-coverage/vxworks/src/coveragetest-timebase.c
index 1f77cef7e..c84c092f5 100644
--- a/src/unit-test-coverage/vxworks/src/coveragetest-timebase.c
+++ b/src/unit-test-coverage/vxworks/src/coveragetest-timebase.c
@@ -101,6 +101,7 @@ void Test_OS_TimeBaseCreate_Impl(void)
     /* Test Case For:
      * int32 OS_TimeBaseCreate_Impl(uint32 timer_id)
      */
+    osal_id_t id;
 
     /*
      * Test paths though the signal number assignment.
@@ -108,7 +109,8 @@ void Test_OS_TimeBaseCreate_Impl(void)
      * This should be done first as it will assign the "external_sync"
      * and therefore cause future calls to skip this block.
      */
-    OS_global_timebase_table[1].active_id = 0x1;
+    memset(&id, 0x01, sizeof(id));
+    OS_global_timebase_table[1].active_id = id;
     UT_TimeBaseTest_Setup(1,OCS_SIGRTMIN, false);
     UT_SetForceFail(UT_KEY(OCS_sigismember), true);
     OSAPI_TEST_FUNCTION_RC(OS_TimeBaseCreate_Impl(0), OS_TIMER_ERR_UNAVAILABLE);
@@ -165,8 +167,10 @@ void Test_OS_VxWorks_SigWait(void)
      */
     int signo = OCS_SIGRTMIN;
     struct OCS_itimerspec config_value;
+    osal_id_t id;
 
-    OS_global_timebase_table[0].active_id = 0x12345;
+    memset(&id, 0x02, sizeof(id));
+    OS_global_timebase_table[0].active_id = id;
     OS_timebase_table[0].nominal_start_time = 8888;
     OS_timebase_table[0].nominal_interval_time = 5555;
 
@@ -184,7 +188,7 @@ void Test_OS_VxWorks_SigWait(void)
     OSAPI_TEST_FUNCTION_RC(UT_TimeBaseTest_CallSigWaitFunc(0), 2222222);
 
     UT_TimeBaseTest_Setup(0, 0, false);
-    OS_global_timebase_table[0].active_id = 0;
+    OS_global_timebase_table[0].active_id = OS_OBJECT_ID_UNDEFINED;
     OS_timebase_table[0].nominal_interval_time = 0;
 }
 
diff --git a/src/unit-tests/inc/ut_os_support.h b/src/unit-tests/inc/ut_os_support.h
index 10c41f569..74419a51a 100644
--- a/src/unit-tests/inc/ut_os_support.h
+++ b/src/unit-tests/inc/ut_os_support.h
@@ -106,6 +106,15 @@ static inline bool UtOsalImplemented(int32 Fn, const char *File, uint32 Line)
 #define UT_OS_LOG(...)    \
     UtAssert_Message(UTASSERT_CASETYPE_INFO,__FILE__,__LINE__,__VA_ARGS__);
 
+
+/*
+ * An osal_id_t value which is not OS_OBJECT_ID_UNDEFINED and also
+ * not aliasing any other valid value/type.
+ *
+ * This is used to test for proper rejection of bad ID values.
+ */
+#define UT_OBJID_INCORRECT    ((osal_id_t){0xDEADBEEF})
+
 /*--------------------------------------------------------------------------------*
 ** Data types
 **--------------------------------------------------------------------------------*/
diff --git a/src/unit-tests/oscore-test/ut_oscore_binsem_test.c b/src/unit-tests/oscore-test/ut_oscore_binsem_test.c
index 34ef7d543..fca480e1f 100644
--- a/src/unit-tests/oscore-test/ut_oscore_binsem_test.c
+++ b/src/unit-tests/oscore-test/ut_oscore_binsem_test.c
@@ -70,7 +70,7 @@ void UT_os_bin_sem_create_test()
     int i;
     char  sem_name[UT_OS_NAME_BUFF_SIZE];
     char  long_sem_name[UT_OS_NAME_BUFF_SIZE];
-    uint32  sem_ids[OS_MAX_BIN_SEMAPHORES+1];
+    osal_id_t  sem_ids[OS_MAX_BIN_SEMAPHORES+1];
 
     /*-----------------------------------------------------*/
     if (!UT_IMPL(OS_BinSemCreate(&sem_ids[0], "Good", 1, 0))) return;
@@ -134,13 +134,13 @@ void UT_os_bin_sem_create_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_bin_sem_delete_test()
 {
-    uint32  bin_sem_id;
+    osal_id_t  bin_sem_id;
 
     /*-----------------------------------------------------*/
-    if (!UT_IMPL(OS_BinSemDelete(0))) return;
+    if (!UT_IMPL(OS_BinSemDelete(OS_OBJECT_ID_UNDEFINED))) return;
 
     /*-----------------------------------------------------*/
-    UT_RETVAL(OS_BinSemDelete(99999), OS_ERR_INVALID_ID, "invalid id arg");
+    UT_RETVAL(OS_BinSemDelete(UT_OBJID_INCORRECT), OS_ERR_INVALID_ID, "invalid id arg");
 
     /*-----------------------------------------------------*/
     if(UT_SETUP(OS_BinSemCreate(&bin_sem_id, "DeleteTest", 1, 0)))
@@ -160,13 +160,13 @@ void UT_os_bin_sem_delete_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_bin_sem_flush_test()
 {
-    uint32  bin_sem_id;
+    osal_id_t  bin_sem_id;
 
     /*-----------------------------------------------------*/
-    if (!UT_IMPL(OS_BinSemFlush(0))) return;
+    if (!UT_IMPL(OS_BinSemFlush(OS_OBJECT_ID_UNDEFINED))) return;
 
     /*-----------------------------------------------------*/
-    UT_RETVAL(OS_BinSemFlush(99999), OS_ERR_INVALID_ID, "invalid id arg");
+    UT_RETVAL(OS_BinSemFlush(UT_OBJID_INCORRECT), OS_ERR_INVALID_ID, "invalid id arg");
 
     /*----------------------------------------------------*/
     if(UT_SETUP(OS_BinSemCreate(&bin_sem_id, "FlushTest", 1, 0)))
@@ -187,13 +187,13 @@ void UT_os_bin_sem_flush_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_bin_sem_give_test()
 {
-    uint32  bin_sem_id;
+    osal_id_t  bin_sem_id;
 
     /*-----------------------------------------------------*/
-    if (!UT_IMPL(OS_BinSemGive(0))) return;
+    if (!UT_IMPL(OS_BinSemGive(OS_OBJECT_ID_UNDEFINED))) return;
 
     /*-----------------------------------------------------*/
-    UT_RETVAL(OS_BinSemGive(99999), OS_ERR_INVALID_ID, "invalid id arg");
+    UT_RETVAL(OS_BinSemGive(UT_OBJID_INCORRECT), OS_ERR_INVALID_ID, "invalid id arg");
 
     /*-----------------------------------------------------*/
     if (UT_SETUP(OS_BinSemCreate(&bin_sem_id, "GiveTest", 1, 0)))
@@ -215,13 +215,13 @@ void UT_os_bin_sem_give_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_bin_sem_take_test()
 {
-    uint32  bin_sem_id;
+    osal_id_t  bin_sem_id;
 
     /*-----------------------------------------------------*/
-    if (!UT_IMPL(OS_BinSemTake(0))) return;
+    if (!UT_IMPL(OS_BinSemTake(OS_OBJECT_ID_UNDEFINED))) return;
 
     /*-----------------------------------------------------*/
-    UT_RETVAL(OS_BinSemTake(99999), OS_ERR_INVALID_ID, "invalid id arg");
+    UT_RETVAL(OS_BinSemTake(UT_OBJID_INCORRECT), OS_ERR_INVALID_ID, "invalid id arg");
 
     /*-----------------------------------------------------*/
     if (UT_SETUP(OS_BinSemCreate(&bin_sem_id, "TakeTest", 1, 0)))
@@ -242,13 +242,13 @@ void UT_os_bin_sem_take_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_bin_sem_timed_wait_test()
 {
-    uint32  bin_sem_id;
+    osal_id_t  bin_sem_id;
 
     /*-----------------------------------------------------*/
-    if (!UT_IMPL(OS_BinSemTimedWait(0, 1000))) return;
+    if (!UT_IMPL(OS_BinSemTimedWait(OS_OBJECT_ID_UNDEFINED, 1000))) return;
 
     /*-----------------------------------------------------*/
-    UT_RETVAL(OS_BinSemTimedWait(99999, 1000), OS_ERR_INVALID_ID, "invalid id arg");
+    UT_RETVAL(OS_BinSemTimedWait(UT_OBJID_INCORRECT, 1000), OS_ERR_INVALID_ID, "invalid id arg");
 
     /*-----------------------------------------------------*/
     if(UT_SETUP(OS_BinSemCreate(&bin_sem_id, "TimedWait", 1, 0))
@@ -278,7 +278,7 @@ void UT_os_bin_sem_timed_wait_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_bin_sem_get_id_by_name_test()
 {
-    uint32  bin_sem_id;
+    osal_id_t  bin_sem_id;
     char long_sem_name[UT_OS_NAME_BUFF_SIZE];
 
     /*-----------------------------------------------------*/
@@ -317,14 +317,14 @@ void UT_os_bin_sem_get_id_by_name_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_bin_sem_get_info_test()
 {
-    uint32             bin_sem_id;
+    osal_id_t          bin_sem_id;
     OS_bin_sem_prop_t  bin_sem_prop;
 
     /*-----------------------------------------------------*/
-    if (!UT_IMPL(OS_BinSemGetInfo(0, &bin_sem_prop))) return;
+    if (!UT_IMPL(OS_BinSemGetInfo(OS_OBJECT_ID_UNDEFINED, &bin_sem_prop))) return;
 
     /*-----------------------------------------------------*/
-    UT_RETVAL(OS_BinSemGetInfo(99999, &bin_sem_prop), OS_ERR_INVALID_ID, "invalid id");
+    UT_RETVAL(OS_BinSemGetInfo(UT_OBJID_INCORRECT, &bin_sem_prop), OS_ERR_INVALID_ID, "invalid id");
 
     /*-----------------------------------------------------*/
     if(UT_SETUP(OS_BinSemCreate(&bin_sem_id, "GetInfo", 1, 0)))
diff --git a/src/unit-tests/oscore-test/ut_oscore_countsem_test.c b/src/unit-tests/oscore-test/ut_oscore_countsem_test.c
index 69aede1b9..706c7b8d1 100644
--- a/src/unit-tests/oscore-test/ut_oscore_countsem_test.c
+++ b/src/unit-tests/oscore-test/ut_oscore_countsem_test.c
@@ -70,7 +70,7 @@ void UT_os_count_sem_create_test()
     int            i;
     int32          res = 0;
     const char*    testDesc;
-    uint32         count_sem_ids[OS_MAX_COUNT_SEMAPHORES+1];
+    osal_id_t      count_sem_ids[OS_MAX_COUNT_SEMAPHORES+1];
     char           sem_name[UT_OS_NAME_BUFF_SIZE];
     char           long_sem_name[UT_OS_NAME_BUFF_SIZE];
     uint32         test_setup_invalid = 0;
@@ -222,12 +222,12 @@ void UT_os_count_sem_delete_test()
 {
     int32          res = 0;
     const char*    testDesc;
-    uint32         count_sem_id;
+    osal_id_t      count_sem_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_CountSemDelete(0);
+    res = OS_CountSemDelete(OS_OBJECT_ID_UNDEFINED);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -237,7 +237,7 @@ void UT_os_count_sem_delete_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_CountSemDelete(99999);
+    res = OS_CountSemDelete(UT_OBJID_INCORRECT);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -285,12 +285,12 @@ void UT_os_count_sem_give_test()
 {
     int32          res = 0;
     const char*    testDesc;
-    uint32         count_sem_id;
+    osal_id_t      count_sem_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_CountSemGive(0);
+    res = OS_CountSemGive(OS_OBJECT_ID_UNDEFINED);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -300,7 +300,7 @@ void UT_os_count_sem_give_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_CountSemGive(99999);
+    res = OS_CountSemGive(UT_OBJID_INCORRECT);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -350,12 +350,12 @@ void UT_os_count_sem_take_test()
 {
     int32          res = 0;
     const char*    testDesc;
-    uint32         count_sem_id;
+    osal_id_t      count_sem_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_CountSemTake(0);
+    res = OS_CountSemTake(OS_OBJECT_ID_UNDEFINED);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -365,7 +365,7 @@ void UT_os_count_sem_take_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_CountSemTake(99999);
+    res = OS_CountSemTake(UT_OBJID_INCORRECT);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -414,12 +414,12 @@ void UT_os_count_sem_timed_wait_test()
 {
     int32          res = 0;
     const char*    testDesc;
-    uint32         count_sem_id;
+    osal_id_t      count_sem_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_CountSemTimedWait(0,1000);
+    res = OS_CountSemTimedWait(OS_OBJECT_ID_UNDEFINED,1000);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -429,7 +429,7 @@ void UT_os_count_sem_timed_wait_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_CountSemTimedWait(99999, 1000);
+    res = OS_CountSemTimedWait(UT_OBJID_INCORRECT, 1000);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -509,7 +509,7 @@ void UT_os_count_sem_get_id_by_name_test()
 {
     int32          res = 0;
     const char*    testDesc;
-    uint32         count_sem_id;
+    osal_id_t      count_sem_id;
     char           long_sem_name[UT_OS_NAME_BUFF_SIZE];
 
     /*-----------------------------------------------------*/
@@ -598,13 +598,13 @@ void UT_os_count_sem_get_info_test()
 {
     int32              res = 0;
     const char*        testDesc;
-    uint32             count_sem_id;
+    osal_id_t          count_sem_id;
     OS_count_sem_prop_t  count_sem_prop;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_CountSemGetInfo(0,&count_sem_prop);
+    res = OS_CountSemGetInfo(OS_OBJECT_ID_UNDEFINED,&count_sem_prop);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -614,7 +614,7 @@ void UT_os_count_sem_get_info_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_CountSemGetInfo(99999, &count_sem_prop);
+    res = OS_CountSemGetInfo(UT_OBJID_INCORRECT, &count_sem_prop);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
diff --git a/src/unit-tests/oscore-test/ut_oscore_misc_test.c b/src/unit-tests/oscore-test/ut_oscore_misc_test.c
index f9fc73382..2b9f720ee 100644
--- a/src/unit-tests/oscore-test/ut_oscore_misc_test.c
+++ b/src/unit-tests/oscore-test/ut_oscore_misc_test.c
@@ -90,8 +90,10 @@ void UT_os_apiinit_test()
 {
     int32 res = 0;
     const char* testDesc;
-    uint32 qId = 0, qDepth = 10, qSize = 4, qFlags = 0;
-    uint32 semIds[3], semInitValue = 1, semOptions = 0;
+    osal_id_t qId;
+    uint32 qDepth = 10, qSize = 4, qFlags = 0;
+    osal_id_t semIds[3];
+    uint32 semInitValue = 1, semOptions = 0;
 
     /*-----------------------------------------------------*/
     testDesc = "#1 Init-not-call-first";
diff --git a/src/unit-tests/oscore-test/ut_oscore_mutex_test.c b/src/unit-tests/oscore-test/ut_oscore_mutex_test.c
index 3037309e0..23ebeeb9d 100644
--- a/src/unit-tests/oscore-test/ut_oscore_mutex_test.c
+++ b/src/unit-tests/oscore-test/ut_oscore_mutex_test.c
@@ -70,8 +70,8 @@ void UT_os_mut_sem_create_test()
     int i;
     int32 res = 0;
     const char* testDesc;
-    uint32  mut_sem_id;
-    uint32  mut_sem_id2;
+    osal_id_t  mut_sem_id;
+    osal_id_t  mut_sem_id2;
     char    sem_name[UT_OS_NAME_BUFF_SIZE];
     char    long_sem_name[UT_OS_NAME_BUFF_SIZE];
     uint32  test_setup_invalid = 0;
@@ -205,12 +205,12 @@ void UT_os_mut_sem_delete_test()
 {
     int32 res = 0;
     const char* testDesc;
-    uint32  mut_sem_id;
+    osal_id_t  mut_sem_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_MutSemDelete(0);
+    res = OS_MutSemDelete(OS_OBJECT_ID_UNDEFINED);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -220,7 +220,7 @@ void UT_os_mut_sem_delete_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_MutSemDelete(99999);
+    res = OS_MutSemDelete(UT_OBJID_INCORRECT);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -268,12 +268,12 @@ void UT_os_mut_sem_give_test()
 {
     int32 res = 0;
     const char* testDesc;
-    uint32  mut_sem_id;
+    osal_id_t  mut_sem_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_MutSemGive(0);
+    res = OS_MutSemGive(OS_OBJECT_ID_UNDEFINED);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -283,7 +283,7 @@ void UT_os_mut_sem_give_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_MutSemGive(99999);
+    res = OS_MutSemGive(UT_OBJID_INCORRECT);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -342,12 +342,12 @@ void UT_os_mut_sem_take_test()
 {
     int32 res = 0;
     const char* testDesc;
-    uint32  mut_sem_id;
+    osal_id_t  mut_sem_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_MutSemTake(0);
+    res = OS_MutSemTake(OS_OBJECT_ID_UNDEFINED);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -357,7 +357,7 @@ void UT_os_mut_sem_take_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_MutSemTake(99999);
+    res = OS_MutSemTake(UT_OBJID_INCORRECT);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -408,7 +408,7 @@ void UT_os_mut_sem_get_id_by_name_test()
 {
     int32 res = 0;
     const char* testDesc;
-    uint32  mut_sem_id;
+    osal_id_t  mut_sem_id;
     char        long_sem_name[UT_OS_NAME_BUFF_SIZE];
 
     /*-----------------------------------------------------*/
@@ -496,13 +496,13 @@ void UT_os_mut_sem_get_info_test()
 {
     int32              res = 0;
     const char*        testDesc;
-    uint32             mut_sem_id;
+    osal_id_t             mut_sem_id;
     OS_mut_sem_prop_t  mut_sem_prop;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_MutSemGetInfo(0, &mut_sem_prop);
+    res = OS_MutSemGetInfo(OS_OBJECT_ID_UNDEFINED, &mut_sem_prop);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -512,7 +512,7 @@ void UT_os_mut_sem_get_info_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_MutSemGetInfo(99999, &mut_sem_prop);
+    res = OS_MutSemGetInfo(UT_OBJID_INCORRECT, &mut_sem_prop);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
diff --git a/src/unit-tests/oscore-test/ut_oscore_queue_test.c b/src/unit-tests/oscore-test/ut_oscore_queue_test.c
index f14aa6f7c..2d29d1a52 100644
--- a/src/unit-tests/oscore-test/ut_oscore_queue_test.c
+++ b/src/unit-tests/oscore-test/ut_oscore_queue_test.c
@@ -74,8 +74,8 @@ void UT_os_queue_create_test()
     int i = 0;
     int32 res = 0;
     const char* testDesc;
-    uint32  queue_id = 0;
-    uint32  queue_id2 = 0;
+    osal_id_t  queue_id;
+    osal_id_t  queue_id2;
     char    queue_name[UT_OS_NAME_BUFF_SIZE];
     char    long_queue_name[UT_OS_NAME_BUFF_SIZE];
     uint32  test_setup_invalid = 0;
@@ -206,12 +206,12 @@ void UT_os_queue_delete_test()
 {
     int32 res = 0;
     const char* testDesc;
-    uint32  queue_id;
+    osal_id_t  queue_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_QueueDelete(0);
+    res = OS_QueueDelete(OS_OBJECT_ID_UNDEFINED);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -221,7 +221,7 @@ void UT_os_queue_delete_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_QueueDelete(99999);
+    res = OS_QueueDelete(UT_OBJID_INCORRECT);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -271,7 +271,7 @@ void UT_os_queue_get_test()
 {
     int32              res = 0;
     const char*        testDesc;
-    uint32             queue_id;
+    osal_id_t          queue_id;
     uint32             queue_data_out;
     uint32             queue_data_in;
     uint32             size_copied;
@@ -280,7 +280,7 @@ void UT_os_queue_get_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_QueueGet(0, (void *)&queue_data_in, 4, &size_copied, OS_CHECK);
+    res = OS_QueueGet(OS_OBJECT_ID_UNDEFINED, (void *)&queue_data_in, 4, &size_copied, OS_CHECK);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -290,7 +290,7 @@ void UT_os_queue_get_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_QueueGet(99999, (void *)&queue_data_in, 4, &size_copied, OS_CHECK);
+    res = OS_QueueGet(UT_OBJID_INCORRECT, (void *)&queue_data_in, 4, &size_copied, OS_CHECK);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -524,14 +524,14 @@ void UT_os_queue_put_test()
 {
     int32              res = 0;
     const char*        testDesc;
-    uint32             queue_id;
+    osal_id_t          queue_id;
     uint32             queue_data_out = 0;
     int                i;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_QueuePut(0, (void *)&queue_data_out, 4, 0);
+    res = OS_QueuePut(OS_OBJECT_ID_UNDEFINED, (void *)&queue_data_out, 4, 0);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -541,7 +541,7 @@ void UT_os_queue_put_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_QueuePut(99999, (void *)&queue_data_out, 4, 0);
+    res = OS_QueuePut(UT_OBJID_INCORRECT, (void *)&queue_data_out, 4, 0);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -639,7 +639,7 @@ void UT_os_queue_get_id_by_name_test()
 {
     int32 res = 0;
     const char* testDesc;
-    uint32  queue_id;
+    osal_id_t  queue_id;
     char  long_queue_name[UT_OS_NAME_BUFF_SIZE];
 
     /*-----------------------------------------------------*/
@@ -728,13 +728,13 @@ void UT_os_queue_get_info_test()
 {
     int32              res = 0;
     const char*        testDesc;
-    uint32             queue_id;
+    osal_id_t          queue_id;
     OS_queue_prop_t    queue_prop;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_QueueGetInfo(0,&queue_prop);
+    res = OS_QueueGetInfo(OS_OBJECT_ID_UNDEFINED,&queue_prop);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -744,7 +744,7 @@ void UT_os_queue_get_info_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_QueueGetInfo(99999, &queue_prop);
+    res = OS_QueueGetInfo(UT_OBJID_INCORRECT, &queue_prop);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
diff --git a/src/unit-tests/oscore-test/ut_oscore_select_test.c b/src/unit-tests/oscore-test/ut_oscore_select_test.c
index 432520fed..40ed0fded 100644
--- a/src/unit-tests/oscore-test/ut_oscore_select_test.c
+++ b/src/unit-tests/oscore-test/ut_oscore_select_test.c
@@ -61,14 +61,18 @@
 **--------------------------------------------------------------------------------*/
 
 char *fsAddrPtr = NULL;
-static int32 setup_file(void)
+static osal_id_t setup_file(void)
 {
+    osal_id_t id;
+    int32 status;
     UT_SETUP(OS_mkfs(fsAddrPtr, "/ramdev3", "RAM3", 512, 20));
     UT_SETUP(OS_mount("/ramdev3", "/drive3"));
-    return OS_creat("/drive3/select_test.txt", OS_READ_WRITE);
+    status = OS_creat("/drive3/select_test.txt", OS_READ_WRITE);
+    id = OS_ObjectIdFromInteger(status);
+    return id;
 }
 
-static void teardown_file(int32 fd)
+static void teardown_file(osal_id_t fd)
 {
     OS_close(fd);
     OS_remove("/drive3/select_test.txt");
@@ -86,7 +90,7 @@ static void teardown_file(int32 fd)
 void UT_os_select_fd_test(void)
 {
     OS_FdSet FdSet;
-    int32 fd = setup_file();
+    osal_id_t fd = setup_file();
 
     if(OS_SelectFdZero(&FdSet) == OS_ERR_NOT_IMPLEMENTED
         || OS_SelectFdAdd(&FdSet, fd) == OS_ERR_NOT_IMPLEMENTED
@@ -97,9 +101,9 @@ void UT_os_select_fd_test(void)
     }
 
     UtAssert_Simple(OS_SelectFdZero(NULL) == OS_INVALID_POINTER);
-    UtAssert_Simple(OS_SelectFdAdd(NULL, 0) == OS_INVALID_POINTER);
-    UtAssert_Simple(OS_SelectFdClear(NULL, 0) == OS_INVALID_POINTER);
-    UtAssert_Simple(OS_SelectFdIsSet(NULL, 0) == false);
+    UtAssert_Simple(OS_SelectFdAdd(NULL, fd) == OS_INVALID_POINTER);
+    UtAssert_Simple(OS_SelectFdClear(NULL, fd) == OS_INVALID_POINTER);
+    UtAssert_Simple(OS_SelectFdIsSet(NULL, fd) == false);
 
     OS_SelectFdZero(&FdSet);
     OS_SelectFdAdd(&FdSet, fd);
@@ -124,7 +128,7 @@ void UT_os_select_fd_test(void)
 void UT_os_select_single_test(void)
 {
     uint32 StateFlags;
-    int32 fd = setup_file();
+    osal_id_t fd = setup_file();
     int32 rc;
 
     UT_RETVAL(OS_SelectSingle(fd, NULL, 0), OS_INVALID_POINTER, "NULL flags pointer");
@@ -159,7 +163,7 @@ void UT_os_select_single_test(void)
 void UT_os_select_multi_test(void)
 {
     OS_FdSet ReadSet, WriteSet;
-    int32 fd = setup_file();
+    osal_id_t fd = setup_file();
     int32 rc;
 
     OS_SelectFdZero(&WriteSet);
diff --git a/src/unit-tests/oscore-test/ut_oscore_task_test.c b/src/unit-tests/oscore-test/ut_oscore_task_test.c
index 47a33d85c..ff98f0224 100644
--- a/src/unit-tests/oscore-test/ut_oscore_task_test.c
+++ b/src/unit-tests/oscore-test/ut_oscore_task_test.c
@@ -56,8 +56,8 @@ extern char  g_long_task_name[UT_OS_NAME_BUFF_SIZE];
 **--------------------------------------------------------------------------------*/
 
 uint32 g_task_result = 0;
-uint32 g_task_sync_sem = 0;
-uint32 g_task_ids[UT_OS_TASK_LIST_LEN];
+osal_id_t g_task_sync_sem;
+osal_id_t g_task_ids[UT_OS_TASK_LIST_LEN];
 uint32 g_task_stacks[UT_OS_TASK_LIST_LEN][UT_TASK_STACK_SIZE];
 
 /*--------------------------------------------------------------------------------*
@@ -76,7 +76,7 @@ uint32 g_task_stacks[UT_OS_TASK_LIST_LEN][UT_TASK_STACK_SIZE];
 
 void generic_test_task(void)
 {
-    int32 task_id=0;
+    osal_id_t task_id;
     OS_task_prop_t task_prop;
 
     OS_TaskRegister();
@@ -84,7 +84,8 @@ void generic_test_task(void)
     task_id = OS_TaskGetId();
     OS_TaskGetInfo(task_id, &task_prop);
    
-    UT_OS_LOG("Starting GenericTask: %s, id: %d\n", task_prop.name, (int)task_id);
+    UT_OS_LOG("Starting GenericTask: %s, id: %lx\n",
+            task_prop.name, OS_ObjectIdToInteger(task_id));
 
     while (1)
     {
@@ -276,7 +277,7 @@ void UT_os_task_delete_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_TaskDelete(99999);
+    res = OS_TaskDelete(UT_OBJID_INCORRECT);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -286,7 +287,7 @@ void UT_os_task_delete_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_TaskDelete(99999);
+    res = OS_TaskDelete(UT_OBJID_INCORRECT);
     if ( res == OS_ERR_INVALID_ID )
        UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -341,7 +342,7 @@ void delete_handler_callback(void)
 
 void delete_handler_test_task(void)
 {
-    int32 task_id=0;
+    osal_id_t task_id;
     OS_task_prop_t task_prop;
 
     OS_TaskRegister();
@@ -349,7 +350,8 @@ void delete_handler_test_task(void)
     task_id = OS_TaskGetId();
     OS_TaskGetInfo(task_id, &task_prop);
 
-    UT_OS_LOG("Starting DeleteTest Task: %s, id: %d\n", task_prop.name, (int)task_id);
+    UT_OS_LOG("Starting DeleteTest Task: %s, id: %lx\n",
+            task_prop.name, OS_ObjectIdToInteger(task_id));
 
     g_task_result = OS_TaskInstallDeleteHandler(&delete_handler_callback);
 
@@ -447,7 +449,7 @@ void UT_os_task_install_delete_handler_test(void)
 **--------------------------------------------------------------------------------*/
 void exit_test_task(void)
 {
-    int32 task_id=0;
+    osal_id_t task_id;
     OS_task_prop_t task_prop;
 
     OS_TaskRegister();
@@ -455,7 +457,8 @@ void exit_test_task(void)
     task_id = OS_TaskGetId();
     OS_TaskGetInfo(task_id, &task_prop);
 
-    UT_OS_LOG("Starting ExitTest Task: %s, id: %d\n", task_prop.name, (int)task_id);;
+    UT_OS_LOG("Starting ExitTest Task: %s, id: %lx\n",
+            task_prop.name, OS_ObjectIdToInteger(task_id));
 
     /*
     ** The parent task will check to see if this task is valid.
@@ -611,7 +614,7 @@ void UT_os_task_set_priority_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_TaskSetPriority(99999, 100);
+    res = OS_TaskSetPriority(UT_OBJID_INCORRECT, 100);
     if (res == OS_ERR_INVALID_ID)
        UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -688,7 +691,7 @@ void UT_os_task_set_priority_test()
 **--------------------------------------------------------------------------------*/
 void register_test_task(void)
 {
-    int32 task_id=0;
+    osal_id_t task_id;
     OS_task_prop_t task_prop;
 
     g_task_result = OS_TaskRegister();
@@ -788,7 +791,7 @@ void UT_os_task_register_test(void)
 
 void getid_test_task(void)
 {
-    int32 task_id=0;
+    osal_id_t task_id;
     OS_task_prop_t task_prop;
 
     OS_TaskRegister();
@@ -796,8 +799,8 @@ void getid_test_task(void)
     task_id = OS_TaskGetId();
     OS_TaskGetInfo(task_id, &task_prop);
 
-    UT_OS_LOG("OS_TaskGetId() - #1 Nominal [This is the returned task Id=%d]\n",
-    		            (int)task_id);
+    UT_OS_LOG("OS_TaskGetId() - #1 Nominal [This is the returned task Id=%lx]\n",
+    		            OS_ObjectIdToInteger(task_id));
 
     while (1)
     {
@@ -816,15 +819,10 @@ void UT_os_task_get_id_test()
     int32 res=0;
     const char* testDesc;
 
-    /*-----------------------------------------------------*/
-    testDesc = "API not implemented";
-
-    res = OS_TaskGetId();
-    if (res == OS_ERR_NOT_IMPLEMENTED)
-    {
-        UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
-        goto UT_os_task_get_id_test_exit_tag;
-    }
+    /*
+     * Note this function does not return a normal status code,
+     * there is no provision to return/check for OS_ERR_NOT_IMPLEMENTED.
+     */
 
     /*-----------------------------------------------------*/
     testDesc = "#1 Nominal";
@@ -841,17 +839,14 @@ void UT_os_task_get_id_test()
     {
     	OS_TaskDelay(500);
 
-    	UT_OS_LOG("OS_TaskGetId() - #1 Nominal [This is the expected task Id=%d]\n",
-    			            (int)g_task_ids[1]);
+    	UT_OS_LOG("OS_TaskGetId() - #1 Nominal [This is the expected task Id=%lx]\n",
+    			            OS_ObjectIdToInteger(g_task_ids[1]));
 
     	res = OS_TaskDelete(g_task_ids[1]);  /* Won't hurt if its already deleted */
 
     	UT_OS_TEST_RESULT( "#1 Nominal - Manual inspection required", UTASSERT_CASETYPE_MIR);
     }
 
-UT_os_task_get_id_test_exit_tag:
-    return;
-    
 }
 
 /*--------------------------------------------------------------------------------*
@@ -928,7 +923,7 @@ void UT_os_task_get_id_by_name_test()
     else
     {
         res = OS_TaskGetIdByName(&g_task_ids[6], g_task_names[5]);
-        if ((res == OS_SUCCESS) && (g_task_ids[5] == g_task_ids[6]))
+        if ((res == OS_SUCCESS) && OS_ObjectIdEqual(g_task_ids[5], g_task_ids[6]))
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
         else
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -959,7 +954,7 @@ void UT_os_task_get_info_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_TaskGetInfo(99999, &task_prop);
+    res = OS_TaskGetInfo(UT_OBJID_INCORRECT, &task_prop);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -969,7 +964,7 @@ void UT_os_task_get_info_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_TaskGetInfo(99999, &task_prop);
+    res = OS_TaskGetInfo(UT_OBJID_INCORRECT, &task_prop);
     if (res == OS_ERR_INVALID_ID)
        UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
diff --git a/src/unit-tests/osfile-test/ut_osfile_dirio_test.c b/src/unit-tests/osfile-test/ut_osfile_dirio_test.c
index 5f5ab14db..3f285a3a0 100644
--- a/src/unit-tests/osfile-test/ut_osfile_dirio_test.c
+++ b/src/unit-tests/osfile-test/ut_osfile_dirio_test.c
@@ -66,7 +66,7 @@ char  g_dirItems[UT_OS_FILE_MAX_DIRS][UT_OS_FILE_BUFF_SIZE];
 ** Local function prototypes
 **--------------------------------------------------------------------------------*/
 
-void UT_os_read_n_sort_dirs(uint32);
+void UT_os_read_n_sort_dirs(osal_id_t);
 
 /*--------------------------------------------------------------------------------*
 ** Local function definitions
@@ -120,7 +120,8 @@ void UT_os_read_n_sort_dirs(uint32);
 **--------------------------------------------------------------------------------*/
 void UT_os_makedir_test()
 {
-    int32 fileDesc=0;
+    int32 status;
+    osal_id_t fileDesc;
     const char* testDesc;
 
     /*-----------------------------------------------------*/
@@ -175,13 +176,14 @@ void UT_os_makedir_test()
 
     memset(g_fileName, '\0', sizeof(g_fileName));
     UT_os_sprintf(g_fileName, "%s/mkdir_File.txt", g_dirName);
-    fileDesc = OS_creat(g_fileName, OS_READ_WRITE);
-    if (fileDesc >= 0)
+    status = OS_creat(g_fileName, OS_READ_WRITE);
+    if (status >= 0)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
 
     /* Reset test environment */
+    fileDesc = OS_ObjectIdFromInteger(status);
     OS_close(fileDesc);
     OS_remove(g_fileName);
     OS_rmdir(g_dirName);
@@ -238,7 +240,7 @@ void UT_os_makedir_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_opendir_test()
 {
-    uint32 dirh;
+    osal_id_t dirh;
     const char* testDesc;
 
     /*-----------------------------------------------------*/
@@ -340,14 +342,14 @@ void UT_os_opendir_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_closedir_test()
 {
-    uint32 dirh;
+    osal_id_t dirh;
     os_dirent_t* dirEntry=NULL;
     const char* testDesc;
 
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    if (OS_DirectoryClose(0) == OS_ERR_NOT_IMPLEMENTED)
+    if (OS_DirectoryClose(OS_OBJECT_ID_UNDEFINED) == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
         goto UT_os_closedir_test_exit_tag;
@@ -441,7 +443,7 @@ void UT_os_closedir_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_readdir_test()
 {
-    uint32 dirh;
+    osal_id_t dirh;
     const char* testDesc;
 
     strcpy(g_subdirNames[0], " ");
@@ -450,7 +452,7 @@ void UT_os_readdir_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    if (OS_DirectoryRead(0, NULL) == OS_ERR_NOT_IMPLEMENTED)
+    if (OS_DirectoryRead(OS_OBJECT_ID_UNDEFINED, NULL) == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
         goto UT_os_readdir_test_exit_tag;
@@ -459,7 +461,7 @@ void UT_os_readdir_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Null-pointer-arg";
 
-    if (OS_DirectoryRead(0, NULL) == OS_INVALID_POINTER)
+    if (OS_DirectoryRead(OS_OBJECT_ID_UNDEFINED, NULL) == OS_INVALID_POINTER)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -570,7 +572,7 @@ void UT_os_readdir_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_rewinddir_test()
 {
-    uint32 dirh;
+    osal_id_t dirh;
     const char* testDesc;
 
     strcpy(g_subdirNames[0], " ");
@@ -579,7 +581,7 @@ void UT_os_rewinddir_test()
     /*-----------------------------------------------------*/
     testDesc = "API Not implemented";
 
-    if (OS_DirectoryRewind(0) == OS_ERR_NOT_IMPLEMENTED)
+    if (OS_DirectoryRewind(OS_OBJECT_ID_UNDEFINED) == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
         goto UT_os_rewinddir_test_exit_tag;
@@ -718,7 +720,8 @@ void UT_os_rewinddir_test()
 **--------------------------------------------------------------------------------*/
 void UT_os_removedir_test()
 {
-    int32 fileDesc=0;
+    int32 status;
+    osal_id_t fileDesc;
     const char* testDesc;
 
     /*-----------------------------------------------------*/
@@ -773,14 +776,15 @@ void UT_os_removedir_test()
 
     memset(g_fileName, '\0', sizeof(g_fileName));
     UT_os_sprintf(g_fileName, "%s/rmdir_File1.txt", g_dirName);
-    fileDesc = OS_creat(g_fileName, OS_READ_WRITE);
-    if (fileDesc < 0)
+    status = OS_creat(g_fileName, OS_READ_WRITE);
+    if (status < 0)
     {
         testDesc = "#5 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
     }
 
     /* Must close and remove all files before the directory can be removed */
+    fileDesc = OS_ObjectIdFromInteger(status);
     OS_close(fileDesc);
     OS_remove(g_fileName);
 
@@ -792,8 +796,8 @@ void UT_os_removedir_test()
 
     memset(g_fileName, '\0', sizeof(g_fileName));
     UT_os_sprintf(g_fileName, "%s/rmdir_File2.txt", g_dirName);
-    fileDesc = OS_creat(g_fileName, OS_READ_WRITE);
-    if (fileDesc < 0)
+    status = OS_creat(g_fileName, OS_READ_WRITE);
+    if (status < 0)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -806,7 +810,7 @@ void UT_os_removedir_test()
 /*--------------------------------------------------------------------------------*
  * Internal helper function
 **--------------------------------------------------------------------------------*/
-void UT_os_read_n_sort_dirs(uint32 dirh)
+void UT_os_read_n_sort_dirs(osal_id_t dirh)
 {
     int i=0;
     os_dirent_t dirEntry;
diff --git a/src/unit-tests/osfile-test/ut_osfile_fileio_test.c b/src/unit-tests/osfile-test/ut_osfile_fileio_test.c
index be3b6a21d..0d8496acf 100644
--- a/src/unit-tests/osfile-test/ut_osfile_fileio_test.c
+++ b/src/unit-tests/osfile-test/ut_osfile_fileio_test.c
@@ -57,7 +57,8 @@ extern char* g_mntName;
 **--------------------------------------------------------------------------------*/
 
 char   g_fNames[UT_OS_FILE_LIST_LEN][UT_OS_FILE_BUFF_SIZE];
-int32  g_fDescs[UT_OS_FILE_LIST_LEN];
+int32       g_fStatus[UT_OS_FILE_LIST_LEN];
+osal_id_t   g_fDescs[UT_OS_FILE_LIST_LEN];
 
 char  g_readBuff[UT_OS_IO_BUFF_SIZE];
 char  g_writeBuff[UT_OS_IO_BUFF_SIZE];
@@ -265,7 +266,6 @@ void UT_os_createfile_test()
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
 
     /* Reset test environment */
-    OS_close(res);
     OS_remove(g_fNames[0]);
 
     /*-----------------------------------------------------*/
@@ -280,12 +280,14 @@ void UT_os_createfile_test()
     {
         memset(g_fNames[i], '\0', sizeof(g_fNames[i]));
         UT_os_sprintf(g_fNames[i], "%s/tmpFile%d.txt", g_mntName, (int)i);
-        g_fDescs[i] = OS_creat(g_fNames[i], OS_WRITE_ONLY);
-        if (g_fDescs[i] < 0)
+        g_fStatus[i] = OS_creat(g_fNames[i], OS_WRITE_ONLY);
+        if (g_fStatus[i] < 0)
             break;
+
+        g_fDescs[i] = OS_ObjectIdFromInteger(g_fStatus[i]);
     }
 
-    if ((i == OS_MAX_NUM_OPEN_FILES) && (g_fDescs[i] == OS_ERR_NO_FREE_IDS))
+    if ((i == OS_MAX_NUM_OPEN_FILES) && (g_fStatus[i] == OS_ERR_NO_FREE_IDS))
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -300,8 +302,10 @@ void UT_os_createfile_test()
     /*-----------------------------------------------------*/
     testDesc = "#8 Nominal";
 
-    g_fDescs[5] = OS_creat(g_fNames[5], OS_WRITE_ONLY);
-    g_fDescs[6] = OS_creat(g_fNames[6], OS_WRITE_ONLY);
+    g_fStatus[5] = OS_creat(g_fNames[5], OS_WRITE_ONLY);
+    g_fDescs[5] = OS_ObjectIdFromInteger(g_fStatus[5]);
+    g_fStatus[6] = OS_creat(g_fNames[6], OS_WRITE_ONLY);
+    g_fDescs[6] = OS_ObjectIdFromInteger(g_fStatus[6]);
 
     if ((OS_close(g_fDescs[5])  != OS_SUCCESS) || (OS_close(g_fDescs[6])  != OS_SUCCESS) ||
         (OS_remove(g_fNames[5]) != OS_SUCCESS) || (OS_remove(g_fNames[6]) != OS_SUCCESS))
@@ -445,7 +449,6 @@ void UT_os_openfile_test()
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
 
     /* Reset test environment */
-    OS_close(res);
     OS_remove(g_fNames[0]);
 
     /*-----------------------------------------------------*/
@@ -461,8 +464,8 @@ void UT_os_openfile_test()
     {
         memset(g_fNames[i], '\0', sizeof(g_fNames[i]));
         UT_os_sprintf(g_fNames[i], "%s/tmpFile%d.txt", g_mntName, (int)i);
-        g_fDescs[i] = OS_creat(g_fNames[i], OS_WRITE_ONLY);
-        if (g_fDescs[i] < OS_SUCCESS)
+        g_fStatus[i] = OS_creat(g_fNames[i], OS_WRITE_ONLY);
+        if (g_fStatus[i] < OS_SUCCESS)
         {
             testDesc = "#7 File-descriptors-full - File-create failed";
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
@@ -470,6 +473,8 @@ void UT_os_openfile_test()
             break;
         }
 
+        g_fDescs[i] = OS_ObjectIdFromInteger(g_fStatus[i]);
+
         if (continueFlg && (OS_close(g_fDescs[i]) != OS_SUCCESS))
         {
             testDesc = "#7 File-descriptors-full - File-close failed";
@@ -483,12 +488,14 @@ void UT_os_openfile_test()
     {
         for (i=0; i <= OS_MAX_NUM_OPEN_FILES; i++)
         {
-            g_fDescs[i] = OS_open(g_fNames[i], OS_WRITE_ONLY, 0644);
-            if (g_fDescs[i] < 0)
+            g_fStatus[i] = OS_open(g_fNames[i], OS_WRITE_ONLY, 0644);
+            if (g_fStatus[i] < 0)
                 break;
+
+            g_fDescs[i] = OS_ObjectIdFromInteger(g_fStatus[i]);
         }
 
-        if ((i == OS_MAX_NUM_OPEN_FILES) && (g_fDescs[i] < OS_SUCCESS))
+        if ((i == OS_MAX_NUM_OPEN_FILES) && (g_fStatus[i] < OS_SUCCESS))
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
         else
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -504,15 +511,18 @@ void UT_os_openfile_test()
     /*-----------------------------------------------------*/
     testDesc = "#8 Nominal";
 
-    g_fDescs[5] = OS_creat(g_fNames[5], OS_READ_WRITE);
-    g_fDescs[6] = OS_creat(g_fNames[6], OS_WRITE_ONLY);
-    if ((g_fDescs[5] < OS_SUCCESS) || (g_fDescs[6] < OS_SUCCESS))
+    g_fStatus[5] = OS_creat(g_fNames[5], OS_READ_WRITE);
+    g_fStatus[6] = OS_creat(g_fNames[6], OS_WRITE_ONLY);
+    if ((g_fStatus[5] < OS_SUCCESS) || (g_fStatus[6] < OS_SUCCESS))
     {
         testDesc = "#8 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_openfile_test_exit_tag;
     }
 
+    g_fDescs[5] = OS_ObjectIdFromInteger(g_fStatus[5]);
+    g_fDescs[6] = OS_ObjectIdFromInteger(g_fStatus[6]);
+
     if ((OS_close(g_fDescs[5]) != OS_SUCCESS) || (OS_close(g_fDescs[6]) != OS_SUCCESS))
     {
         testDesc = "#8 Nominal - File-close failed";
@@ -520,8 +530,11 @@ void UT_os_openfile_test()
         goto UT_os_openfile_test_exit_tag;
     }
 
-    g_fDescs[5] = OS_open(g_fNames[5], OS_READ_WRITE, 0644);
-    g_fDescs[6] = OS_open(g_fNames[6], OS_WRITE_ONLY, 0644);
+    g_fStatus[5] = OS_open(g_fNames[5], OS_READ_WRITE, 0644);
+    g_fStatus[6] = OS_open(g_fNames[6], OS_WRITE_ONLY, 0644);
+
+    g_fDescs[5] = OS_ObjectIdFromInteger(g_fStatus[5]);
+    g_fDescs[6] = OS_ObjectIdFromInteger(g_fStatus[6]);
 
     if ((OS_close(g_fDescs[5])  != OS_SUCCESS) || (OS_close(g_fDescs[6])  != OS_SUCCESS) ||
         (OS_remove(g_fNames[5]) != OS_SUCCESS) || (OS_remove(g_fNames[6]) != OS_SUCCESS))
@@ -580,7 +593,7 @@ void UT_os_closefile_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    if (OS_close(99999) == OS_ERR_NOT_IMPLEMENTED)
+    if (OS_close(UT_OBJID_INCORRECT) == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
         goto UT_os_closefile_test_exit_tag;
@@ -589,7 +602,7 @@ void UT_os_closefile_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-file-desc-arg";
 
-    if (OS_close(99999) == OS_ERR_INVALID_ID)
+    if (OS_close(UT_OBJID_INCORRECT) == OS_ERR_INVALID_ID)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -605,14 +618,16 @@ void UT_os_closefile_test()
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Close_Nominal.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#3 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_closefile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
+
     if ((OS_close(g_fDescs[0]) != OS_SUCCESS) ||
         (OS_write(g_fDescs[0], tmpBuff, sizeof(tmpBuff)) != OS_ERR_INVALID_ID) ||
         (OS_read(g_fDescs[0],  tmpBuff, sizeof(tmpBuff)) != OS_ERR_INVALID_ID))
@@ -688,7 +703,7 @@ void UT_os_readfile_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    if (OS_read(99999, NULL, 0) == OS_ERR_NOT_IMPLEMENTED)
+    if (OS_read(UT_OBJID_INCORRECT, NULL, 0) == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
         goto UT_os_readfile_test_exit_tag;
@@ -699,14 +714,16 @@ void UT_os_readfile_test()
 
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Read_NullPtr.txt", g_mntName);
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#1 Null-pointer-arg - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
     }
     else
     {
+        g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
+
         if (OS_read(g_fDescs[0], NULL, sizeof(g_readBuff)) == OS_INVALID_POINTER)
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
         else
@@ -720,7 +737,7 @@ void UT_os_readfile_test()
     /*-----------------------------------------------------*/
     testDesc = "#2 Invalid-file-desc-arg";
 
-    if (OS_read(99999, g_readBuff, sizeof(g_readBuff)) == OS_ERR_INVALID_ID)
+    if (OS_read(UT_OBJID_INCORRECT, g_readBuff, sizeof(g_readBuff)) == OS_ERR_INVALID_ID)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -736,14 +753,15 @@ void UT_os_readfile_test()
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Read_Nominal.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#4 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_readfile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     memset(g_writeBuff, '\0', sizeof(g_writeBuff));
     strcpy(g_writeBuff, "A HORSE! A HORSE! MY KINGDOM FOR A HORSE!");
     if (OS_write(g_fDescs[0], g_writeBuff, strlen(g_writeBuff)) != strlen(g_writeBuff))
@@ -769,8 +787,8 @@ void UT_os_readfile_test()
         goto UT_os_readfile_test_exit_tag;
     }
 
-    g_fDescs[0] = OS_open(g_fNames[0], OS_READ_WRITE, 0644);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_open(g_fNames[0], OS_READ_WRITE, 0644);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#4 Nominal - File-open failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
@@ -781,6 +799,7 @@ void UT_os_readfile_test()
         goto UT_os_readfile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     memset(g_readBuff, '\0', sizeof(g_readBuff));
     if ((OS_read(g_fDescs[0], g_readBuff, strlen(g_writeBuff)) == strlen(g_writeBuff)) &&
         (strncmp(g_readBuff, g_writeBuff, strlen(g_writeBuff)) == 0))
@@ -859,7 +878,7 @@ void UT_os_writefile_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    if (OS_write(99999, NULL, 0) == OS_ERR_NOT_IMPLEMENTED)
+    if (OS_write(UT_OBJID_INCORRECT, NULL, 0) == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
         goto UT_os_writefile_test_exit_tag;
@@ -870,14 +889,16 @@ void UT_os_writefile_test()
 
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Write_NullPtr.txt", g_mntName);
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#1 Null-pointer-arg - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
     }
     else
     {
+        g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
+
         if (OS_write(g_fDescs[0], NULL, sizeof(g_writeBuff)) == OS_INVALID_POINTER)
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
         else
@@ -891,7 +912,7 @@ void UT_os_writefile_test()
     /*-----------------------------------------------------*/
     testDesc = "#2 Invalid-file-desc-arg";
 
-    if (OS_write(99999, g_writeBuff, sizeof(g_writeBuff)) == OS_ERR_INVALID_ID)
+    if (OS_write(UT_OBJID_INCORRECT, g_writeBuff, sizeof(g_writeBuff)) == OS_ERR_INVALID_ID)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -907,14 +928,15 @@ void UT_os_writefile_test()
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Write_Nominal.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < OS_SUCCESS)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < OS_SUCCESS)
     {
         testDesc = "#4 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_writefile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     memset(g_writeBuff, '\0', sizeof(g_writeBuff));
     strcpy(g_writeBuff, "TO BE OR NOT TO BE, THAT IS A QUESTION.");
     if (OS_write(g_fDescs[0], g_writeBuff, strlen(g_writeBuff)) != strlen(g_writeBuff))
@@ -939,8 +961,8 @@ void UT_os_writefile_test()
         goto UT_os_writefile_test_exit_tag;
     }
 
-    g_fDescs[0] = OS_open(g_fNames[0], OS_READ_WRITE, 0644);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_open(g_fNames[0], OS_READ_WRITE, 0644);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#4 Nominal - File-open failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
@@ -951,6 +973,7 @@ void UT_os_writefile_test()
         goto UT_os_writefile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     memset(g_readBuff, '\0', sizeof(g_readBuff));
     if ((OS_read(g_fDescs[0], g_readBuff, strlen(g_writeBuff)) == strlen(g_writeBuff)) &&
         (strncmp(g_readBuff, g_writeBuff, strlen(g_writeBuff)) == 0))
@@ -1028,7 +1051,7 @@ void UT_os_lseekfile_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    if (OS_lseek(99999, 0, OS_SEEK_CUR) == OS_ERR_NOT_IMPLEMENTED)
+    if (OS_lseek(UT_OBJID_INCORRECT, 0, OS_SEEK_CUR) == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
         goto UT_os_lseekfile_test_exit_tag;
@@ -1037,7 +1060,7 @@ void UT_os_lseekfile_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-file-desc-arg";
 
-    if (OS_lseek(99999, 0, OS_SEEK_SET) == OS_ERR_INVALID_ID)
+    if (OS_lseek(UT_OBJID_INCORRECT, 0, OS_SEEK_SET) == OS_ERR_INVALID_ID)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -1047,22 +1070,24 @@ void UT_os_lseekfile_test()
 
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Seek_InvWhence.txt", g_mntName);
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#2 Invalid-whence-arg - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
     }
     else
     {
+        g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
         if (OS_lseek(g_fDescs[0], 0, 123456) == OS_ERROR)
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
         else
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
+
+        OS_close(g_fDescs[0]);
     }
 
     /* Reset test environment */
-    OS_close(g_fDescs[0]);
     OS_remove(g_fNames[0]);
 
     /*-----------------------------------------------------*/
@@ -1076,14 +1101,15 @@ void UT_os_lseekfile_test()
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Seek_Nominal.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#4 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_lseekfile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     memset(g_writeBuff, '\0', sizeof(g_writeBuff));
     strcpy(g_writeBuff, "THE BROWN FOX JUMPS OVER THE LAZY DOG.");
     buffLen = (int32)strlen(g_writeBuff);
@@ -1250,8 +1276,8 @@ void UT_os_statfile_test()
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Stat_Nominal.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#5 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
@@ -1264,6 +1290,7 @@ void UT_os_statfile_test()
         goto UT_os_statfile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     memset(g_writeBuff, '\0', sizeof(g_writeBuff));
     strcpy(g_writeBuff, "HOW NOW, BROWN COW?");
     if (OS_write(g_fDescs[0], g_writeBuff, strlen(g_writeBuff)) != strlen(g_writeBuff))
@@ -1410,14 +1437,15 @@ void UT_os_removefile_test()
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Remove_Nominal.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#6 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_removefile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     /* TODO: Check to see if OS_remove() can delete an opened file. */
     OS_close(g_fDescs[0]);
 
@@ -1556,8 +1584,8 @@ void UT_os_renamefile_test()
     UT_os_sprintf(g_fNames[0], "%s/Rename_Nom_Old.txt", g_mntName);
     UT_os_sprintf(g_fNames[1], "%s/Rename_Nom_New.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#6 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
@@ -1714,14 +1742,15 @@ void UT_os_copyfile_test()
         goto UT_os_copyfile_test_exit_tag;
     }
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#6 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_copyfile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     if (OS_close(g_fDescs[0]) != OS_SUCCESS)
     {
         testDesc = "#6 Nominal - File-close failed";
@@ -1882,14 +1911,15 @@ void UT_os_movefile_test()
         goto UT_os_movefile_test_exit_tag;
     }
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#6 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_movefile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     /* Close file before moving */
     if (OS_close(g_fDescs[0]) != OS_SUCCESS)
     {
@@ -1978,7 +2008,7 @@ void UT_os_outputtofile_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    if (OS_ShellOutputToFile(NULL, 0) == OS_ERR_NOT_IMPLEMENTED)
+    if (OS_ShellOutputToFile(NULL, OS_OBJECT_ID_UNDEFINED) == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
         goto UT_os_outputtofile_test_exit_tag;
@@ -1987,7 +2017,7 @@ void UT_os_outputtofile_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Null-pointer-arg";
 
-    if (OS_ShellOutputToFile(NULL, 0) == OS_INVALID_POINTER)
+    if (OS_ShellOutputToFile(NULL, OS_OBJECT_ID_UNDEFINED) == OS_INVALID_POINTER)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -1995,7 +2025,7 @@ void UT_os_outputtofile_test()
     /*-----------------------------------------------------*/
     testDesc = "#2 Invalid-file-desc-arg";
 
-    if (OS_ShellOutputToFile("ls", 99999) == OS_ERR_INVALID_ID)
+    if (OS_ShellOutputToFile("ls", UT_OBJID_INCORRECT) == OS_ERR_INVALID_ID)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -2010,14 +2040,15 @@ void UT_os_outputtofile_test()
 
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Output_Nominal.txt", g_mntName);
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#4 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_outputtofile_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     cmd = "echo \"UT_os_outputtofile_test\"";
     res = OS_ShellOutputToFile(cmd, g_fDescs[0]);
     if (res == OS_ERR_NOT_IMPLEMENTED)
@@ -2121,7 +2152,7 @@ void UT_os_getfdinfo_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    if (OS_FDGetInfo(0, NULL) == OS_ERR_NOT_IMPLEMENTED)
+    if (OS_FDGetInfo(OS_OBJECT_ID_UNDEFINED, NULL) == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
         goto UT_os_getfdinfo_test_exit_tag;
@@ -2133,28 +2164,32 @@ void UT_os_getfdinfo_test()
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/GetInfo_Null.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#1 Null-pointer-arg - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
     }
-    else if (OS_FDGetInfo(g_fDescs[0], NULL) != OS_INVALID_POINTER)
-    {
-        UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
-    }
     else
     {
-        UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
-    }
+        g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
+        if (OS_FDGetInfo(g_fDescs[0], NULL) != OS_INVALID_POINTER)
+        {
+            UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
+        }
+        else
+        {
+            UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
+        }
 
-    OS_close(g_fDescs[0]);
+        OS_close(g_fDescs[0]);
+    }
     OS_remove(g_fNames[0]);
 
     /*-----------------------------------------------------*/
     testDesc = "#2 Invalid-file-desc-arg";
 
-    if (OS_FDGetInfo(99999, &fdProps) == OS_ERR_INVALID_ID)
+    if (OS_FDGetInfo(UT_OBJID_INCORRECT, &fdProps) == OS_ERR_INVALID_ID)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -2169,14 +2204,15 @@ void UT_os_getfdinfo_test()
 
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/%s", g_mntName, fileName);
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_WRITE_ONLY);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#4 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
         goto UT_os_getfdinfo_test_exit_tag;
     }
 
+    g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
     memset(&fdProps, 0x00, sizeof(fdProps));
     if (OS_FDGetInfo(g_fDescs[0], &fdProps) != OS_SUCCESS ||
         strcmp(fdProps.Path, g_fNames[0]) != 0)
@@ -2265,24 +2301,29 @@ void UT_os_checkfileopen_test()
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/FChk_UnOpened.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#2 File-not-opened - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
     }
-    else if (OS_close(g_fDescs[0]) != OS_SUCCESS)
-    {
-        testDesc = "#2 File-not-opened - File-close failed";
-        UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
-    }
-    else if (OS_FileOpenCheck(g_fNames[0]) != OS_ERROR)
-    {
-        UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
-    }
     else
     {
-        UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
+        g_fDescs[0] = OS_ObjectIdFromInteger(g_fStatus[0]);
+
+        if (OS_close(g_fDescs[0]) != OS_SUCCESS)
+        {
+            testDesc = "#2 File-not-opened - File-close failed";
+            UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
+        }
+        else if (OS_FileOpenCheck(g_fNames[0]) != OS_ERROR)
+        {
+            UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
+        }
+        else
+        {
+            UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
+        }
     }
 
     /* Reset test environment */
@@ -2294,8 +2335,8 @@ void UT_os_checkfileopen_test()
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/FileChk_Nominal.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#3 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
@@ -2374,10 +2415,10 @@ void UT_os_closeallfiles_test()
     UT_os_sprintf(g_fNames[1], "%s/CloseAll_Nom_2.txt", g_mntName);
     UT_os_sprintf(g_fNames[2], "%s/CloseAll_Nom_3.txt", g_mntName);
 
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    g_fDescs[1] = OS_creat(g_fNames[1], OS_READ_WRITE);
-    g_fDescs[2] = OS_creat(g_fNames[2], OS_READ_WRITE);
-    if ((g_fDescs[0] < 0) || (g_fDescs[1] < 0) || (g_fDescs[2] < 0))
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    g_fStatus[1] = OS_creat(g_fNames[1], OS_READ_WRITE);
+    g_fStatus[2] = OS_creat(g_fNames[2], OS_READ_WRITE);
+    if ((g_fStatus[0] < 0) || (g_fStatus[1] < 0) || (g_fStatus[2] < 0))
     {
         testDesc = "#2 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
@@ -2488,8 +2529,8 @@ void UT_os_closefilebyname_test()
 
     memset(g_fNames[0], '\0', sizeof(g_fNames[0]));
     UT_os_sprintf(g_fNames[0], "%s/Close_Nominal.txt", g_mntName);
-    g_fDescs[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
-    if (g_fDescs[0] < 0)
+    g_fStatus[0] = OS_creat(g_fNames[0], OS_READ_WRITE);
+    if (g_fStatus[0] < 0)
     {
         testDesc = "#4 Nominal - File-create failed";
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_TSF);
diff --git a/src/unit-tests/osloader-test/ut_osloader_module_test.c b/src/unit-tests/osloader-test/ut_osloader_module_test.c
index d88b69573..c45ac9ee0 100644
--- a/src/unit-tests/osloader-test/ut_osloader_module_test.c
+++ b/src/unit-tests/osloader-test/ut_osloader_module_test.c
@@ -71,8 +71,8 @@ void UT_os_module_load_test()
     int32 res = 0;
     const char* testDesc;
     uint32  test_setup_invalid = 0;
-    uint32  module_id;
-    uint32  module_id2;
+    osal_id_t  module_id;
+    osal_id_t  module_id2;
     char    module_name[UT_OS_NAME_BUFF_SIZE];
     char    module_file_name[UT_OS_PATH_BUFF_SIZE];
 
@@ -199,12 +199,12 @@ void UT_os_module_unload_test()
 {
     int32 res = 0;
     const char* testDesc;
-    uint32  module_id = 0;
+    osal_id_t  module_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API Not implemented";
 
-    res = OS_ModuleUnload(0);
+    res = OS_ModuleUnload(OS_OBJECT_ID_UNDEFINED);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -214,7 +214,7 @@ void UT_os_module_unload_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-ID-arg";
 
-    res = OS_ModuleUnload(99999);
+    res = OS_ModuleUnload(UT_OBJID_INCORRECT);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -261,13 +261,13 @@ void UT_os_module_info_test()
 {
     int32              res = 0;
     const char*        testDesc;
-    uint32             module_id;
+    osal_id_t          module_id;
     OS_module_prop_t   module_info;
 
     /*-----------------------------------------------------*/
     testDesc = "API Not implemented";
 
-    res = OS_ModuleInfo(0, &module_info);
+    res = OS_ModuleInfo(OS_OBJECT_ID_UNDEFINED, &module_info);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -277,7 +277,7 @@ void UT_os_module_info_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-pointer-arg";
 
-    res = OS_ModuleInfo(0, NULL);
+    res = OS_ModuleInfo(OS_OBJECT_ID_UNDEFINED, NULL);
     if ( res == OS_INVALID_POINTER )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -286,7 +286,7 @@ void UT_os_module_info_test()
     /*-----------------------------------------------------*/
     testDesc = "#2 Invalid-ID-arg";
 
-    res = OS_ModuleInfo(99999, &module_info);
+    res = OS_ModuleInfo(UT_OBJID_INCORRECT, &module_info);
     if ( res == OS_ERR_INVALID_ID )
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
diff --git a/src/unit-tests/osloader-test/ut_osloader_symtable_test.c b/src/unit-tests/osloader-test/ut_osloader_symtable_test.c
index b0212de9a..0ec59dae9 100644
--- a/src/unit-tests/osloader-test/ut_osloader_symtable_test.c
+++ b/src/unit-tests/osloader-test/ut_osloader_symtable_test.c
@@ -69,7 +69,7 @@ void UT_os_symbol_lookup_test()
     int32 res = 0;
     const char*    testDesc;
     cpuaddr        symbol_addr;
-    uint32         module_id = 0;
+    osal_id_t      module_id;
 
     /*-----------------------------------------------------*/
     testDesc = "API Not implemented";
diff --git a/src/unit-tests/osloader-test/ut_osloader_test.c b/src/unit-tests/osloader-test/ut_osloader_test.c
index f3903a186..f3821e748 100644
--- a/src/unit-tests/osloader-test/ut_osloader_test.c
+++ b/src/unit-tests/osloader-test/ut_osloader_test.c
@@ -60,7 +60,7 @@
 
 void UtTest_Setup(void)
 {
-    uint32 fs_id;
+    osal_id_t fs_id;
 
     if (OS_API_Init() != OS_SUCCESS)
     {
diff --git a/src/unit-tests/ostimer-test/ut_ostimer_test.c b/src/unit-tests/ostimer-test/ut_ostimer_test.c
index 3cb8c8bce..affb5a4b5 100644
--- a/src/unit-tests/ostimer-test/ut_ostimer_test.c
+++ b/src/unit-tests/ostimer-test/ut_ostimer_test.c
@@ -53,13 +53,13 @@ uint32  g_cbLoopCntMax = 5;
 uint32  g_toleranceVal = 0;
 uint32  g_timerFirst   = 0;
 int32   g_status  = 0;
-uint32  g_timerId = 0;
+osal_id_t  g_timerId;
 
 /*--------------------------------------------------------------------------------*
 ** Local function prototypes
 **--------------------------------------------------------------------------------*/
 
-void UT_os_timercallback(uint32 timerId);
+void UT_os_timercallback(osal_id_t timerId);
 
 void UT_os_init_timer_misc(void);
 void UT_os_setup_timercreate_test(void);
@@ -72,7 +72,7 @@ void UT_os_setup_timerset_test(void);
 ** Local function definitions
 **--------------------------------------------------------------------------------*/
 
-void UT_os_timercallback(uint32 timerId)
+void UT_os_timercallback(osal_id_t timerId)
 {
     int deltaTime = 0;
     static int32 loopCnt = 0, res = 0;
@@ -80,7 +80,7 @@ void UT_os_timercallback(uint32 timerId)
     static uint32 currIntervalTime = 0;
     static OS_time_t currTime = {0,0}, endTime = {0,0};
 
-    if (timerId == g_timerId)
+    if (OS_ObjectIdEqual(timerId, g_timerId))
     {
         if (g_timerFirst)
         {
diff --git a/src/unit-tests/ostimer-test/ut_ostimer_timerio_test.c b/src/unit-tests/ostimer-test/ut_ostimer_timerio_test.c
index 0e4dc6bc6..eb85d0048 100644
--- a/src/unit-tests/ostimer-test/ut_ostimer_timerio_test.c
+++ b/src/unit-tests/ostimer-test/ut_ostimer_timerio_test.c
@@ -49,20 +49,20 @@ extern uint32  g_cbLoopCntMax;
 extern uint32  g_toleranceVal;
 extern uint32  g_timerFirst;
 extern int32   g_status;
-extern uint32  g_timerId;
+extern osal_id_t  g_timerId;
 
 /*--------------------------------------------------------------------------------*
 ** External function prototypes
 **--------------------------------------------------------------------------------*/
 
-extern void UT_os_timercallback(uint32 timerId);
+extern void UT_os_timercallback(osal_id_t timerId);
 
 /*--------------------------------------------------------------------------------*
 ** Global variables
 **--------------------------------------------------------------------------------*/
 
 uint32  g_clkAccuracy = 0;
-uint32  g_timerIds[UT_OS_TIMER_LIST_LEN];
+osal_id_t  g_timerIds[UT_OS_TIMER_LIST_LEN];
 
 /*--------------------------------------------------------------------------------*
 ** Local function prototypes
@@ -343,7 +343,7 @@ void UT_os_timercreate_test()
     if (res == OS_SUCCESS)
     {
         if ((OS_TimerGetIdByName(&g_timerIds[8], g_timerNames[7]) == OS_SUCCESS) &&
-            (g_timerIds[7] == g_timerIds[8]) &&
+            OS_ObjectIdEqual(g_timerIds[7], g_timerIds[8]) &&
             (OS_TimerDelete(g_timerIds[7]) == OS_SUCCESS))
             UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
         else
@@ -409,7 +409,7 @@ void UT_os_timerdelete_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_TimerDelete(99999);
+    res = OS_TimerDelete(UT_OBJID_INCORRECT);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -419,7 +419,7 @@ void UT_os_timerdelete_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-id-arg";
 
-    if (OS_TimerDelete(99999) == OS_ERR_INVALID_ID)
+    if (OS_TimerDelete(UT_OBJID_INCORRECT) == OS_ERR_INVALID_ID)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -522,7 +522,7 @@ void UT_os_timerset_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_TimerSet(99999, startTime, intervalTime);
+    res = OS_TimerSet(UT_OBJID_INCORRECT, startTime, intervalTime);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -532,7 +532,7 @@ void UT_os_timerset_test()
     /*-----------------------------------------------------*/
     testDesc = "#1 Invalid-id-arg";
 
-    res = OS_TimerSet(99999, 10000, 10000);
+    res = OS_TimerSet(UT_OBJID_INCORRECT, 10000, 10000);
     if (res == OS_ERR_INVALID_ID)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
@@ -720,7 +720,7 @@ void UT_os_timergetidbyname_test()
     }
 
     res = OS_TimerGetIdByName(&g_timerIds[5], g_timerNames[4]);
-    if ((res == OS_SUCCESS) && (g_timerIds[4] == g_timerIds[5]))
+    if ((res == OS_SUCCESS) && OS_ObjectIdEqual(g_timerIds[4], g_timerIds[5]))
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
@@ -779,7 +779,7 @@ void UT_os_timergetinfo_test()
     /*-----------------------------------------------------*/
     testDesc = "API not implemented";
 
-    res = OS_TimerGetInfo(99999, &timerProps);
+    res = OS_TimerGetInfo(UT_OBJID_INCORRECT, &timerProps);
     if (res == OS_ERR_NOT_IMPLEMENTED)
     {
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_NA);
@@ -809,7 +809,7 @@ void UT_os_timergetinfo_test()
     /*-----------------------------------------------------*/
     testDesc = "#2 Invalid-id-arg";
 
-    if (OS_TimerGetInfo(99999, &timerProps) == OS_ERR_INVALID_ID)
+    if (OS_TimerGetInfo(UT_OBJID_INCORRECT, &timerProps) == OS_ERR_INVALID_ID)
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_PASS);
     else
         UT_OS_TEST_RESULT( testDesc, UTASSERT_CASETYPE_FAILURE);
diff --git a/src/ut-stubs/osapi-utstub-binsem.c b/src/ut-stubs/osapi-utstub-binsem.c
index ea0cccd42..dc19b7b96 100644
--- a/src/ut-stubs/osapi-utstub-binsem.c
+++ b/src/ut-stubs/osapi-utstub-binsem.c
@@ -53,7 +53,7 @@ UT_DEFAULT_STUB(OS_BinSemAPI_Init,(void))
 **        Returns either -1 or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_BinSemTake(uint32 sem_id)
+int32 OS_BinSemTake(osal_id_t sem_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_BinSemTake), sem_id);
 
@@ -83,7 +83,7 @@ int32 OS_BinSemTake(uint32 sem_id)
 **        Returns OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_BinSemFlush(uint32 sem_id)
+int32 OS_BinSemFlush(osal_id_t sem_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_BinSemFlush), sem_id);
 
@@ -117,7 +117,7 @@ int32 OS_BinSemFlush(uint32 sem_id)
 **        Returns either a user-defined status flag, OS_ERROR, or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_BinSemCreate(uint32 *sem_id, const char *sem_name,
+int32 OS_BinSemCreate(osal_id_t *sem_id, const char *sem_name,
                       uint32 sem_initial_value, uint32 options)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_BinSemCreate), sem_id);
@@ -135,7 +135,7 @@ int32 OS_BinSemCreate(uint32 *sem_id, const char *sem_name,
     }
     else
     {
-        *sem_id = 0xDEADBEEFU;
+        *sem_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
     return status;
@@ -157,7 +157,7 @@ int32 OS_BinSemCreate(uint32 *sem_id, const char *sem_name,
 **        Returns the user-defined value UT_BinSemFail.
 **
 ******************************************************************************/
-int32 OS_BinSemGive(uint32 sem_id)
+int32 OS_BinSemGive(osal_id_t sem_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_BinSemGive), sem_id);
 
@@ -184,7 +184,7 @@ int32 OS_BinSemGive(uint32 sem_id)
 **        Returns OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_BinSemGetInfo(uint32 sem_id, OS_bin_sem_prop_t *bin_prop)
+int32 OS_BinSemGetInfo(osal_id_t sem_id, OS_bin_sem_prop_t *bin_prop)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_BinSemGetInfo), sem_id);
     UT_Stub_RegisterContext(UT_KEY(OS_BinSemGetInfo), bin_prop);
@@ -196,8 +196,7 @@ int32 OS_BinSemGetInfo(uint32 sem_id, OS_bin_sem_prop_t *bin_prop)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_BinSemGetInfo), bin_prop, sizeof(*bin_prop)) < sizeof(*bin_prop))
     {
-        bin_prop->creator =  1;
-        UT_FIXUP_ID(bin_prop->creator, UT_OBJTYPE_TASK);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TASK, &bin_prop->creator);
         strncpy(bin_prop->name, "Name", OS_MAX_API_NAME - 1);
         bin_prop->name[OS_MAX_API_NAME - 1] = '\0';
     }
@@ -226,7 +225,7 @@ int32 OS_BinSemGetInfo(uint32 sem_id, OS_bin_sem_prop_t *bin_prop)
 **        Returns either a user-defined status flag or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_BinSemDelete(uint32 sem_id)
+int32 OS_BinSemDelete(osal_id_t sem_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_BinSemDelete), sem_id);
 
@@ -261,7 +260,7 @@ int32 OS_BinSemDelete(uint32 sem_id)
 **        Returns OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_BinSemTimedWait(uint32 sem_id, uint32 msecs)
+int32 OS_BinSemTimedWait(osal_id_t sem_id, uint32 msecs)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_BinSemTimedWait), sem_id);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_BinSemTimedWait), msecs);
@@ -278,7 +277,7 @@ int32 OS_BinSemTimedWait(uint32 sem_id, uint32 msecs)
  * Stub function for OS_BinSemGetIdByName()
  *
  *****************************************************************************/
-int32 OS_BinSemGetIdByName (uint32 *sem_id, const char *sem_name)
+int32 OS_BinSemGetIdByName (osal_id_t *sem_id, const char *sem_name)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_BinSemGetIdByName), sem_id);
     UT_Stub_RegisterContext(UT_KEY(OS_BinSemGetIdByName), sem_name);
@@ -290,8 +289,7 @@ int32 OS_BinSemGetIdByName (uint32 *sem_id, const char *sem_name)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_BinSemGetIdByName), sem_id, sizeof(*sem_id)) < sizeof(*sem_id))
     {
-        *sem_id =  1;
-        UT_FIXUP_ID(*sem_id, UT_OBJTYPE_BINSEM);
+        UT_ObjIdCompose(1, UT_OBJTYPE_BINSEM, sem_id);
     }
 
     return status;
diff --git a/src/ut-stubs/osapi-utstub-countsem.c b/src/ut-stubs/osapi-utstub-countsem.c
index b13485490..048fc2c44 100644
--- a/src/ut-stubs/osapi-utstub-countsem.c
+++ b/src/ut-stubs/osapi-utstub-countsem.c
@@ -42,7 +42,7 @@ UT_DEFAULT_STUB(OS_CountSemAPI_Init,(void))
  * Stub function for OS_CountSemCreate()
  *
  *****************************************************************************/
-int32 OS_CountSemCreate(uint32 *sem_id, const char *sem_name,
+int32 OS_CountSemCreate(osal_id_t *sem_id, const char *sem_name,
                       uint32 sem_initial_value, uint32 options)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_CountSemCreate), sem_id);
@@ -60,7 +60,7 @@ int32 OS_CountSemCreate(uint32 *sem_id, const char *sem_name,
     }
     else
     {
-        *sem_id = 0xDEADBEEFU;
+        *sem_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
     return status;
@@ -86,7 +86,7 @@ int32 OS_CountSemCreate(uint32 *sem_id, const char *sem_name,
 **        Returns either a user-defined status flag or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_CountSemDelete(uint32 sem_id)
+int32 OS_CountSemDelete(osal_id_t sem_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_CountSemDelete), sem_id);
 
@@ -108,7 +108,7 @@ int32 OS_CountSemDelete(uint32 sem_id)
  * Stub for OS_CountSemGive() function
  *
  *****************************************************************************/
-int32 OS_CountSemGive ( uint32 sem_id )
+int32 OS_CountSemGive ( osal_id_t sem_id )
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_CountSemGive), sem_id);
 
@@ -124,7 +124,7 @@ int32 OS_CountSemGive ( uint32 sem_id )
  * Stub for OS_CountSemTake() function
  *
  *****************************************************************************/
-int32 OS_CountSemTake ( uint32 sem_id )
+int32 OS_CountSemTake ( osal_id_t sem_id )
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_CountSemTake), sem_id);
 
@@ -140,7 +140,7 @@ int32 OS_CountSemTake ( uint32 sem_id )
  * Stub for OS_CountSemTimedWait() function
  *
  *****************************************************************************/
-int32 OS_CountSemTimedWait ( uint32 sem_id, uint32 msecs )
+int32 OS_CountSemTimedWait ( osal_id_t sem_id, uint32 msecs )
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_CountSemTimedWait), sem_id);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_CountSemTimedWait), msecs);
@@ -157,7 +157,7 @@ int32 OS_CountSemTimedWait ( uint32 sem_id, uint32 msecs )
  * Stub for OS_CountSemGetIdByName() function
  *
  *****************************************************************************/
-int32 OS_CountSemGetIdByName (uint32 *sem_id, const char *sem_name)
+int32 OS_CountSemGetIdByName (osal_id_t *sem_id, const char *sem_name)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_CountSemGetIdByName), sem_id);
     UT_Stub_RegisterContext(UT_KEY(OS_CountSemGetIdByName), sem_name);
@@ -169,8 +169,7 @@ int32 OS_CountSemGetIdByName (uint32 *sem_id, const char *sem_name)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_CountSemGetIdByName), sem_id, sizeof(*sem_id)) < sizeof(*sem_id))
     {
-        *sem_id =  1;
-        UT_FIXUP_ID(*sem_id, UT_OBJTYPE_COUNTSEM);
+        UT_ObjIdCompose(1, UT_OBJTYPE_COUNTSEM, sem_id);
     }
 
     return status;
@@ -192,7 +191,7 @@ int32 OS_CountSemGetIdByName (uint32 *sem_id, const char *sem_name)
 **        Returns OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_CountSemGetInfo(uint32 sem_id, OS_count_sem_prop_t *count_prop)
+int32 OS_CountSemGetInfo(osal_id_t sem_id, OS_count_sem_prop_t *count_prop)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_CountSemGetInfo), sem_id);
     UT_Stub_RegisterContext(UT_KEY(OS_CountSemGetInfo), count_prop);
@@ -204,8 +203,7 @@ int32 OS_CountSemGetInfo(uint32 sem_id, OS_count_sem_prop_t *count_prop)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_CountSemGetInfo), count_prop, sizeof(*count_prop)) < sizeof(*count_prop))
     {
-        count_prop->creator = 1;
-        UT_FIXUP_ID(count_prop->creator, UT_OBJTYPE_TASK);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TASK, &count_prop->creator);
         strncpy(count_prop->name, "Name", OS_MAX_API_NAME - 1);
         count_prop->name[OS_MAX_API_NAME - 1] = '\0';
     }
diff --git a/src/ut-stubs/osapi-utstub-dir.c b/src/ut-stubs/osapi-utstub-dir.c
index e4dc958dc..5268e2bae 100644
--- a/src/ut-stubs/osapi-utstub-dir.c
+++ b/src/ut-stubs/osapi-utstub-dir.c
@@ -77,7 +77,7 @@ int32  OS_rmdir (const char *path)
  * Stub for OS_DirectoryOpen() function
  *
  *****************************************************************************/
-int32 OS_DirectoryOpen(uint32 *dir_id, const char *path)
+int32 OS_DirectoryOpen(osal_id_t *dir_id, const char *path)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_DirectoryOpen), dir_id);
     UT_Stub_RegisterContext(UT_KEY(OS_DirectoryOpen), path);
@@ -92,7 +92,7 @@ int32 OS_DirectoryOpen(uint32 *dir_id, const char *path)
     }
     else
     {
-        *dir_id = 0xDEADBEEFU;
+        *dir_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
 
@@ -104,7 +104,7 @@ int32 OS_DirectoryOpen(uint32 *dir_id, const char *path)
  * Stub for OS_DirectoryClose() function
  *
  *****************************************************************************/
-int32 OS_DirectoryClose(uint32 dir_id)
+int32 OS_DirectoryClose(osal_id_t dir_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_DirectoryClose), dir_id);
 
@@ -125,7 +125,7 @@ int32 OS_DirectoryClose(uint32 dir_id)
  * Stub for OS_DirectoryRewind() function
  *
  *****************************************************************************/
-int32 OS_DirectoryRewind(uint32 dir_id)
+int32 OS_DirectoryRewind(osal_id_t dir_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_DirectoryRewind), dir_id);
 
@@ -141,7 +141,7 @@ int32 OS_DirectoryRewind(uint32 dir_id)
  * Stub for OS_DirectoryRead() function
  *
  *****************************************************************************/
-int32 OS_DirectoryRead(uint32 dir_id, os_dirent_t *dirent)
+int32 OS_DirectoryRead(osal_id_t dir_id, os_dirent_t *dirent)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_DirectoryRead), dir_id);
     UT_Stub_RegisterContext(UT_KEY(OS_DirectoryRead), dirent);
diff --git a/src/ut-stubs/osapi-utstub-file.c b/src/ut-stubs/osapi-utstub-file.c
index 719cec567..f9b933c87 100644
--- a/src/ut-stubs/osapi-utstub-file.c
+++ b/src/ut-stubs/osapi-utstub-file.c
@@ -117,14 +117,15 @@ int32 OS_creat(const char *path, int32 access)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_creat), path);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_creat), access);
-
+    osal_id_t objid;
     int32 status;
 
     status = UT_DEFAULT_IMPL(OS_creat);
 
     if (status == OS_SUCCESS)
     {
-        status = UT_AllocStubObjId(UT_OBJTYPE_FILESTREAM);
+        objid = UT_AllocStubObjId(UT_OBJTYPE_FILESTREAM);
+        status = OS_ObjectIdToInteger(objid);
     }
 
    return status;
@@ -140,14 +141,41 @@ int32 OS_open(const char *path, int32 access, uint32 mode)
     UT_Stub_RegisterContext(UT_KEY(OS_open), path);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_open), access);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_open), mode);
-
+    osal_id_t objid;
     int32 status;
 
     status = UT_DEFAULT_IMPL(OS_open);
 
     if (status == OS_SUCCESS)
     {
-        status = UT_AllocStubObjId(UT_OBJTYPE_FILESTREAM);
+        objid = UT_AllocStubObjId(UT_OBJTYPE_FILESTREAM);
+        status = OS_ObjectIdToInteger(objid);
+    }
+
+    return status;
+}
+
+/*****************************************************************************
+ *
+ * Stub function for OS_OpenCreate()
+ *
+ *****************************************************************************/
+int32 OS_OpenCreate(osal_id_t *filedes, const char *path, int32 flags, int32 access)
+{
+    UT_Stub_RegisterContext(UT_KEY(OS_OpenCreate), filedes);
+    UT_Stub_RegisterContext(UT_KEY(OS_OpenCreate), path);
+    UT_Stub_RegisterContextGenericArg(UT_KEY(OS_OpenCreate), flags);
+    UT_Stub_RegisterContextGenericArg(UT_KEY(OS_OpenCreate), access);
+    int32 status;
+
+    status = UT_DEFAULT_IMPL(OS_OpenCreate);
+    if (status == OS_SUCCESS)
+    {
+        *filedes = UT_AllocStubObjId(UT_OBJTYPE_FILESTREAM);
+    }
+    else
+    {
+        *filedes = UT_STUB_FAKE_OBJECT_ID;
     }
 
     return status;
@@ -159,7 +187,7 @@ int32 OS_open(const char *path, int32 access, uint32 mode)
  * Stub function for OS_close()
  *
  *****************************************************************************/
-int32 OS_close(uint32 filedes)
+int32 OS_close(osal_id_t filedes)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_close), filedes);
 
@@ -180,7 +208,7 @@ int32 OS_close(uint32 filedes)
  * Stub function for OS_StreamRead()
  *
  *****************************************************************************/
-int32 OS_StreamRead(uint32  filedes, void *buffer, uint32 nbytes, int32 timeout)
+int32 OS_StreamRead(osal_id_t  filedes, void *buffer, uint32 nbytes, int32 timeout)
 {
     return UT_GenericReadStub(__func__,UT_KEY(OS_StreamRead),buffer,nbytes);
 }
@@ -190,7 +218,7 @@ int32 OS_StreamRead(uint32  filedes, void *buffer, uint32 nbytes, int32 timeout)
  * Stub function for OS_StreamWrite()
  *
  *****************************************************************************/
-int32 OS_StreamWrite(uint32  filedes, const void *buffer, uint32 nbytes, int32 timeout)
+int32 OS_StreamWrite(osal_id_t  filedes, const void *buffer, uint32 nbytes, int32 timeout)
 {
     return UT_GenericWriteStub(__func__,UT_KEY(OS_StreamWrite),buffer,nbytes);
 }
@@ -200,7 +228,7 @@ int32 OS_StreamWrite(uint32  filedes, const void *buffer, uint32 nbytes, int32 t
  * Stub function for OS_read()
  *
  *****************************************************************************/
-int32 OS_read(uint32 filedes, void *buffer, uint32 nbytes)
+int32 OS_read(osal_id_t filedes, void *buffer, uint32 nbytes)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_read), filedes);
     UT_Stub_RegisterContext(UT_KEY(OS_read), buffer);
@@ -214,7 +242,7 @@ int32 OS_read(uint32 filedes, void *buffer, uint32 nbytes)
  * Stub function for OS_write()
  *
  *****************************************************************************/
-int32 OS_write(uint32 filedes, const void *buffer, uint32 nbytes)
+int32 OS_write(osal_id_t filedes, const void *buffer, uint32 nbytes)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_write), filedes);
     UT_Stub_RegisterContext(UT_KEY(OS_write), buffer);
@@ -228,7 +256,7 @@ int32 OS_write(uint32 filedes, const void *buffer, uint32 nbytes)
  * Stub function for OS_TimedRead()
  *
  *****************************************************************************/
-int32 OS_TimedRead(uint32  filedes, void *buffer, uint32 nbytes, int32 timeout)
+int32 OS_TimedRead(osal_id_t  filedes, void *buffer, uint32 nbytes, int32 timeout)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimedRead), filedes);
     UT_Stub_RegisterContext(UT_KEY(OS_TimedRead), buffer);
@@ -243,7 +271,7 @@ int32 OS_TimedRead(uint32  filedes, void *buffer, uint32 nbytes, int32 timeout)
  * Stub function for OS_TimedWrite()
  *
  *****************************************************************************/
-int32 OS_TimedWrite(uint32  filedes, const void *buffer, uint32 nbytes, int32 timeout)
+int32 OS_TimedWrite(osal_id_t  filedes, const void *buffer, uint32 nbytes, int32 timeout)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimedWrite), filedes);
     UT_Stub_RegisterContext(UT_KEY(OS_TimedWrite), buffer);
@@ -298,7 +326,7 @@ int32 OS_stat   (const char *path, os_fstat_t *filestats)
  * Stub function for OS_lseek()
  *
  *****************************************************************************/
-int32 OS_lseek(uint32 filedes, int32 offset, uint32 whence)
+int32 OS_lseek(osal_id_t filedes, int32 offset, uint32 whence)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_lseek), filedes);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_lseek), offset);
@@ -384,7 +412,7 @@ int32 OS_mv (const char *src, const char *dest)
  * Stub function for OS_FDGetInfo()
  *
  *****************************************************************************/
-int32 OS_FDGetInfo (uint32 filedes, OS_file_prop_t *fd_prop)
+int32 OS_FDGetInfo (osal_id_t filedes, OS_file_prop_t *fd_prop)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_FDGetInfo), filedes);
     UT_Stub_RegisterContext(UT_KEY(OS_FDGetInfo), fd_prop);
@@ -402,8 +430,7 @@ int32 OS_FDGetInfo (uint32 filedes, OS_file_prop_t *fd_prop)
         {
             memset(fd_prop, 0, sizeof(*fd_prop));
             fd_prop->IsValid = true;
-            fd_prop->User = 1;
-            UT_FIXUP_ID(fd_prop->User, UT_OBJTYPE_TASK);
+            UT_ObjIdCompose(1, UT_OBJTYPE_TASK, &fd_prop->User);
         }
     }
 
@@ -462,7 +489,7 @@ int32 OS_CloseAllFiles(void)
  * Stub function for OS_ShellOutputToFile()
  *
  *****************************************************************************/
-int32 OS_ShellOutputToFile(const char* Cmd, uint32 filedes)
+int32 OS_ShellOutputToFile(const char* Cmd, osal_id_t filedes)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_ShellOutputToFile), Cmd);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_ShellOutputToFile), filedes);
diff --git a/src/ut-stubs/osapi-utstub-filesys.c b/src/ut-stubs/osapi-utstub-filesys.c
index 4e09777f5..ba14917f4 100644
--- a/src/ut-stubs/osapi-utstub-filesys.c
+++ b/src/ut-stubs/osapi-utstub-filesys.c
@@ -43,7 +43,7 @@ UT_DEFAULT_STUB(OS_FileSysAPI_Init,(void))
  * Stub function for OS_FileSysAddFixedMap()
  *
  *****************************************************************************/
-int32           OS_FileSysAddFixedMap(uint32 *filesys_id, const char *phys_path,
+int32           OS_FileSysAddFixedMap(osal_id_t *filesys_id, const char *phys_path,
                                 const char *virt_path)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_FileSysAddFixedMap), filesys_id);
@@ -60,7 +60,7 @@ int32           OS_FileSysAddFixedMap(uint32 *filesys_id, const char *phys_path,
     }
     else
     {
-        *filesys_id = 0xDEADBEEFU;
+        *filesys_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
 
diff --git a/src/ut-stubs/osapi-utstub-idmap.c b/src/ut-stubs/osapi-utstub-idmap.c
index d014328bd..460d0befb 100644
--- a/src/ut-stubs/osapi-utstub-idmap.c
+++ b/src/ut-stubs/osapi-utstub-idmap.c
@@ -99,9 +99,10 @@ uint32 OS_GetBaseForObjectType(uint32 idtype)
  * Stub function for OS_ObjectIdToArrayIndex()
  *
  *****************************************************************************/
-int32 OS_ObjectIdToArrayIndex(uint32 idtype, uint32 id, uint32 *ArrayIndex)
+int32 OS_ObjectIdToArrayIndex(uint32 idtype, osal_id_t id, uint32 *ArrayIndex)
 {
     int32 Status;
+    UT_ObjType_t checktype;
 
     Status = UT_DEFAULT_IMPL(OS_ObjectIdToArrayIndex);
 
@@ -109,7 +110,7 @@ int32 OS_ObjectIdToArrayIndex(uint32 idtype, uint32 id, uint32 *ArrayIndex)
             UT_Stub_CopyToLocal(UT_KEY(OS_ObjectIdToArrayIndex), ArrayIndex, sizeof(*ArrayIndex)) < sizeof(*ArrayIndex))
     {
         /* this needs to output something valid or code will break */
-        *ArrayIndex = id & 0xFFFF;
+        UT_ObjIdDecompose(id, ArrayIndex, &checktype);
     }
 
     return Status;
@@ -120,7 +121,7 @@ int32 OS_ObjectIdToArrayIndex(uint32 idtype, uint32 id, uint32 *ArrayIndex)
  * Stub function for OS_ObjectIdFinalize()
  *
  *****************************************************************************/
-int32 OS_ObjectIdFinalizeNew(int32 operation_status, OS_common_record_t *record, uint32 *outid)
+int32 OS_ObjectIdFinalizeNew(int32 operation_status, OS_common_record_t *record, osal_id_t *outid)
 {
     int32 Status;
 
@@ -172,8 +173,7 @@ int32 OS_ObjectIdGetBySearch(OS_lock_mode_t lock_mode, uint32 idtype, OS_ObjectM
             UT_Stub_CopyToLocal(UT_KEY(OS_ObjectIdGetBySearch), record, sizeof(*record)) < sizeof(*record))
     {
         memset(&fake_record, 0, sizeof(fake_record));
-        fake_record.active_id = 1;
-        UT_FIXUP_ID(fake_record.active_id, idtype);
+        UT_ObjIdCompose(1, idtype, &fake_record.active_id);
         *record = &fake_record;
     }
 
@@ -182,10 +182,10 @@ int32 OS_ObjectIdGetBySearch(OS_lock_mode_t lock_mode, uint32 idtype, OS_ObjectM
 
 /*****************************************************************************
  *
- * Stub function for OS_ObjectIdFindByName()
+ * Stub function for OS_ObjectIdFindByName(, &fake_record.active_id)
  *
  *****************************************************************************/
-int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, uint32 *object_id)
+int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, osal_id_t *object_id)
 {
     int32 Status;
 
@@ -199,8 +199,7 @@ int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, uint32 *object_id)
     if (Status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_ObjectIdFindByName), object_id, sizeof(*object_id)) < sizeof(*object_id))
     {
-        *object_id = 1;
-        UT_FIXUP_ID(*object_id, idtype);
+        UT_ObjIdCompose(1, idtype, object_id);
     }
 
     return Status;
@@ -208,7 +207,7 @@ int32 OS_ObjectIdFindByName (uint32 idtype, const char *name, uint32 *object_id)
 
 /*****************************************************************************
  *
- * Stub function for OS_ObjectIdGetByName()
+ * Stub function for OS_ObjectIdGetByName(,object_id)
  *
  *****************************************************************************/
 int32 OS_ObjectIdGetByName (OS_lock_mode_t lock_mode, uint32 idtype, const char *name, OS_common_record_t **record)
@@ -224,9 +223,8 @@ int32 OS_ObjectIdGetByName (OS_lock_mode_t lock_mode, uint32 idtype, const char
         if (UT_Stub_CopyToLocal(UT_KEY(OS_ObjectIdGetByName), &local_record, sizeof(local_record)) < sizeof(local_record))
         {
             memset(&fake_record, 0, sizeof(fake_record));
-            fake_record.active_id = 1;
             local_record = &fake_record;
-            UT_FIXUP_ID(fake_record.active_id, idtype);
+            UT_ObjIdCompose(1, idtype, &fake_record.active_id);
         }
 
         /* this needs to output something valid or code will break */
@@ -241,13 +239,14 @@ int32 OS_ObjectIdGetByName (OS_lock_mode_t lock_mode, uint32 idtype, const char
 
 /*****************************************************************************
  *
- * Stub function for OS_ObjectIdGetById()
+ * Stub function for OS_ObjectIdGetById(, &fake_record.active_id)
  *
  *****************************************************************************/
-int32 OS_ObjectIdGetById(OS_lock_mode_t check_mode, uint32 idtype, uint32 id, uint32 *array_index, OS_common_record_t **record)
+int32 OS_ObjectIdGetById(OS_lock_mode_t check_mode, uint32 idtype, osal_id_t id, uint32 *array_index, OS_common_record_t **record)
 {
     int32 Status;
     uint32 local_id;
+    UT_ObjType_t checktype;
     OS_common_record_t *local_record;
     static OS_common_record_t fake_record;
 
@@ -257,7 +256,7 @@ int32 OS_ObjectIdGetById(OS_lock_mode_t check_mode, uint32 idtype, uint32 id, ui
     {
         if (UT_Stub_CopyToLocal(UT_KEY(OS_ObjectIdGetById), &local_id, sizeof(local_id)) < sizeof(local_id))
         {
-            local_id = id & 0xFFFF;
+            UT_ObjIdDecompose(id, &local_id, &checktype);
         }
 
         if (UT_Stub_CopyToLocal(UT_KEY(OS_ObjectIdGetById), &local_record, sizeof(local_record)) < sizeof(local_record))
@@ -325,8 +324,7 @@ int32 OS_ObjectIdGetNext(uint32 idtype, uint32 *curr_index, OS_common_record_t *
             if (UT_Stub_CopyToLocal(UT_KEY(OS_ObjectIdGetNext), &local_record, sizeof(local_record)) < sizeof(local_record))
             {
                 memset(&fake_record, 0, sizeof(fake_record));
-                fake_record.active_id = local_id;
-                UT_FIXUP_ID(fake_record.active_id, idtype);
+                UT_ObjIdCompose(local_id, idtype, &fake_record.active_id);
                 local_record = &fake_record;
             }
 
@@ -347,7 +345,7 @@ int32 OS_ObjectIdGetNext(uint32 idtype, uint32 *curr_index, OS_common_record_t *
 
 /*****************************************************************************
  *
- * Stub function for OS_ObjectIdAllocateNew()
+ * Stub function for OS_ObjectIdAllocateNew(, &fake_record.active_id)
  *
  *****************************************************************************/
 int32 OS_ObjectIdAllocateNew(uint32 idtype, const char *name, uint32 *array_index, OS_common_record_t **record)
@@ -369,8 +367,7 @@ int32 OS_ObjectIdAllocateNew(uint32 idtype, const char *name, uint32 *array_inde
         if (UT_Stub_CopyToLocal(UT_KEY(OS_ObjectIdAllocateNew), &local_record, sizeof(local_record)) < sizeof(local_record))
         {
             memset(&fake_record, 0, sizeof(fake_record));
-            fake_record.active_id = local_id;
-            UT_FIXUP_ID(fake_record.active_id, idtype);
+            UT_ObjIdCompose(local_id, idtype, &fake_record.active_id);
             local_record = &fake_record;
         }
 
@@ -389,7 +386,7 @@ int32 OS_ObjectIdAllocateNew(uint32 idtype, const char *name, uint32 *array_inde
 
     returns: status
 ---------------------------------------------------------------------------------------*/
-int32 OS_GetResourceName(uint32 object_id, char *buffer, uint32 buffer_size)
+int32 OS_GetResourceName(osal_id_t object_id, char *buffer, uint32 buffer_size)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_GetResourceName), object_id);
     UT_Stub_RegisterContext(UT_KEY(OS_GetResourceName), buffer);
@@ -422,7 +419,7 @@ int32 OS_GetResourceName(uint32 object_id, char *buffer, uint32 buffer_size)
 
     returns: status
 ---------------------------------------------------------------------------------------*/
-int32 OS_ConvertToArrayIndex(uint32 object_id, uint32 *ArrayIndex)
+int32 OS_ConvertToArrayIndex(osal_id_t object_id, uint32 *ArrayIndex)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_ConvertToArrayIndex), object_id);
     UT_Stub_RegisterContext(UT_KEY(OS_ConvertToArrayIndex), ArrayIndex);
@@ -433,9 +430,8 @@ int32 OS_ConvertToArrayIndex(uint32 object_id, uint32 *ArrayIndex)
 
    if (return_code == OS_SUCCESS)
    {
-       uint32 ObjType = (object_id >> 16) ^ 0x4000U;
-
-       *ArrayIndex = object_id & 0xFFFFU;
+       UT_ObjType_t ObjType;
+       UT_ObjIdDecompose(object_id, ArrayIndex, &ObjType);
        if (ObjType != UT_OBJTYPE_NONE && ObjType < UT_OBJTYPE_MAX)
        {
            *ArrayIndex %= UT_MAXOBJS[ObjType];
@@ -460,14 +456,14 @@ int32 OS_ConvertToArrayIndex(uint32 object_id, uint32 *ArrayIndex)
 
     returns: None
 ---------------------------------------------------------------------------------------*/
-void OS_ForEachObjectOfType     (uint32 objtype, uint32 creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg)
+void OS_ForEachObjectOfType     (uint32 objtype, osal_id_t creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_ForEachObjectOfType), objtype);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_ForEachObjectOfType), creator_id);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_ForEachObjectOfType), callback_ptr);
     UT_Stub_RegisterContext(UT_KEY(OS_ForEachObjectOfType), callback_arg);
 
-    uint32 NextId;
+    osal_id_t NextId;
     uint32 IdSize;
 
     /* Although this is "void", Invoke the default impl to log it and invoke any hooks */
@@ -492,13 +488,13 @@ void OS_ForEachObjectOfType     (uint32 objtype, uint32 creator_id, OS_ArgCallba
 
     returns: None
 ---------------------------------------------------------------------------------------*/
-void OS_ForEachObject (uint32 creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg)
+void OS_ForEachObject (osal_id_t creator_id, OS_ArgCallback_t callback_ptr, void *callback_arg)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_ForEachObject), creator_id);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_ForEachObject), callback_ptr);
     UT_Stub_RegisterContext(UT_KEY(OS_ForEachObject), callback_arg);
 
-    uint32 NextId;
+    osal_id_t NextId;
     uint32 IdSize;
 
     /* Although this is "void", Invoke the default impl to log it and invoke any hooks */
@@ -522,13 +518,17 @@ void OS_ForEachObject (uint32 creator_id, OS_ArgCallback_t callback_ptr, void *c
 
    returns: The type of object that the ID represents
 ---------------------------------------------------------------------------------------*/
-uint32 OS_IdentifyObject       (uint32 object_id)
+uint32 OS_IdentifyObject       (osal_id_t object_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_IdentifyObject), object_id);
 
+    UT_ObjType_t ObjType;
+    uint32 checkindx;
     int32 DefaultType;
 
-    switch ((object_id >> 16) ^ 0x4000U)
+    UT_ObjIdDecompose(object_id, &checkindx, &ObjType);
+
+    switch (ObjType)
     {
     case UT_OBJTYPE_TASK:
         DefaultType = OS_OBJECT_TYPE_OS_TASK;
diff --git a/src/ut-stubs/osapi-utstub-module.c b/src/ut-stubs/osapi-utstub-module.c
index 8112f9595..08102b221 100644
--- a/src/ut-stubs/osapi-utstub-module.c
+++ b/src/ut-stubs/osapi-utstub-module.c
@@ -83,7 +83,7 @@ int32 dummy_function(void)
 **        Returns either a user-defined status flag or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_ModuleLoad(uint32 *module_id, const char *module_name, const char *filename)
+int32 OS_ModuleLoad(osal_id_t *module_id, const char *module_name, const char *filename)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_ModuleLoad), module_id);
     UT_Stub_RegisterContext(UT_KEY(OS_ModuleLoad), module_name);
@@ -99,7 +99,7 @@ int32 OS_ModuleLoad(uint32 *module_id, const char *module_name, const char *file
     }
     else
     {
-        *module_id = 0xDEADBEEFU;
+        *module_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
     return status;
@@ -125,7 +125,7 @@ int32 OS_ModuleLoad(uint32 *module_id, const char *module_name, const char *file
 **        Returns either a user-defined status flag or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_ModuleUnload(uint32 module_id)
+int32 OS_ModuleUnload(osal_id_t module_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_ModuleUnload), module_id);
 
@@ -161,7 +161,7 @@ int32 OS_ModuleUnload(uint32 module_id)
 **        Returns either a user-defined status flag or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_ModuleInfo(uint32 module_id, OS_module_prop_t *module_info)
+int32 OS_ModuleInfo(osal_id_t module_id, OS_module_prop_t *module_info)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_ModuleInfo), module_id);
     UT_Stub_RegisterContext(UT_KEY(OS_ModuleInfo), module_info);
diff --git a/src/ut-stubs/osapi-utstub-mutex.c b/src/ut-stubs/osapi-utstub-mutex.c
index c9a049a3c..e475243e0 100644
--- a/src/ut-stubs/osapi-utstub-mutex.c
+++ b/src/ut-stubs/osapi-utstub-mutex.c
@@ -59,7 +59,7 @@ UT_DEFAULT_STUB(OS_MutexAPI_Init,(void))
 **        Returns either a user-defined status flag, OS_ERROR, or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_MutSemCreate(uint32 *sem_id, const char *sem_name, uint32 options)
+int32 OS_MutSemCreate(osal_id_t *sem_id, const char *sem_name, uint32 options)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_MutSemCreate), sem_id);
     UT_Stub_RegisterContext(UT_KEY(OS_MutSemCreate), sem_name);
@@ -75,7 +75,7 @@ int32 OS_MutSemCreate(uint32 *sem_id, const char *sem_name, uint32 options)
     }
     else
     {
-        *sem_id = 0xDEADBEEFU;
+        *sem_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
     return status;
@@ -101,7 +101,7 @@ int32 OS_MutSemCreate(uint32 *sem_id, const char *sem_name, uint32 options)
 **        Returns either a user-defined status flag or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_MutSemDelete(uint32 sem_id)
+int32 OS_MutSemDelete(osal_id_t sem_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_MutSemDelete), sem_id);
 
@@ -137,7 +137,7 @@ int32 OS_MutSemDelete(uint32 sem_id)
 **        Returns either a user-defined status flag or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_MutSemGive(uint32 sem_id)
+int32 OS_MutSemGive(osal_id_t sem_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_MutSemGive), sem_id);
 
@@ -168,7 +168,7 @@ int32 OS_MutSemGive(uint32 sem_id)
 **        Returns either a user-defined status flag or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_MutSemTake(uint32 sem_id)
+int32 OS_MutSemTake(osal_id_t sem_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_MutSemTake), sem_id);
 
@@ -184,7 +184,7 @@ int32 OS_MutSemTake(uint32 sem_id)
  * Stub function for OS_MutSemGetIdByName()
  *
  *****************************************************************************/
-int32 OS_MutSemGetIdByName (uint32 *sem_id, const char *sem_name)
+int32 OS_MutSemGetIdByName (osal_id_t *sem_id, const char *sem_name)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_MutSemGetIdByName), sem_id);
     UT_Stub_RegisterContext(UT_KEY(OS_MutSemGetIdByName), sem_name);
@@ -196,8 +196,7 @@ int32 OS_MutSemGetIdByName (uint32 *sem_id, const char *sem_name)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_MutSemGetIdByName), sem_id, sizeof(*sem_id)) < sizeof(*sem_id))
     {
-        *sem_id =  1;
-        UT_FIXUP_ID(*sem_id, UT_OBJTYPE_MUTEX);
+        UT_ObjIdCompose(1, UT_OBJTYPE_MUTEX, sem_id);
     }
 
     return status;
@@ -220,7 +219,7 @@ int32 OS_MutSemGetIdByName (uint32 *sem_id, const char *sem_name)
 **        Returns OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_MutSemGetInfo(uint32 sem_id, OS_mut_sem_prop_t *mut_prop)
+int32 OS_MutSemGetInfo(osal_id_t sem_id, OS_mut_sem_prop_t *mut_prop)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_MutSemGetInfo), sem_id);
     UT_Stub_RegisterContext(UT_KEY(OS_MutSemGetInfo), mut_prop);
@@ -234,8 +233,7 @@ int32 OS_MutSemGetInfo(uint32 sem_id, OS_mut_sem_prop_t *mut_prop)
     {
         strncpy(mut_prop->name, "Name", OS_MAX_API_NAME - 1);
         mut_prop->name[OS_MAX_API_NAME - 1] = '\0';
-        mut_prop->creator =  1;
-        UT_FIXUP_ID(mut_prop->creator, UT_OBJTYPE_TASK);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TASK, &mut_prop->creator);
     }
 
     return status;
diff --git a/src/ut-stubs/osapi-utstub-queue.c b/src/ut-stubs/osapi-utstub-queue.c
index 4b8300950..71c305501 100644
--- a/src/ut-stubs/osapi-utstub-queue.c
+++ b/src/ut-stubs/osapi-utstub-queue.c
@@ -62,7 +62,7 @@ UT_DEFAULT_STUB(OS_QueueAPI_Init,(void))
 **        or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_QueueCreate(uint32 *queue_id,
+int32 OS_QueueCreate(osal_id_t *queue_id,
                      const char *queue_name,
                      uint32 queue_depth,
                      uint32 data_size,
@@ -84,7 +84,7 @@ int32 OS_QueueCreate(uint32 *queue_id,
     }
     else
     {
-        *queue_id = 0xDEADBEEFU;
+        *queue_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
     return status;
@@ -113,7 +113,7 @@ int32 OS_QueueCreate(uint32 *queue_id,
 **        OS_ERROR, or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_QueueDelete(uint32 queue_id)
+int32 OS_QueueDelete(osal_id_t queue_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_QueueDelete), queue_id);
 
@@ -154,7 +154,7 @@ int32 OS_QueueDelete(uint32 queue_id)
 **        or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_QueueGet(uint32 queue_id,
+int32 OS_QueueGet(osal_id_t queue_id,
                   void *data,
                   uint32 size,
                   uint32 *size_copied,
@@ -172,7 +172,7 @@ int32 OS_QueueGet(uint32 queue_id,
 
     if (status == OS_SUCCESS)
     {
-        *size_copied = UT_Stub_CopyToLocal((UT_EntryKey_t)&OS_QueueGet + queue_id, data, size);
+        *size_copied = UT_Stub_CopyToLocal((UT_EntryKey_t)OS_ObjectIdToInteger(queue_id), data, size);
         if (*size_copied == 0)
         {
             status = OS_QUEUE_EMPTY;
@@ -205,7 +205,7 @@ int32 OS_QueueGet(uint32 queue_id,
 **        OS_INVALID_POINTER, OS_QUEUE_FULL, or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_QueuePut(uint32 queue_id, const void *data, uint32 size, uint32 flags)
+int32 OS_QueuePut(osal_id_t queue_id, const void *data, uint32 size, uint32 flags)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_QueuePut), queue_id);
     UT_Stub_RegisterContext(UT_KEY(OS_QueuePut), data);
@@ -218,7 +218,7 @@ int32 OS_QueuePut(uint32 queue_id, const void *data, uint32 size, uint32 flags)
 
     if (status == OS_SUCCESS)
     {
-        UT_SetDataBuffer((UT_EntryKey_t)&OS_QueueGet + queue_id, (void *)data, size, true);
+        UT_SetDataBuffer((UT_EntryKey_t)OS_ObjectIdToInteger(queue_id), (void *)data, size, true);
     }
 
     return status;
@@ -229,7 +229,7 @@ int32 OS_QueuePut(uint32 queue_id, const void *data, uint32 size, uint32 flags)
  * Stub function for OS_QueueGetIdByName()
  *
  *****************************************************************************/
-int32 OS_QueueGetIdByName (uint32 *queue_id, const char *queue_name)
+int32 OS_QueueGetIdByName (osal_id_t *queue_id, const char *queue_name)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_QueueGetIdByName), queue_id);
     UT_Stub_RegisterContext(UT_KEY(OS_QueueGetIdByName), queue_name);
@@ -241,8 +241,7 @@ int32 OS_QueueGetIdByName (uint32 *queue_id, const char *queue_name)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_QueueGetIdByName), queue_id, sizeof(*queue_id)) < sizeof(*queue_id))
     {
-        *queue_id =  1;
-        UT_FIXUP_ID(*queue_id, UT_OBJTYPE_QUEUE);
+        UT_ObjIdCompose(1, UT_OBJTYPE_QUEUE,queue_id);
     }
 
     return status;
@@ -264,7 +263,7 @@ int32 OS_QueueGetIdByName (uint32 *queue_id, const char *queue_name)
 **        Returns OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_QueueGetInfo(uint32 queue_id, OS_queue_prop_t *queue_prop)
+int32 OS_QueueGetInfo(osal_id_t queue_id, OS_queue_prop_t *queue_prop)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_QueueGetInfo), queue_id);
     UT_Stub_RegisterContext(UT_KEY(OS_QueueGetInfo), queue_prop);
@@ -276,8 +275,7 @@ int32 OS_QueueGetInfo(uint32 queue_id, OS_queue_prop_t *queue_prop)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_QueueGetInfo), queue_prop, sizeof(*queue_prop)) < sizeof(*queue_prop))
     {
-        queue_prop->creator = 1;
-        UT_FIXUP_ID(queue_prop->creator, UT_OBJTYPE_TASK);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TASK, &queue_prop->creator);
         strncpy(queue_prop->name, "Name", OS_MAX_API_NAME - 1);
         queue_prop->name[OS_MAX_API_NAME - 1] = '\0';
     }
diff --git a/src/ut-stubs/osapi-utstub-select.c b/src/ut-stubs/osapi-utstub-select.c
index 3e9e56731..6be77a36a 100644
--- a/src/ut-stubs/osapi-utstub-select.c
+++ b/src/ut-stubs/osapi-utstub-select.c
@@ -38,7 +38,7 @@
  * Stub function for OS_SelectSingle()
  *
  *****************************************************************************/
-int32 OS_SelectSingle(uint32 objid, uint32 *StateFlags, int32 msecs)
+int32 OS_SelectSingle(osal_id_t objid, uint32 *StateFlags, int32 msecs)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SelectSingle), objid);
     UT_Stub_RegisterContext(UT_KEY(OS_SelectSingle), StateFlags);
@@ -90,7 +90,7 @@ int32 OS_SelectFdZero(OS_FdSet *Set)
  * Stub function for OS_SelectFdAdd()
  *
  *****************************************************************************/
-int32 OS_SelectFdAdd(OS_FdSet *Set, uint32 objid)
+int32 OS_SelectFdAdd(OS_FdSet *Set, osal_id_t objid)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_SelectFdAdd), Set);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SelectFdAdd), objid);
@@ -107,7 +107,7 @@ int32 OS_SelectFdAdd(OS_FdSet *Set, uint32 objid)
  * Stub function for OS_SelectFdClear()
  *
  *****************************************************************************/
-int32 OS_SelectFdClear(OS_FdSet *Set, uint32 objid)
+int32 OS_SelectFdClear(OS_FdSet *Set, osal_id_t objid)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_SelectFdClear), Set);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SelectFdClear), objid);
@@ -124,7 +124,7 @@ int32 OS_SelectFdClear(OS_FdSet *Set, uint32 objid)
  * Stub function for OS_SelectFdIsSet()
  *
  *****************************************************************************/
-bool OS_SelectFdIsSet(OS_FdSet *Set, uint32 objid)
+bool OS_SelectFdIsSet(OS_FdSet *Set, osal_id_t objid)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_SelectFdIsSet), Set);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SelectFdIsSet), objid);
diff --git a/src/ut-stubs/osapi-utstub-sockets.c b/src/ut-stubs/osapi-utstub-sockets.c
index 72980c001..7a1618286 100644
--- a/src/ut-stubs/osapi-utstub-sockets.c
+++ b/src/ut-stubs/osapi-utstub-sockets.c
@@ -39,7 +39,7 @@ UT_DEFAULT_STUB(OS_SocketAPI_Init,(void))
  * Stub function for OS_SocketOpen()
  *
  *****************************************************************************/
-int32 OS_SocketOpen(uint32 *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t Type)
+int32 OS_SocketOpen(osal_id_t *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t Type)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_SocketOpen), sock_id);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SocketOpen), Domain);
@@ -62,7 +62,7 @@ int32 OS_SocketOpen(uint32 *sock_id, OS_SocketDomain_t Domain, OS_SocketType_t T
  * Stub function for OS_SocketBind()
  *
  *****************************************************************************/
-int32 OS_SocketBind(uint32 sock_id, const OS_SockAddr_t *Addr)
+int32 OS_SocketBind(osal_id_t sock_id, const OS_SockAddr_t *Addr)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SocketBind), sock_id);
     UT_Stub_RegisterContext(UT_KEY(OS_SocketBind), Addr);
@@ -78,7 +78,7 @@ int32 OS_SocketBind(uint32 sock_id, const OS_SockAddr_t *Addr)
  * Stub function for OS_SocketAccept()
  *
  *****************************************************************************/
-int32 OS_SocketAccept(uint32 sock_id, uint32 *connsock_id, OS_SockAddr_t *Addr, int32 timeout)
+int32 OS_SocketAccept(osal_id_t sock_id, osal_id_t *connsock_id, OS_SockAddr_t *Addr, int32 timeout)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SocketAccept), sock_id);
     UT_Stub_RegisterContext(UT_KEY(OS_SocketAccept), connsock_id);
@@ -97,7 +97,7 @@ int32 OS_SocketAccept(uint32 sock_id, uint32 *connsock_id, OS_SockAddr_t *Addr,
  * Stub function for OS_SocketConnect()
  *
  *****************************************************************************/
-int32 OS_SocketConnect(uint32 sock_id, const OS_SockAddr_t *Addr, int32 timeout)
+int32 OS_SocketConnect(osal_id_t sock_id, const OS_SockAddr_t *Addr, int32 timeout)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SocketConnect), sock_id);
     UT_Stub_RegisterContext(UT_KEY(OS_SocketConnect), Addr);
@@ -115,7 +115,7 @@ int32 OS_SocketConnect(uint32 sock_id, const OS_SockAddr_t *Addr, int32 timeout)
  * Stub function for OS_SocketRecvFrom()
  *
  *****************************************************************************/
-int32 OS_SocketRecvFrom(uint32 sock_id, void *buffer, uint32 buflen, OS_SockAddr_t *RemoteAddr, int32 timeout)
+int32 OS_SocketRecvFrom(osal_id_t sock_id, void *buffer, uint32 buflen, OS_SockAddr_t *RemoteAddr, int32 timeout)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SocketRecvFrom), sock_id);
     UT_Stub_RegisterContext(UT_KEY(OS_SocketRecvFrom), buffer);
@@ -160,7 +160,7 @@ int32 OS_SocketRecvFrom(uint32 sock_id, void *buffer, uint32 buflen, OS_SockAddr
  * Stub function for OS_SocketSendTo()
  *
  *****************************************************************************/
-int32 OS_SocketSendTo(uint32 sock_id, const void *buffer, uint32 buflen, const OS_SockAddr_t *RemoteAddr)
+int32 OS_SocketSendTo(osal_id_t sock_id, const void *buffer, uint32 buflen, const OS_SockAddr_t *RemoteAddr)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SocketSendTo), sock_id);
     UT_Stub_RegisterContext(UT_KEY(OS_SocketSendTo), buffer);
@@ -198,7 +198,7 @@ int32 OS_SocketSendTo(uint32 sock_id, const void *buffer, uint32 buflen, const O
  * Stub function for OS_SocketGetIdByName()
  *
  *****************************************************************************/
-int32 OS_SocketGetIdByName (uint32 *sock_id, const char *sock_name)
+int32 OS_SocketGetIdByName (osal_id_t *sock_id, const char *sock_name)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_SocketGetIdByName), sock_id);
     UT_Stub_RegisterContext(UT_KEY(OS_SocketGetIdByName), sock_name);
@@ -210,8 +210,7 @@ int32 OS_SocketGetIdByName (uint32 *sock_id, const char *sock_name)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_SocketGetIdByName), sock_id, sizeof(*sock_id)) < sizeof(*sock_id))
     {
-        *sock_id =  1;
-        UT_FIXUP_ID(*sock_id, UT_OBJTYPE_SOCKET);
+        UT_ObjIdCompose(1, UT_OBJTYPE_SOCKET, sock_id);
     }
 
     return status;
@@ -219,10 +218,10 @@ int32 OS_SocketGetIdByName (uint32 *sock_id, const char *sock_name)
 
 /*****************************************************************************
  *
- * Stub function for OS_SocketGetInfo()
+ * Stub function for OS_SocketGetInfo(,sock_id)
  *
  *****************************************************************************/
-int32 OS_SocketGetInfo (uint32 sock_id, OS_socket_prop_t *sock_prop)
+int32 OS_SocketGetInfo (osal_id_t sock_id, OS_socket_prop_t *sock_prop)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_SocketGetInfo), sock_id);
     UT_Stub_RegisterContext(UT_KEY(OS_SocketGetInfo), sock_prop);
@@ -238,8 +237,7 @@ int32 OS_SocketGetInfo (uint32 sock_id, OS_socket_prop_t *sock_prop)
         CopySize = UT_Stub_CopyToLocal(UT_KEY(OS_SocketGetInfo), sock_prop, sizeof(*sock_prop));
         if (CopySize < sizeof(*sock_prop))
         {
-            sock_prop->creator = 1;
-            UT_FIXUP_ID(sock_prop->creator, UT_OBJTYPE_TASK);
+            UT_ObjIdCompose(1, UT_OBJTYPE_TASK, &sock_prop->creator);
             strncpy(sock_prop->name, "ut", sizeof(sock_prop->name));
         }
     }
diff --git a/src/ut-stubs/osapi-utstub-task.c b/src/ut-stubs/osapi-utstub-task.c
index bd0819cc2..61d9f111b 100644
--- a/src/ut-stubs/osapi-utstub-task.c
+++ b/src/ut-stubs/osapi-utstub-task.c
@@ -53,7 +53,7 @@ UT_DEFAULT_STUB(OS_TaskAPI_Init,(void))
 **        Returns either OS_SUCCESS or OS_ERROR.
 **
 ******************************************************************************/
-int32 OS_TaskCreate(uint32 *task_id, const char *task_name,
+int32 OS_TaskCreate(osal_id_t *task_id, const char *task_name,
                     osal_task_entry function_pointer,
                     uint32 *stack_pointer,
                     uint32 stack_size, uint32 priority,
@@ -77,7 +77,7 @@ int32 OS_TaskCreate(uint32 *task_id, const char *task_name,
     }
     else
     {
-        *task_id = 0xDEADBEEFU;
+        *task_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
 
@@ -100,7 +100,7 @@ int32 OS_TaskCreate(uint32 *task_id, const char *task_name,
 **        Returns either OS_SUCCESS or OS_ERROR.
 **
 ******************************************************************************/
-int32 OS_TaskDelete(uint32 task_id)
+int32 OS_TaskDelete(osal_id_t task_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TaskDelete), task_id);
 
@@ -171,7 +171,7 @@ int32 OS_TaskDelay(uint32 millisecond)
  * Stub function for OS_TaskSetPriority()
  *
  *****************************************************************************/
-int32 OS_TaskSetPriority (uint32 task_id, uint32 new_priority)
+int32 OS_TaskSetPriority (osal_id_t task_id, uint32 new_priority)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TaskSetPriority), task_id);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TaskSetPriority), new_priority);
@@ -224,13 +224,13 @@ int32 OS_TaskRegister(void)
 **        Returns 1 unless an override value is configured.
 **
 ******************************************************************************/
-uint32 OS_TaskGetId(void)
+osal_id_t OS_TaskGetId(void)
 {
-    int32 TaskId;
+    osal_id_t TaskId;
+    int32 status;
 
-    TaskId = 1;
-    UT_FIXUP_ID(TaskId, UT_OBJTYPE_TASK);
-    TaskId = UT_DEFAULT_IMPL_RC(OS_TaskGetId, TaskId);
+    status = UT_DEFAULT_IMPL_RC(OS_TaskGetId, 1);
+    UT_ObjIdCompose(status, UT_OBJTYPE_TASK, &TaskId);
 
     return TaskId;
 }
@@ -241,7 +241,7 @@ uint32 OS_TaskGetId(void)
  * Stub function for OS_TaskGetIdByName()
  *
  *****************************************************************************/
-int32 OS_TaskGetIdByName (uint32 *task_id, const char *task_name)
+int32 OS_TaskGetIdByName (osal_id_t *task_id, const char *task_name)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_TaskGetIdByName), task_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TaskGetIdByName), task_name);
@@ -253,8 +253,7 @@ int32 OS_TaskGetIdByName (uint32 *task_id, const char *task_name)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_TaskGetIdByName), task_id, sizeof(*task_id)) < sizeof(*task_id))
     {
-        *task_id =  1;
-        UT_FIXUP_ID(*task_id, UT_OBJTYPE_TASK);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TASK, task_id);
     }
 
     return status;
@@ -278,7 +277,7 @@ int32 OS_TaskGetIdByName (uint32 *task_id, const char *task_name)
 **        Returns either OS_INVALID_POINTER or OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_TaskGetInfo(uint32 task_id, OS_task_prop_t *task_prop)
+int32 OS_TaskGetInfo(osal_id_t task_id, OS_task_prop_t *task_prop)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TaskGetInfo), task_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TaskGetInfo), task_prop);
@@ -290,8 +289,7 @@ int32 OS_TaskGetInfo(uint32 task_id, OS_task_prop_t *task_prop)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_TaskGetInfo), task_prop, sizeof(*task_prop)) < sizeof(*task_prop))
     {
-        task_prop->creator = 1;
-        UT_FIXUP_ID(task_prop->creator, UT_OBJTYPE_TASK);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TASK, &task_prop->creator);
         task_prop->stack_size = 100;
         task_prop->priority = 150;
         strncpy(task_prop->name, "UnitTest", OS_MAX_API_NAME - 1);
@@ -313,7 +311,7 @@ int32 OS_TaskGetInfo(uint32 task_id, OS_task_prop_t *task_prop)
 **        The return value instructed by the test case setup
 **
 ******************************************************************************/
-int32 OS_TaskFindIdBySystemData(uint32 *task_id, const void *sysdata, size_t sysdata_size)
+int32 OS_TaskFindIdBySystemData(osal_id_t *task_id, const void *sysdata, size_t sysdata_size)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_TaskFindIdBySystemData), task_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TaskFindIdBySystemData), sysdata);
@@ -326,8 +324,7 @@ int32 OS_TaskFindIdBySystemData(uint32 *task_id, const void *sysdata, size_t sys
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_TaskFindIdBySystemData), task_id, sizeof(*task_id)) < sizeof(*task_id))
     {
-        *task_id = 1;
-        UT_FIXUP_ID(*task_id, UT_OBJTYPE_TASK);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TASK, task_id);
     }
 
     return status;
@@ -357,7 +354,7 @@ int32 OS_TaskInstallDeleteHandler(osal_task_entry function_pointer)
  * the low level implementation that uses the shared layer.
  *
  *****************************************************************************/
-void OS_TaskEntryPoint(uint32 task_id)
+void OS_TaskEntryPoint(osal_id_t task_id)
 {
     UT_DEFAULT_IMPL(OS_TaskEntryPoint);
 }
diff --git a/src/ut-stubs/osapi-utstub-time.c b/src/ut-stubs/osapi-utstub-time.c
index 356410eac..909ff8bcc 100644
--- a/src/ut-stubs/osapi-utstub-time.c
+++ b/src/ut-stubs/osapi-utstub-time.c
@@ -41,7 +41,7 @@ UT_DEFAULT_STUB(OS_TimerCbAPI_Init,(void))
  * Stub function for OS_TimerAdd()
  *
  *****************************************************************************/
-int32 OS_TimerAdd(uint32 *timer_id, const char *timer_name, uint32 timebase_id, OS_ArgCallback_t  callback_ptr, void *callback_arg)
+int32 OS_TimerAdd(osal_id_t *timer_id, const char *timer_name, osal_id_t timebase_id, OS_ArgCallback_t  callback_ptr, void *callback_arg)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_TimerAdd), timer_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TimerAdd), timer_name);
@@ -59,7 +59,7 @@ int32 OS_TimerAdd(uint32 *timer_id, const char *timer_name, uint32 timebase_id,
     }
     else
     {
-        *timer_id = 0xDEADBEEFU;
+        *timer_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
     return status;
@@ -70,7 +70,7 @@ int32 OS_TimerAdd(uint32 *timer_id, const char *timer_name, uint32 timebase_id,
  * Stub function for OS_TimerCreate()
  *
  *****************************************************************************/
-int32 OS_TimerCreate(uint32 *timer_id, const char *timer_name, uint32 *clock_accuracy, OS_TimerCallback_t  callback_ptr)
+int32 OS_TimerCreate(osal_id_t *timer_id, const char *timer_name, uint32 *clock_accuracy, OS_TimerCallback_t  callback_ptr)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_TimerCreate), timer_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TimerCreate), timer_name);
@@ -87,7 +87,7 @@ int32 OS_TimerCreate(uint32 *timer_id, const char *timer_name, uint32 *clock_acc
     }
     else
     {
-        *timer_id = 0xDEADBEEFU;
+        *timer_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
     return status;
@@ -98,7 +98,7 @@ int32 OS_TimerCreate(uint32 *timer_id, const char *timer_name, uint32 *clock_acc
  * Stub function for OS_TimerSet()
  *
  *****************************************************************************/
-int32 OS_TimerSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
+int32 OS_TimerSet(osal_id_t timer_id, uint32 start_time, uint32 interval_time)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimerSet), timer_id);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimerSet), start_time);
@@ -127,7 +127,7 @@ int32 OS_TimerSet(uint32 timer_id, uint32 start_time, uint32 interval_time)
 **        Returns OS_ERR_INVALID_ID.
 **
 ******************************************************************************/
-int32 OS_TimerDelete(uint32 timer_id)
+int32 OS_TimerDelete(osal_id_t timer_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimerDelete), timer_id);
 
@@ -148,7 +148,7 @@ int32 OS_TimerDelete(uint32 timer_id)
  * Stub function for OS_TimerGetIdByName()
  *
  *****************************************************************************/
-int32 OS_TimerGetIdByName (uint32 *timer_id, const char *timer_name)
+int32 OS_TimerGetIdByName (osal_id_t *timer_id, const char *timer_name)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_TimerGetIdByName), timer_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TimerGetIdByName), timer_name);
@@ -160,8 +160,7 @@ int32 OS_TimerGetIdByName (uint32 *timer_id, const char *timer_name)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_TimerGetIdByName), timer_id, sizeof(*timer_id)) < sizeof(*timer_id))
     {
-        *timer_id =  1;
-        UT_FIXUP_ID(*timer_id, UT_OBJTYPE_TIMECB);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TIMECB, timer_id);
     }
 
     return status;
@@ -186,7 +185,7 @@ int32 OS_TimerGetIdByName (uint32 *timer_id, const char *timer_name)
 **        Returns OS_SUCCESS.
 **
 ******************************************************************************/
-int32 OS_TimerGetInfo(uint32 timer_id, OS_timer_prop_t *timer_prop)
+int32 OS_TimerGetInfo(osal_id_t timer_id, OS_timer_prop_t *timer_prop)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimerGetInfo), timer_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TimerGetInfo), timer_prop);
@@ -199,8 +198,7 @@ int32 OS_TimerGetInfo(uint32 timer_id, OS_timer_prop_t *timer_prop)
             UT_Stub_CopyToLocal(UT_KEY(OS_TimerGetInfo), timer_prop, sizeof(*timer_prop)) < sizeof(*timer_prop))
     {
         memset(timer_prop, 0, sizeof(*timer_prop));
-        timer_prop->creator = 1;
-        UT_FIXUP_ID(timer_prop->creator, UT_OBJTYPE_TASK);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TASK, &timer_prop->creator);
     }
 
     return status;
diff --git a/src/ut-stubs/osapi-utstub-timebase.c b/src/ut-stubs/osapi-utstub-timebase.c
index 584515294..8bee73fcc 100644
--- a/src/ut-stubs/osapi-utstub-timebase.c
+++ b/src/ut-stubs/osapi-utstub-timebase.c
@@ -42,7 +42,7 @@ UT_DEFAULT_STUB(OS_TimeBaseAPI_Init,(void))
  * Stub for OS_TimeBaseCreate() function
  *
  *****************************************************************************/
-int32 OS_TimeBaseCreate(uint32 *timebase_id, const char *timebase_name, OS_TimerSync_t external_sync)
+int32 OS_TimeBaseCreate(osal_id_t *timebase_id, const char *timebase_name, OS_TimerSync_t external_sync)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_TimeBaseCreate), timebase_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TimeBaseCreate), timebase_name);
@@ -58,7 +58,7 @@ int32 OS_TimeBaseCreate(uint32 *timebase_id, const char *timebase_name, OS_Timer
     }
     else
     {
-        *timebase_id = 0xDEADBEEFU;
+        *timebase_id = UT_STUB_FAKE_OBJECT_ID;
     }
 
     return status;
@@ -70,7 +70,7 @@ int32 OS_TimeBaseCreate(uint32 *timebase_id, const char *timebase_name, OS_Timer
  * Stub for OS_TimeBaseSet() function
  *
  *****************************************************************************/
-int32 OS_TimeBaseSet(uint32 timebase_id, uint32 start_time, uint32 interval_time)
+int32 OS_TimeBaseSet(osal_id_t timebase_id, uint32 start_time, uint32 interval_time)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimeBaseSet), timebase_id);
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimeBaseSet), start_time);
@@ -89,7 +89,7 @@ int32 OS_TimeBaseSet(uint32 timebase_id, uint32 start_time, uint32 interval_time
  * Stub for OS_TimeBaseDelete() function
  *
  *****************************************************************************/
-int32 OS_TimeBaseDelete(uint32 timebase_id)
+int32 OS_TimeBaseDelete(osal_id_t timebase_id)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimeBaseDelete), timebase_id);
 
@@ -111,7 +111,7 @@ int32 OS_TimeBaseDelete(uint32 timebase_id)
  * Stub for OS_TimeBaseGetIdByName() function
  *
  *****************************************************************************/
-int32 OS_TimeBaseGetIdByName (uint32 *timebase_id, const char *timebase_name)
+int32 OS_TimeBaseGetIdByName (osal_id_t *timebase_id, const char *timebase_name)
 {
     UT_Stub_RegisterContext(UT_KEY(OS_TimeBaseGetIdByName), timebase_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TimeBaseGetIdByName), timebase_name);
@@ -123,8 +123,7 @@ int32 OS_TimeBaseGetIdByName (uint32 *timebase_id, const char *timebase_name)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_TimeBaseGetIdByName), timebase_id, sizeof(*timebase_id)) < sizeof(*timebase_id))
     {
-        *timebase_id =  1;
-        UT_FIXUP_ID(*timebase_id, UT_OBJTYPE_TIMEBASE);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TIMEBASE, timebase_id);
     }
 
     return status;
@@ -136,7 +135,7 @@ int32 OS_TimeBaseGetIdByName (uint32 *timebase_id, const char *timebase_name)
  * Stub for OS_TimeBaseGetInfo() function
  *
  *****************************************************************************/
-int32 OS_TimeBaseGetInfo (uint32 timebase_id, OS_timebase_prop_t *timebase_prop)
+int32 OS_TimeBaseGetInfo (osal_id_t timebase_id, OS_timebase_prop_t *timebase_prop)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimeBaseGetInfo), timebase_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TimeBaseGetInfo), timebase_prop);
@@ -148,8 +147,7 @@ int32 OS_TimeBaseGetInfo (uint32 timebase_id, OS_timebase_prop_t *timebase_prop)
     if (status == OS_SUCCESS &&
             UT_Stub_CopyToLocal(UT_KEY(OS_TimeBaseGetInfo), timebase_prop, sizeof(*timebase_prop)) < sizeof(*timebase_prop))
     {
-        timebase_prop->creator = 1;
-        UT_FIXUP_ID(timebase_prop->creator, UT_OBJTYPE_TASK);
+        UT_ObjIdCompose(1, UT_OBJTYPE_TASK, &timebase_prop->creator);
         strncpy(timebase_prop->name, "Name", OS_MAX_API_NAME - 1);
         timebase_prop->name[OS_MAX_API_NAME - 1] = '\0';
     }
@@ -163,7 +161,7 @@ int32 OS_TimeBaseGetInfo (uint32 timebase_id, OS_timebase_prop_t *timebase_prop)
  * Stub for OS_TimeBaseGetFreeRun() function
  *
  *****************************************************************************/
-int32 OS_TimeBaseGetFreeRun     (uint32 timebase_id, uint32 *freerun_val)
+int32 OS_TimeBaseGetFreeRun     (osal_id_t timebase_id, uint32 *freerun_val)
 {
     UT_Stub_RegisterContextGenericArg(UT_KEY(OS_TimeBaseGetFreeRun), timebase_id);
     UT_Stub_RegisterContext(UT_KEY(OS_TimeBaseGetFreeRun), freerun_val);
diff --git a/src/ut-stubs/utstub-helpers.c b/src/ut-stubs/utstub-helpers.c
index 95efd07cb..9285c7503 100644
--- a/src/ut-stubs/utstub-helpers.c
+++ b/src/ut-stubs/utstub-helpers.c
@@ -69,11 +69,12 @@ void UT_ClearAllStubObjects (void)
 /*
  * Helper function - "allocate" a fake object ID of the given type
  */
-uint32 UT_AllocStubObjId(UT_ObjType_t ObjType)
+osal_id_t UT_AllocStubObjId(UT_ObjType_t ObjType)
 {
     UT_ObjTypeState_t *StatePtr;
     uint8 ObjMask;
-    uint32 Result;
+    uint32 indx;
+    osal_id_t Result;
 
     UT_Stub_CallOnce(UT_ClearAllStubObjects);
 
@@ -92,9 +93,9 @@ uint32 UT_AllocStubObjId(UT_ObjType_t ObjType)
         ++StatePtr->LastIssueNumber;
     }
 
-    Result = StatePtr->LastIssueNumber;
+    indx = StatePtr->LastIssueNumber;
 
-    ObjMask = 1 << (Result & 0x07);
+    ObjMask = 1 << (indx & 0x07);
     /*
      * Check for overlap/re-issue - this COULD happen when using
      * the original (non-opaque) object IDs if a UT creates too many
@@ -102,16 +103,16 @@ uint32 UT_AllocStubObjId(UT_ObjType_t ObjType)
      * and it means the test needs to be revised to not create so many
      * objects OR it needs to support opaque object IDs
      */
-    if ((StatePtr->ValidBits[Result >> 3] & ObjMask) != 0)
+    if ((StatePtr->ValidBits[indx >> 3] & ObjMask) != 0)
     {
         UtAssert_Failed("OSAPI UT stub object overlap");
     }
-    StatePtr->ValidBits[Result >> 3] |= ObjMask;
+    StatePtr->ValidBits[indx >> 3] |= ObjMask;
 
     /*
      * Finalize Object ID - put into proper range for type
      */
-    UT_FIXUP_ID(Result, ObjType);
+    UT_ObjIdCompose(indx, ObjType, &Result);
 
     return Result;
 }
@@ -119,25 +120,28 @@ uint32 UT_AllocStubObjId(UT_ObjType_t ObjType)
 /*
  * Helper function - "deallocate" a fake object ID of the given type
  */
-void UT_DeleteStubObjId(UT_ObjType_t ObjType, uint32 ObjId)
+void UT_DeleteStubObjId(UT_ObjType_t ObjType, osal_id_t ObjId)
 {
     UT_ObjTypeState_t *StatePtr;
     uint8 ObjMask;
+    UT_ObjType_t checktype;
+    uint32 checkidx;
     bool ObjWasValid;
 
     UT_Stub_CallOnce(UT_ClearAllStubObjects);
 
+    UT_ObjIdDecompose(ObjId, &checkidx, &checktype);
+
     /*
      * Verify the object type
      */
-    if (ObjType != ((ObjId >> 16) ^ 0x4000U))
+    if (ObjType != checktype)
     {
         /* Calling code is broken, abort the test */
         UtAssert_Failed("Object type is not correct");
     }
 
-    ObjId &= 0xFFFFU;
-    if (ObjId >= (8 * sizeof(StatePtr->ValidBits)))
+    if (checkidx >= (8 * sizeof(StatePtr->ValidBits)))
     {
         /* Calling code is broken */
         UtAssert_Failed("ObjId out of range");
@@ -147,11 +151,11 @@ void UT_DeleteStubObjId(UT_ObjType_t ObjType, uint32 ObjId)
 
     /* Clear out any bit it could have been */
     ObjWasValid = false;
-    ObjMask = 1 << (ObjId & 0x07);
-    if ((StatePtr->ValidBits[ObjId >> 3] & ObjMask) != 0)
+    ObjMask = 1 << (checkidx & 0x07);
+    if ((StatePtr->ValidBits[checkidx >> 3] & ObjMask) != 0)
     {
         ObjWasValid = true;
-        StatePtr->ValidBits[ObjId >> 3] &= ~ObjMask;
+        StatePtr->ValidBits[checkidx >> 3] &= ~ObjMask;
     }
 
     /* Unfortunately, some code has a habit of just blindly calling "Delete"
@@ -172,13 +176,22 @@ void UT_DeleteStubObjId(UT_ObjType_t ObjType, uint32 ObjId)
     }
 }
 
+void UT_ObjIdCompose(uint32 indx, UT_ObjType_t objtype, osal_id_t *id)
+{
+    /* note - the OS_ObjectIdFromInteger() is an inline function,
+     * and therefore this uses the real thing and not a stub  */
+    *id = OS_ObjectIdFromInteger((unsigned long)indx | ((0x4000UL | objtype) << 16));
+}
 
-uint32 UT_ObjIdFixup(uint32 val, uint32 objtype)
+void UT_ObjIdDecompose(osal_id_t id, uint32 *indx, UT_ObjType_t *objtype)
 {
-    return (val | ((0x4000U | objtype) << 16));
+    unsigned long idv = OS_ObjectIdToInteger(id);
+    *indx = idv & 0xFFFFUL;
+    *objtype = (idv >> 16) ^ 0x4000UL;
 }
 
 
+
 /*
 ** Report and close any sockets found open
 ** Moved here temporarily to ensure full compatibility with CFE implementation
@@ -191,17 +204,13 @@ void UT_CheckForOpenSockets(void)
 {
     UT_ObjTypeState_t *StatePtr;
     uint32 i;
-    uint32 id;
 
     StatePtr = &UT_ObjState[UT_OBJTYPE_QUEUE];
     for (i=0; i <= StatePtr->LastIssueNumber; ++i)
     {
         if ((StatePtr->ValidBits[i >> 3] & (1 << (i & 0x07))) != 0)
         {
-            id = i;
-            UT_FIXUP_ID(id, UT_OBJTYPE_QUEUE);
-
-            UtAssert_Failed("UT_Queue %d left open. ID=%x\n", (int)i, (unsigned int)id);
+            UtAssert_Failed("UT_Queue %d left open.\n", (int)i);
         }
     }
 
diff --git a/src/ut-stubs/utstub-helpers.h b/src/ut-stubs/utstub-helpers.h
index 3288661ac..6501a6a79 100644
--- a/src/ut-stubs/utstub-helpers.h
+++ b/src/ut-stubs/utstub-helpers.h
@@ -70,13 +70,9 @@ typedef enum
 } UT_ObjType_t;
 
 /*
- * Function to adjust any objid into the proper range
- *
- * If building an OSAL that has opaque (nonzero) object IDs,
- * then these stub functions can also replicate that.  This
- * macro will be used to support both opaque and non-opaque IDs
+ * A constant to use in stubs where no other value is applicable
  */
-#define UT_FIXUP_ID(id,typ)        id = UT_ObjIdFixup(id,typ)
+#define UT_STUB_FAKE_OBJECT_ID     ((osal_id_t){0xDEADBEEFU})
 
 /*
  * Size of the bitmask for the OSAL fake object ID validity table
@@ -105,12 +101,12 @@ extern const uint32 UT_MAXOBJS[];
 /*
  * Helper function - "allocate" a fake object ID of the given type
  */
-uint32 UT_AllocStubObjId(UT_ObjType_t ObjType);
+osal_id_t UT_AllocStubObjId(UT_ObjType_t ObjType);
 
 /*
  * Helper function - "deallocate" a fake object ID of the given type
  */
-void UT_DeleteStubObjId(UT_ObjType_t ObjType, uint32 ObjId);
+void UT_DeleteStubObjId(UT_ObjType_t ObjType, osal_id_t ObjId);
 
 /*
  * Helper function - Report any queue objects found open
@@ -125,9 +121,11 @@ void UT_CheckForOpenSockets(void);
 void UT_ClearAllStubObjects(void);
 
 /*
- * Takes an ID index and sets the proper ID bits.
+ * Compose/Decompose a unit test object ID from an index and type.
+ * This is the UT-specific version not related to the OSAL runtime version.
  */
-uint32 UT_ObjIdFixup(uint32 val,uint32 objtype);
+void UT_ObjIdCompose(uint32 indx, UT_ObjType_t objtype, osal_id_t *id);
+void UT_ObjIdDecompose(osal_id_t id, uint32 *indx, UT_ObjType_t *objtype);
 
 #endif