Change returning 'invalid arg' status to asserting params

in internal memspace and memtarget functions.

Author: lukaszstolarczuk

src/memspace.c

@@ -204,9 +204,8 @@ static int propertyCmp(const void *a, const void *b) {
 
 umf_result_t umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
                                  umfGetPropertyFn getProperty) {
-    if (!hMemspace || !getProperty) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(hMemspace);
+    assert(getProperty);
 
     struct memtarget_sort_entry *entries = umf_ba_global_alloc(
         sizeof(struct memtarget_sort_entry) * hMemspace->size);
@@ -241,9 +240,8 @@ umf_result_t umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
 umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
                                umfGetTargetFn getTarget,
                                umf_memspace_handle_t *filteredMemspace) {
-    if (!hMemspace || !getTarget) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(hMemspace);
+    assert(getTarget);
 
     umf_memtarget_handle_t *uniqueBestNodes =
         umf_ba_global_alloc(hMemspace->size * sizeof(*uniqueBestNodes));
@@ -433,10 +431,8 @@ umfMemspaceMemtargetRemove(umf_memspace_handle_t hMemspace,
 static int umfMemspaceFilterHelper(umf_memspace_handle_t memspace,
                                    umf_memspace_filter_func_t filter,
                                    void *args) {
-
-    if (!memspace || !filter) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(memspace);
+    assert(filter);
 
     size_t idx = 0;
     int ret;

src/memtarget.c

@@ -20,9 +20,8 @@
 umf_result_t umfMemtargetCreate(const umf_memtarget_ops_t *ops, void *params,
                                 umf_memtarget_handle_t *memoryTarget) {
     libumfInit();
-    if (!ops || !memoryTarget) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(ops);
+    assert(memoryTarget);
 
     umf_memtarget_handle_t target =
         umf_ba_global_alloc(sizeof(umf_memtarget_t));
@@ -93,9 +92,9 @@ umf_result_t umfMemtargetGetCapacity(umf_const_memtarget_handle_t memoryTarget,
 umf_result_t umfMemtargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget,
                                       umf_memtarget_handle_t dstMemoryTarget,
                                       size_t *bandwidth) {
-    if (!srcMemoryTarget || !dstMemoryTarget || !bandwidth) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(srcMemoryTarget);
+    assert(dstMemoryTarget);
+    assert(bandwidth);
 
     return srcMemoryTarget->ops->get_bandwidth(
         srcMemoryTarget->priv, dstMemoryTarget->priv, bandwidth);
@@ -104,9 +103,9 @@ umf_result_t umfMemtargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget,
 umf_result_t umfMemtargetGetLatency(umf_memtarget_handle_t srcMemoryTarget,
                                     umf_memtarget_handle_t dstMemoryTarget,
                                     size_t *latency) {
-    if (!srcMemoryTarget || !dstMemoryTarget || !latency) {
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
-    }
+    assert(srcMemoryTarget);
+    assert(dstMemoryTarget);
+    assert(latency);
 
     return srcMemoryTarget->ops->get_latency(srcMemoryTarget->priv,
                                              dstMemoryTarget->priv, latency);