Handle null vector as input and remove vector_is_released function

sagiegurari · sagiegurari · commit c50d2b62b50b · 2022-10-25T12:46:28.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,7 +1,9 @@
 ## CHANGELOG
 
-### v0.1.2
+### v0.1.2 (2022-10-25)
 
+* Handle null vector as input
+* Removed vector_is_released function
 * Free all memory in tests
 * Test memory leaks in CI
 * Added void to no arg functions
diff --git a/include/vector.h b/include/vector.h
@@ -9,7 +9,6 @@ struct Vector;
 struct Vector *vector_new(void);
 struct Vector *vector_new_with_options(const size_t /* initial_size */, const bool /* allow_resize */);
 
-bool vector_is_released(struct Vector *);
 bool vector_is_empty(struct Vector *);
 size_t vector_size(struct Vector *);
 size_t vector_capacity(struct Vector *);
diff --git a/src/vector.c b/src/vector.c
@@ -9,7 +9,6 @@ static bool _vector_set_capacity(struct Vector *, size_t);
 
 struct Vector
 {
-  bool   released;
   size_t size;
   size_t capacity;
   void   **buffer;
@@ -38,7 +37,6 @@ struct Vector *vector_new_with_options(const size_t initial_size, const bool all
     return(NULL);
   }
 
-  vector->released = false;
   vector->size     = 0;
   vector->capacity = size;
 
@@ -56,39 +54,53 @@ struct Vector *vector_new_with_options(const size_t initial_size, const bool all
 }
 
 
-bool vector_is_released(struct Vector *vector)
-{
-  return(vector == NULL || vector->released);
-}
-
-
 bool vector_is_empty(struct Vector *vector)
 {
+  if (vector == NULL)
+  {
+    return(true);
+  }
+
   return(vector->size == 0);
 }
 
 
 size_t vector_size(struct Vector *vector)
 {
+  if (vector == NULL)
+  {
+    return(0);
+  }
+
   return(vector->size);
 }
 
 
 size_t vector_capacity(struct Vector *vector)
 {
+  if (vector == NULL)
+  {
+    return(0);
+  }
+
   return(vector->capacity);
 }
 
 
 bool  vector_is_allow_resize(struct Vector *vector)
 {
+  if (vector == NULL)
+  {
+    return(false);
+  }
+
   return(vector->allow_resize);
 }
 
 
 bool vector_clear(struct Vector *vector)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(false);
   }
@@ -105,7 +117,7 @@ bool vector_clear(struct Vector *vector)
 
 void vector_release(struct Vector *vector)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return;
   }
@@ -116,15 +128,13 @@ void vector_release(struct Vector *vector)
     vector->buffer = NULL;
   }
 
-  vector->released = true;
-
   free(vector);
 }
 
 
 bool vector_ensure_capacity(struct Vector *vector, const size_t size)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(false);
   }
@@ -140,7 +150,7 @@ bool vector_ensure_capacity(struct Vector *vector, const size_t size)
 
 bool vector_shrink(struct Vector *vector)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(false);
   }
@@ -156,7 +166,7 @@ bool vector_shrink(struct Vector *vector)
 
 void **vector_to_array(struct Vector *vector)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(NULL);
   }
@@ -175,7 +185,7 @@ void **vector_to_array(struct Vector *vector)
 
 bool vector_push(struct Vector *vector, void *item)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(false);
   }
@@ -186,7 +196,7 @@ bool vector_push(struct Vector *vector, void *item)
 
 void *vector_pop(struct Vector *vector)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(NULL);
   }
@@ -202,7 +212,7 @@ void *vector_pop(struct Vector *vector)
 
 void *vector_set(struct Vector *vector, size_t index, void *item)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(NULL);
   }
@@ -226,7 +236,7 @@ void *vector_set(struct Vector *vector, size_t index, void *item)
 
 void *vector_get(struct Vector *vector, size_t index)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(NULL);
   }
@@ -248,7 +258,7 @@ bool vector_prepend(struct Vector *vector, void *item)
 
 bool vector_insert(struct Vector *vector, size_t index, void *item)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(false);
   }
@@ -294,7 +304,7 @@ bool vector_insert(struct Vector *vector, size_t index, void *item)
 
 void *vector_remove(struct Vector *vector, size_t index)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(NULL);
   }
@@ -320,7 +330,7 @@ void *vector_remove(struct Vector *vector, size_t index)
 
 static bool _vector_clear(struct Vector *vector)
 {
-  if (vector_is_released(vector))
+  if (vector == NULL)
   {
     return(false);
   }
@@ -353,6 +363,11 @@ static bool _vector_clear(struct Vector *vector)
 
 static bool _vector_set_capacity_with_buffer(struct Vector *vector, size_t min_size)
 {
+  if (vector == NULL)
+  {
+    return(false);
+  }
+
   if (min_size > vector->capacity)
   {
     size_t new_size = vector->size * 2;
@@ -372,7 +387,7 @@ static bool _vector_set_capacity_with_buffer(struct Vector *vector, size_t min_s
 
 static bool _vector_set_capacity(struct Vector *vector, const size_t size)
 {
-  if (!vector->allow_resize)
+  if (vector == NULL || !vector->allow_resize)
   {
     return(false);
   }
diff --git a/tests/test_capacity_null.c b/tests/test_capacity_null.c
@@ -0,0 +1,15 @@
+#include "test.h"
+#include "vector.h"
+
+
+void test_impl()
+{
+  assert_num_equal(vector_capacity(NULL), 0);
+}
+
+
+int main()
+{
+  test_run(test_impl);
+}
+
diff --git a/tests/test_is_allow_resize_null.c b/tests/test_is_allow_resize_null.c
@@ -0,0 +1,15 @@
+#include "test.h"
+#include "vector.h"
+
+
+void test_impl()
+{
+  assert_true(!vector_is_allow_resize(NULL));
+}
+
+
+int main()
+{
+  test_run(test_impl);
+}
+
diff --git a/tests/test_is_empty_null.c b/tests/test_is_empty_null.c
@@ -0,0 +1,15 @@
+#include "test.h"
+#include "vector.h"
+
+
+void test_impl()
+{
+  assert_true(vector_is_empty(NULL));
+}
+
+
+int main()
+{
+  test_run(test_impl);
+}
+
diff --git a/tests/test_new.c b/tests/test_new.c
@@ -6,7 +6,6 @@ void test_impl()
 {
   struct Vector *vector = vector_new();
 
-  assert_true(!vector_is_released(vector));
   assert_true(vector_is_empty(vector));
   assert_num_equal(vector_size(vector), 0);
   assert_num_equal(vector_capacity(vector), 20);
diff --git a/tests/test_new_with_options_no_resize.c b/tests/test_new_with_options_no_resize.c
@@ -6,7 +6,6 @@ void test_impl()
 {
   struct Vector *vector = vector_new_with_options(50, false);
 
-  assert_true(!vector_is_released(vector));
   assert_true(vector_is_empty(vector));
   assert_num_equal(vector_size(vector), 0);
   assert_num_equal(vector_capacity(vector), 50);
diff --git a/tests/test_new_with_options_with_resize.c b/tests/test_new_with_options_with_resize.c
@@ -6,7 +6,6 @@ void test_impl()
 {
   struct Vector *vector = vector_new_with_options(50, true);
 
-  assert_true(!vector_is_released(vector));
   assert_true(vector_is_empty(vector));
   assert_num_equal(vector_size(vector), 0);
   assert_num_equal(vector_capacity(vector), 50);
diff --git a/tests/test_size_null.c b/tests/test_size_null.c
@@ -0,0 +1,15 @@
+#include "test.h"
+#include "vector.h"
+
+
+void test_impl()
+{
+  assert_num_equal(vector_size(NULL), 0);
+}
+
+
+int main()
+{
+  test_run(test_impl);
+}
+

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,6 @@ static bool _vector_set_capacity(struct Vector *, size_t);`
`9`	`9`
`10`	`10`	`struct Vector`
`11`	`11`	`{`
`12`		`- bool released;`
`13`	`12`	`size_t size;`
`14`	`13`	`size_t capacity;`
`15`	`14`	`void **buffer;`
`@@ -38,7 +37,6 @@ struct Vector *vector_new_with_options(const size_t initial_size, const bool all`
`38`	`37`	`return(NULL);`
`39`	`38`	`}`
`40`	`39`
`41`		`- vector->released = false;`
`42`	`40`	`vector->size = 0;`
`43`	`41`	`vector->capacity = size;`
`44`	`42`
`@@ -56,39 +54,53 @@ struct Vector *vector_new_with_options(const size_t initial_size, const bool all`
`56`	`54`	`}`
`57`	`55`
`58`	`56`
`59`		`-bool vector_is_released(struct Vector *vector)`
`60`		`-{`
`61`		`- return(vector == NULL \|\| vector->released);`
`62`		`-}`
`63`		`-`
`64`		`-`
`65`	`57`	`bool vector_is_empty(struct Vector *vector)`
`66`	`58`	`{`
	`59`	`+ if (vector == NULL)`
	`60`	`+ {`
	`61`	`+ return(true);`
	`62`	`+ }`
	`63`	`+`
`67`	`64`	`return(vector->size == 0);`
`68`	`65`	`}`
`69`	`66`
`70`	`67`
`71`	`68`	`size_t vector_size(struct Vector *vector)`
`72`	`69`	`{`
	`70`	`+ if (vector == NULL)`
	`71`	`+ {`
	`72`	`+ return(0);`
	`73`	`+ }`
	`74`	`+`
`73`	`75`	`return(vector->size);`
`74`	`76`	`}`
`75`	`77`
`76`	`78`
`77`	`79`	`size_t vector_capacity(struct Vector *vector)`
`78`	`80`	`{`
	`81`	`+ if (vector == NULL)`
	`82`	`+ {`
	`83`	`+ return(0);`
	`84`	`+ }`
	`85`	`+`
`79`	`86`	`return(vector->capacity);`
`80`	`87`	`}`
`81`	`88`
`82`	`89`
`83`	`90`	`bool vector_is_allow_resize(struct Vector *vector)`
`84`	`91`	`{`
	`92`	`+ if (vector == NULL)`
	`93`	`+ {`
	`94`	`+ return(false);`
	`95`	`+ }`
	`96`	`+`
`85`	`97`	`return(vector->allow_resize);`
`86`	`98`	`}`
`87`	`99`
`88`	`100`
`89`	`101`	`bool vector_clear(struct Vector *vector)`
`90`	`102`	`{`
`91`		`- if (vector_is_released(vector))`
	`103`	`+ if (vector == NULL)`
`92`	`104`	`{`
`93`	`105`	`return(false);`
`94`	`106`	`}`
`@@ -105,7 +117,7 @@ bool vector_clear(struct Vector *vector)`
`105`	`117`
`106`	`118`	`void vector_release(struct Vector *vector)`
`107`	`119`	`{`
`108`		`- if (vector_is_released(vector))`
	`120`	`+ if (vector == NULL)`
`109`	`121`	`{`
`110`	`122`	`return;`
`111`	`123`	`}`
`@@ -116,15 +128,13 @@ void vector_release(struct Vector *vector)`
`116`	`128`	`vector->buffer = NULL;`
`117`	`129`	`}`
`118`	`130`
`119`		`- vector->released = true;`
`120`		`-`
`121`	`131`	`free(vector);`
`122`	`132`	`}`
`123`	`133`
`124`	`134`
`125`	`135`	`bool vector_ensure_capacity(struct Vector *vector, const size_t size)`
`126`	`136`	`{`
`127`		`- if (vector_is_released(vector))`
	`137`	`+ if (vector == NULL)`
`128`	`138`	`{`
`129`	`139`	`return(false);`
`130`	`140`	`}`
`@@ -140,7 +150,7 @@ bool vector_ensure_capacity(struct Vector *vector, const size_t size)`
`140`	`150`
`141`	`151`	`bool vector_shrink(struct Vector *vector)`
`142`	`152`	`{`
`143`		`- if (vector_is_released(vector))`
	`153`	`+ if (vector == NULL)`
`144`	`154`	`{`
`145`	`155`	`return(false);`
`146`	`156`	`}`
`@@ -156,7 +166,7 @@ bool vector_shrink(struct Vector *vector)`
`156`	`166`
`157`	`167`	`void *vector_to_array(struct Vector vector)`
`158`	`168`	`{`
`159`		`- if (vector_is_released(vector))`
	`169`	`+ if (vector == NULL)`
`160`	`170`	`{`
`161`	`171`	`return(NULL);`
`162`	`172`	`}`
`@@ -175,7 +185,7 @@ void *vector_to_array(struct Vector vector)`
`175`	`185`
`176`	`186`	`bool vector_push(struct Vector vector, void item)`
`177`	`187`	`{`
`178`		`- if (vector_is_released(vector))`
	`188`	`+ if (vector == NULL)`
`179`	`189`	`{`
`180`	`190`	`return(false);`
`181`	`191`	`}`
`@@ -186,7 +196,7 @@ bool vector_push(struct Vector vector, void item)`
`186`	`196`
`187`	`197`	`void vector_pop(struct Vector vector)`
`188`	`198`	`{`
`189`		`- if (vector_is_released(vector))`
	`199`	`+ if (vector == NULL)`
`190`	`200`	`{`
`191`	`201`	`return(NULL);`
`192`	`202`	`}`
`@@ -202,7 +212,7 @@ void vector_pop(struct Vector vector)`
`202`	`212`
`203`	`213`	`void vector_set(struct Vector vector, size_t index, void *item)`
`204`	`214`	`{`
`205`		`- if (vector_is_released(vector))`
	`215`	`+ if (vector == NULL)`
`206`	`216`	`{`
`207`	`217`	`return(NULL);`
`208`	`218`	`}`
`@@ -226,7 +236,7 @@ void vector_set(struct Vector vector, size_t index, void *item)`
`226`	`236`
`227`	`237`	`void vector_get(struct Vector vector, size_t index)`
`228`	`238`	`{`
`229`		`- if (vector_is_released(vector))`
	`239`	`+ if (vector == NULL)`
`230`	`240`	`{`
`231`	`241`	`return(NULL);`
`232`	`242`	`}`
`@@ -248,7 +258,7 @@ bool vector_prepend(struct Vector vector, void item)`
`248`	`258`
`249`	`259`	`bool vector_insert(struct Vector vector, size_t index, void item)`
`250`	`260`	`{`
`251`		`- if (vector_is_released(vector))`
	`261`	`+ if (vector == NULL)`
`252`	`262`	`{`
`253`	`263`	`return(false);`
`254`	`264`	`}`
`@@ -294,7 +304,7 @@ bool vector_insert(struct Vector vector, size_t index, void item)`
`294`	`304`
`295`	`305`	`void vector_remove(struct Vector vector, size_t index)`
`296`	`306`	`{`
`297`		`- if (vector_is_released(vector))`
	`307`	`+ if (vector == NULL)`
`298`	`308`	`{`
`299`	`309`	`return(NULL);`
`300`	`310`	`}`
`@@ -320,7 +330,7 @@ void vector_remove(struct Vector vector, size_t index)`
`320`	`330`
`321`	`331`	`static bool _vector_clear(struct Vector *vector)`
`322`	`332`	`{`
`323`		`- if (vector_is_released(vector))`
	`333`	`+ if (vector == NULL)`
`324`	`334`	`{`
`325`	`335`	`return(false);`
`326`	`336`	`}`
`@@ -353,6 +363,11 @@ static bool _vector_clear(struct Vector *vector)`
`353`	`363`
`354`	`364`	`static bool _vector_set_capacity_with_buffer(struct Vector *vector, size_t min_size)`
`355`	`365`	`{`
	`366`	`+ if (vector == NULL)`
	`367`	`+ {`
	`368`	`+ return(false);`
	`369`	`+ }`
	`370`	`+`
`356`	`371`	`if (min_size > vector->capacity)`
`357`	`372`	`{`
`358`	`373`	`size_t new_size = vector->size * 2;`
`@@ -372,7 +387,7 @@ static bool _vector_set_capacity_with_buffer(struct Vector *vector, size_t min_s`
`372`	`387`
`373`	`388`	`static bool _vector_set_capacity(struct Vector *vector, const size_t size)`
`374`	`389`	`{`
`375`		`- if (!vector->allow_resize)`
	`390`	`+ if (vector == NULL \|\| !vector->allow_resize)`
`376`	`391`	`{`
`377`	`392`	`return(false);`
`378`	`393`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ void test_impl()`
`6`	`6`	`{`
`7`	`7`	`struct Vector *vector = vector_new();`
`8`	`8`
`9`		`- assert_true(!vector_is_released(vector));`
`10`	`9`	`assert_true(vector_is_empty(vector));`
`11`	`10`	`assert_num_equal(vector_size(vector), 0);`
`12`	`11`	`assert_num_equal(vector_capacity(vector), 20);`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ void test_impl()`
`6`	`6`	`{`
`7`	`7`	`struct Vector *vector = vector_new_with_options(50, false);`
`8`	`8`
`9`		`- assert_true(!vector_is_released(vector));`
`10`	`9`	`assert_true(vector_is_empty(vector));`
`11`	`10`	`assert_num_equal(vector_size(vector), 0);`
`12`	`11`	`assert_num_equal(vector_capacity(vector), 50);`