NULL array after freeing in cvec_free functions

rswinkle · rswinkle · commit 1d284db1e093 · 2025-01-03T20:07:26.000-07:00
Bump to 4.2.1
Change Copyright to 2025
diff --git a/Doxyfile b/Doxyfile
@@ -32,7 +32,7 @@ PROJECT_NAME           = CVector
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = 4.2.0
+PROJECT_NUMBER         = 4.2.1
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description 
 # for a project that appears at the top of each page and should give viewer 
diff --git a/LICENSE b/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2011-2024 Robert Winkler
+Copyright (c) 2011-2025 Robert Winkler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without limitation
diff --git a/README.md b/README.md
@@ -150,7 +150,7 @@ LICENSE
 =======
 CVector is licensed under the MIT License.
 
-Copyright (c) 2011-2024 Robert Winkler
+Copyright (c) 2011-2025 Robert Winkler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without limitation
diff --git a/cvector.h b/cvector.h
@@ -1,6 +1,6 @@
 /*
 
-CVector 4.2.0 MIT Licensed vector (dynamic array) library in strict C89
+CVector 4.2.1 MIT Licensed vector (dynamic array) library in strict C89
 http://www.robertwinkler.com/projects/cvector.html
 http://www.robertwinkler.com/projects/cvector/
 
@@ -16,7 +16,7 @@ more practical examples:
 
 The MIT License (MIT)
 
-Copyright (c) 2011-2024 Robert Winkler
+Copyright (c) 2011-2025 Robert Winkler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without limitation
@@ -602,6 +602,7 @@ void cvec_free_void(void* vec);
   {                                                                                         \
     cvector_##TYPE* tmp = (cvector_##TYPE*)vec;                                             \
     CVEC_FREE(tmp->a);                                                                      \
+    tmp->a        = NULL;                                                                   \
     tmp->size     = 0;                                                                      \
     tmp->capacity = 0;                                                                      \
   }
@@ -1171,7 +1172,7 @@ void cvec_free_void(void* vec);
     }                                                                                            \
                                                                                                  \
     CVEC_FREE(tmp->a);                                                                           \
-                                                                                                 \
+    tmp->a        = NULL;                                                                        \
     tmp->size     = 0;                                                                           \
     tmp->capacity = 0;                                                                           \
   }
@@ -1513,11 +1514,13 @@ void cvec_free_i_heap(void* vec)
 	CVEC_FREE(tmp);
 }
 
-/** Frees the internal array and sets size and capacity to 0 */
+/** Frees the internal array and zeros out the members to maintain a
+ * consistent state */
 void cvec_free_i(void* vec)
 {
 	cvector_i* tmp = (cvector_i*)vec;
 	CVEC_FREE(tmp->a);
+	tmp->a = NULL;
 	tmp->size = 0;
 	tmp->capacity = 0;
 }
@@ -1852,11 +1855,14 @@ void cvec_free_d_heap(void* vec)
 	CVEC_FREE(tmp);
 }
 
-/** Frees the internal array and sets size and capacity to 0 */
+/** Frees the internal array and zeros out the members to maintain a
+ * consistent state */
 void cvec_free_d(void* vec)
 {
 	cvector_d* tmp = (cvector_d*)vec;
-	CVEC_FREE(tmp->a); tmp->size = 0;
+	CVEC_FREE(tmp->a);
+	tmp->a = NULL;
+	tmp->size = 0;
 	tmp->capacity = 0;
 }
 #endif
@@ -2354,7 +2360,8 @@ void cvec_free_str_heap(void* vec)
 	CVEC_FREE(tmp);
 }
 
-/** Frees the internal array and sets size and capacity to 0 */
+/** Frees the internal array and zeros out the members to maintain a
+ * consistent state */
 void cvec_free_str(void* vec)
 {
 	cvec_sz i;
@@ -2364,6 +2371,7 @@ void cvec_free_str(void* vec)
 	}
 	
 	CVEC_FREE(tmp->a);
+	tmp->a = NULL;
 	tmp->size = 0;
 	tmp->capacity = 0;
 }
@@ -3008,7 +3016,8 @@ void cvec_free_void_heap(void* vec)
 	CVEC_FREE(tmp);
 }
 
-/** Frees the internal array and sets size and capacity to 0 */
+/** Frees the internal array and sets it, size, and capacity to NULL/0 to
+ * maintain a consistent state */
 void cvec_free_void(void* vec)
 {
 	cvec_sz i;
@@ -3020,7 +3029,7 @@ void cvec_free_void(void* vec)
 	}
 
 	CVEC_FREE(tmp->a);
-
+	tmp->a = NULL;
 	tmp->size = 0;
 	tmp->capacity = 0;
 }
@@ -3185,7 +3194,7 @@ action and how it should behave, look at cvector_tests.c
 \section LICENSE
 CVector is licensed under the MIT License.
 
-Copyright (c) 2011-2024 Robert Winkler
+Copyright (c) 2011-2025 Robert Winkler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without limitation
diff --git a/cvector_d.c b/cvector_d.c
@@ -353,10 +353,13 @@ void cvec_free_d_heap(void* vec)
 	CVEC_FREE(tmp);
 }
 
-/** Frees the internal array and sets size and capacity to 0 */
+/** Frees the internal array and zeros out the members to maintain a
+ * consistent state */
 void cvec_free_d(void* vec)
 {
 	cvector_d* tmp = (cvector_d*)vec;
-	CVEC_FREE(tmp->a); tmp->size = 0;
+	CVEC_FREE(tmp->a);
+	tmp->a = NULL;
+	tmp->size = 0;
 	tmp->capacity = 0;
 }
diff --git a/cvector_f_struct.h b/cvector_f_struct.h
@@ -1,6 +1,6 @@
 /*
 
-CVector 4.2.0 MIT Licensed vector (dynamic array) library in strict C89
+CVector 4.2.1 MIT Licensed vector (dynamic array) library in strict C89
 http://www.robertwinkler.com/projects/cvector.html
 http://www.robertwinkler.com/projects/cvector/
 
@@ -16,7 +16,7 @@ more practical examples:
 
 The MIT License (MIT)
 
-Copyright (c) 2011-2024 Robert Winkler
+Copyright (c) 2011-2025 Robert Winkler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without limitation
@@ -647,7 +647,7 @@ void cvec_free_f_struct(void* vec)
 	}
 
 	CVEC_FREE(tmp->a);
-
+	tmp->a = NULL;
 	tmp->size = 0;
 	tmp->capacity = 0;
 }
diff --git a/cvector_i.c b/cvector_i.c
@@ -354,11 +354,13 @@ void cvec_free_i_heap(void* vec)
 	CVEC_FREE(tmp);
 }
 
-/** Frees the internal array and sets size and capacity to 0 */
+/** Frees the internal array and zeros out the members to maintain a
+ * consistent state */
 void cvec_free_i(void* vec)
 {
 	cvector_i* tmp = (cvector_i*)vec;
 	CVEC_FREE(tmp->a);
+	tmp->a = NULL;
 	tmp->size = 0;
 	tmp->capacity = 0;
 }
diff --git a/cvector_macro.h b/cvector_macro.h
@@ -1,6 +1,6 @@
 /*
 
-CVector 4.2.0 MIT Licensed vector (dynamic array) library in strict C89
+CVector 4.2.1 MIT Licensed vector (dynamic array) library in strict C89
 http://www.robertwinkler.com/projects/cvector.html
 http://www.robertwinkler.com/projects/cvector/
 
@@ -16,7 +16,7 @@ more practical examples:
 
 The MIT License (MIT)
 
-Copyright (c) 2011-2024 Robert Winkler
+Copyright (c) 2011-2025 Robert Winkler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without limitation
@@ -376,6 +376,7 @@ typedef CVEC_SIZE_TYPE cvec_sz;
   {                                                                                         \
     cvector_##TYPE* tmp = (cvector_##TYPE*)vec;                                             \
     CVEC_FREE(tmp->a);                                                                      \
+    tmp->a        = NULL;                                                                   \
     tmp->size     = 0;                                                                      \
     tmp->capacity = 0;                                                                      \
   }
@@ -945,7 +946,7 @@ typedef CVEC_SIZE_TYPE cvec_sz;
     }                                                                                            \
                                                                                                  \
     CVEC_FREE(tmp->a);                                                                           \
-                                                                                                 \
+    tmp->a        = NULL;                                                                        \
     tmp->size     = 0;                                                                           \
     tmp->capacity = 0;                                                                           \
   }
diff --git a/cvector_short.h b/cvector_short.h
@@ -1,6 +1,6 @@
 /*
 
-CVector 4.2.0 MIT Licensed vector (dynamic array) library in strict C89
+CVector 4.2.1 MIT Licensed vector (dynamic array) library in strict C89
 http://www.robertwinkler.com/projects/cvector.html
 http://www.robertwinkler.com/projects/cvector/
 
@@ -16,7 +16,7 @@ more practical examples:
 
 The MIT License (MIT)
 
-Copyright (c) 2011-2024 Robert Winkler
+Copyright (c) 2011-2025 Robert Winkler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without limitation
@@ -392,6 +392,7 @@ void cvec_free_short(void* vec)
 {
 	cvector_short* tmp = (cvector_short*)vec;
 	CVEC_FREE(tmp->a);
+	tmp->a = NULL;
 	tmp->size = 0;
 	tmp->capacity = 0;
 }
diff --git a/cvector_str.c b/cvector_str.c
@@ -518,7 +518,8 @@ void cvec_free_str_heap(void* vec)
 	CVEC_FREE(tmp);
 }
 
-/** Frees the internal array and sets size and capacity to 0 */
+/** Frees the internal array and zeros out the members to maintain a
+ * consistent state */
 void cvec_free_str(void* vec)
 {
 	cvec_sz i;
@@ -528,6 +529,7 @@ void cvec_free_str(void* vec)
 	}
 	
 	CVEC_FREE(tmp->a);
+	tmp->a = NULL;
 	tmp->size = 0;
 	tmp->capacity = 0;
 }
diff --git a/cvector_template.h b/cvector_template.h
@@ -358,6 +358,7 @@ void cvec_free_TYPE(void* vec)
 {
 	cvector_TYPE* tmp = (cvector_TYPE*)vec;
 	CVEC_FREE(tmp->a);
+	tmp->a = NULL;
 	tmp->size = 0;
 	tmp->capacity = 0;
 }
diff --git a/cvector_template2.h b/cvector_template2.h
@@ -613,7 +613,7 @@ void cvec_free_TYPE(void* vec)
 	}
 
 	CVEC_FREE(tmp->a);
-
+	tmp->a = NULL;
 	tmp->size = 0;
 	tmp->capacity = 0;
 }
diff --git a/cvector_tests.c b/cvector_tests.c
@@ -116,7 +116,7 @@ void erase_i_test()
 	cvec_free_i(&vec);
 }
 
-/* zeroing is valid initialization */
+/* zeroing is valid initialization and cvec_free_i returns to this state */
 void zero_init_i_test()
 {
 	int i;
@@ -138,6 +138,9 @@ void zero_init_i_test()
 		CU_ASSERT_EQUAL(i, vec.a[i]);
 
 	cvec_free_i(&vec);
+	CU_ASSERT(vec.capacity == 0)
+	CU_ASSERT(vec.size == 0)
+	CU_ASSERT(vec.a == NULL)
 }
 
 
@@ -391,7 +394,7 @@ void erase_d_test()
 	cvec_free_d(&vec);
 }
 
-/* zeroing is valid initialization */
+/* zeroing is valid initialization and cvec_free_d returns to this state */
 void zero_init_d_test()
 {
 	int i;
@@ -413,6 +416,9 @@ void zero_init_d_test()
 		CU_ASSERT_EQUAL(i+0.5, vec.a[i]);
 
 	cvec_free_d(&vec);
+	CU_ASSERT(vec.capacity == 0)
+	CU_ASSERT(vec.size == 0)
+	CU_ASSERT(vec.a == NULL)
 }
 
 void insert_d_test()
@@ -700,7 +706,7 @@ void remove_str_test()
 
 }
 
-/* zeroing is valid initialization */
+/* zeroing is valid initialization and cvec_free_s returns to this state */
 void zero_init_str_test()
 {
 	int i;
@@ -727,6 +733,9 @@ void zero_init_str_test()
 	}
 
 	cvec_free_str(&vec);
+	CU_ASSERT(vec.capacity == 0)
+	CU_ASSERT(vec.size == 0)
+	CU_ASSERT(vec.a == NULL)
 }
 
 
@@ -1392,6 +1401,12 @@ void zero_init_void_test()
 
 	cvec_free_void(&vec1);
 	cvec_free_void(&vec2);
+	CU_ASSERT(vec1.capacity == 0)
+	CU_ASSERT(vec1.size == 0)
+	CU_ASSERT(vec1.a == NULL)
+	CU_ASSERT(vec2.capacity == 0)
+	CU_ASSERT(vec2.size == 0)
+	CU_ASSERT(vec2.a == NULL)
 }
 
 
@@ -1986,6 +2001,9 @@ void template_test()
 		CU_ASSERT_EQUAL(i, vec.a[i]);
 
 	cvec_free_short(&vec);
+	CU_ASSERT(vec.capacity == 0)
+	CU_ASSERT(vec.size == 0)
+	CU_ASSERT(vec.a == NULL)
 }
 
 void template_test2()
@@ -2194,6 +2212,9 @@ void template_test2()
 	CU_ASSERT_EQUAL(vec.size, 101);
 
 	cvec_free_f_struct(&vec);
+	CU_ASSERT(vec.capacity == 0)
+	CU_ASSERT(vec.size == 0)
+	CU_ASSERT(vec.a == NULL)
 }
 
 
diff --git a/cvector_void.c b/cvector_void.c
diff --git a/header_docs.txt b/header_docs.txt
diff --git a/testoutput/CUnitAutomated-Results.xml b/testoutput/CUnitAutomated-Results.xml

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`/*`
`2`	`2`
`3`		`-CVector 4.2.0 MIT Licensed vector (dynamic array) library in strict C89`
	`3`	`+CVector 4.2.1 MIT Licensed vector (dynamic array) library in strict C89`
`4`	`4`	`http://www.robertwinkler.com/projects/cvector.html`
`5`	`5`	`http://www.robertwinkler.com/projects/cvector/`
`6`	`6`
`@@ -16,7 +16,7 @@ more practical examples:`
`16`	`16`
`17`	`17`	`The MIT License (MIT)`
`18`	`18`
`19`		`-Copyright (c) 2011-2024 Robert Winkler`
	`19`	`+Copyright (c) 2011-2025 Robert Winkler`
`20`	`20`
`21`	`21`	`Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated`
`22`	`22`	`documentation files (the "Software"), to deal in the Software without restriction, including without limitation`
`@@ -602,6 +602,7 @@ void cvec_free_void(void* vec);`
`602`	`602`	`{ \`
`603`	`603`	`cvector_##TYPE* tmp = (cvector_##TYPE*)vec; \`
`604`	`604`	`CVEC_FREE(tmp->a); \`
	`605`	`+ tmp->a = NULL; \`
`605`	`606`	`tmp->size = 0; \`
`606`	`607`	`tmp->capacity = 0; \`
`607`	`608`	`}`
`@@ -1171,7 +1172,7 @@ void cvec_free_void(void* vec);`
`1171`	`1172`	`} \`
`1172`	`1173`	`\`
`1173`	`1174`	`CVEC_FREE(tmp->a); \`
`1174`		`- \`
	`1175`	`+ tmp->a = NULL; \`
`1175`	`1176`	`tmp->size = 0; \`
`1176`	`1177`	`tmp->capacity = 0; \`
`1177`	`1178`	`}`
`@@ -1513,11 +1514,13 @@ void cvec_free_i_heap(void* vec)`
`1513`	`1514`	`CVEC_FREE(tmp);`
`1514`	`1515`	`}`
`1515`	`1516`
`1516`		`-/** Frees the internal array and sets size and capacity to 0 */`
	`1517`	`+/** Frees the internal array and zeros out the members to maintain a`
	`1518`	`+ * consistent state */`
`1517`	`1519`	`void cvec_free_i(void* vec)`
`1518`	`1520`	`{`
`1519`	`1521`	`cvector_i* tmp = (cvector_i*)vec;`
`1520`	`1522`	`CVEC_FREE(tmp->a);`
	`1523`	`+ tmp->a = NULL;`
`1521`	`1524`	`tmp->size = 0;`
`1522`	`1525`	`tmp->capacity = 0;`
`1523`	`1526`	`}`
`@@ -1852,11 +1855,14 @@ void cvec_free_d_heap(void* vec)`
`1852`	`1855`	`CVEC_FREE(tmp);`
`1853`	`1856`	`}`
`1854`	`1857`
`1855`		`-/** Frees the internal array and sets size and capacity to 0 */`
	`1858`	`+/** Frees the internal array and zeros out the members to maintain a`
	`1859`	`+ * consistent state */`
`1856`	`1860`	`void cvec_free_d(void* vec)`
`1857`	`1861`	`{`
`1858`	`1862`	`cvector_d* tmp = (cvector_d*)vec;`
`1859`		`- CVEC_FREE(tmp->a); tmp->size = 0;`
	`1863`	`+ CVEC_FREE(tmp->a);`
	`1864`	`+ tmp->a = NULL;`
	`1865`	`+ tmp->size = 0;`
`1860`	`1866`	`tmp->capacity = 0;`
`1861`	`1867`	`}`
`1862`	`1868`	`#endif`
`@@ -2354,7 +2360,8 @@ void cvec_free_str_heap(void* vec)`
`2354`	`2360`	`CVEC_FREE(tmp);`
`2355`	`2361`	`}`
`2356`	`2362`
`2357`		`-/** Frees the internal array and sets size and capacity to 0 */`
	`2363`	`+/** Frees the internal array and zeros out the members to maintain a`
	`2364`	`+ * consistent state */`
`2358`	`2365`	`void cvec_free_str(void* vec)`
`2359`	`2366`	`{`
`2360`	`2367`	`cvec_sz i;`
`@@ -2364,6 +2371,7 @@ void cvec_free_str(void* vec)`
`2364`	`2371`	`}`
`2365`	`2372`
`2366`	`2373`	`CVEC_FREE(tmp->a);`
	`2374`	`+ tmp->a = NULL;`
`2367`	`2375`	`tmp->size = 0;`
`2368`	`2376`	`tmp->capacity = 0;`
`2369`	`2377`	`}`
`@@ -3008,7 +3016,8 @@ void cvec_free_void_heap(void* vec)`
`3008`	`3016`	`CVEC_FREE(tmp);`
`3009`	`3017`	`}`
`3010`	`3018`
`3011`		`-/** Frees the internal array and sets size and capacity to 0 */`
	`3019`	`+/** Frees the internal array and sets it, size, and capacity to NULL/0 to`
	`3020`	`+ * maintain a consistent state */`
`3012`	`3021`	`void cvec_free_void(void* vec)`
`3013`	`3022`	`{`
`3014`	`3023`	`cvec_sz i;`
`@@ -3020,7 +3029,7 @@ void cvec_free_void(void* vec)`
`3020`	`3029`	`}`
`3021`	`3030`
`3022`	`3031`	`CVEC_FREE(tmp->a);`
`3023`		`-`
	`3032`	`+ tmp->a = NULL;`
`3024`	`3033`	`tmp->size = 0;`
`3025`	`3034`	`tmp->capacity = 0;`
`3026`	`3035`	`}`
`@@ -3185,7 +3194,7 @@ action and how it should behave, look at cvector_tests.c`
`3185`	`3194`	`\section LICENSE`
`3186`	`3195`	`CVector is licensed under the MIT License.`
`3187`	`3196`
`3188`		`-Copyright (c) 2011-2024 Robert Winkler`
	`3197`	`+Copyright (c) 2011-2025 Robert Winkler`
`3189`	`3198`
`3190`	`3199`	`Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated`
`3191`	`3200`	`documentation files (the "Software"), to deal in the Software without restriction, including without limitation`
Original file line number	Diff line number	Diff line change
`@@ -353,10 +353,13 @@ void cvec_free_d_heap(void* vec)`
`353`	`353`	`CVEC_FREE(tmp);`
`354`	`354`	`}`
`355`	`355`
`356`		`-/** Frees the internal array and sets size and capacity to 0 */`
	`356`	`+/** Frees the internal array and zeros out the members to maintain a`
	`357`	`+ * consistent state */`
`357`	`358`	`void cvec_free_d(void* vec)`
`358`	`359`	`{`
`359`	`360`	`cvector_d* tmp = (cvector_d*)vec;`
`360`		`- CVEC_FREE(tmp->a); tmp->size = 0;`
	`361`	`+ CVEC_FREE(tmp->a);`
	`362`	`+ tmp->a = NULL;`
	`363`	`+ tmp->size = 0;`
`361`	`364`	`tmp->capacity = 0;`
`362`	`365`	`}`
Original file line number	Diff line number	Diff line change
`@@ -354,11 +354,13 @@ void cvec_free_i_heap(void* vec)`
`354`	`354`	`CVEC_FREE(tmp);`
`355`	`355`	`}`
`356`	`356`
`357`		`-/** Frees the internal array and sets size and capacity to 0 */`
	`357`	`+/** Frees the internal array and zeros out the members to maintain a`
	`358`	`+ * consistent state */`
`358`	`359`	`void cvec_free_i(void* vec)`
`359`	`360`	`{`
`360`	`361`	`cvector_i* tmp = (cvector_i*)vec;`
`361`	`362`	`CVEC_FREE(tmp->a);`
	`363`	`+ tmp->a = NULL;`
`362`	`364`	`tmp->size = 0;`
`363`	`365`	`tmp->capacity = 0;`
`364`	`366`	`}`
Original file line number	Diff line number	Diff line change
`@@ -518,7 +518,8 @@ void cvec_free_str_heap(void* vec)`
`518`	`518`	`CVEC_FREE(tmp);`
`519`	`519`	`}`
`520`	`520`
`521`		`-/** Frees the internal array and sets size and capacity to 0 */`
	`521`	`+/** Frees the internal array and zeros out the members to maintain a`
	`522`	`+ * consistent state */`
`522`	`523`	`void cvec_free_str(void* vec)`
`523`	`524`	`{`
`524`	`525`	`cvec_sz i;`
`@@ -528,6 +529,7 @@ void cvec_free_str(void* vec)`
`528`	`529`	`}`
`529`	`530`
`530`	`531`	`CVEC_FREE(tmp->a);`
	`532`	`+ tmp->a = NULL;`
`531`	`533`	`tmp->size = 0;`
`532`	`534`	`tmp->capacity = 0;`
`533`	`535`	`}`
Original file line number	Diff line number	Diff line change
`@@ -358,6 +358,7 @@ void cvec_free_TYPE(void* vec)`
`358`	`358`	`{`
`359`	`359`	`cvector_TYPE* tmp = (cvector_TYPE*)vec;`
`360`	`360`	`CVEC_FREE(tmp->a);`
	`361`	`+ tmp->a = NULL;`
`361`	`362`	`tmp->size = 0;`
`362`	`363`	`tmp->capacity = 0;`
`363`	`364`	`}`
Original file line number	Diff line number	Diff line change
`@@ -613,7 +613,7 @@ void cvec_free_TYPE(void* vec)`
`613`	`613`	`}`
`614`	`614`
`615`	`615`	`CVEC_FREE(tmp->a);`
`616`		`-`
	`616`	`+ tmp->a = NULL;`
`617`	`617`	`tmp->size = 0;`
`618`	`618`	`tmp->capacity = 0;`
`619`	`619`	`}`
Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ void erase_i_test()`
`116`	`116`	`cvec_free_i(&vec);`
`117`	`117`	`}`
`118`	`118`
`119`		`-/* zeroing is valid initialization */`
	`119`	`+/* zeroing is valid initialization and cvec_free_i returns to this state */`
`120`	`120`	`void zero_init_i_test()`
`121`	`121`	`{`
`122`	`122`	`int i;`
`@@ -138,6 +138,9 @@ void zero_init_i_test()`
`138`	`138`	`CU_ASSERT_EQUAL(i, vec.a[i]);`
`139`	`139`
`140`	`140`	`cvec_free_i(&vec);`
	`141`	`+ CU_ASSERT(vec.capacity == 0)`
	`142`	`+ CU_ASSERT(vec.size == 0)`
	`143`	`+ CU_ASSERT(vec.a == NULL)`
`141`	`144`	`}`
`142`	`145`
`143`	`146`
`@@ -391,7 +394,7 @@ void erase_d_test()`
`391`	`394`	`cvec_free_d(&vec);`
`392`	`395`	`}`
`393`	`396`
`394`		`-/* zeroing is valid initialization */`
	`397`	`+/* zeroing is valid initialization and cvec_free_d returns to this state */`
`395`	`398`	`void zero_init_d_test()`
`396`	`399`	`{`
`397`	`400`	`int i;`
`@@ -413,6 +416,9 @@ void zero_init_d_test()`
`413`	`416`	`CU_ASSERT_EQUAL(i+0.5, vec.a[i]);`
`414`	`417`
`415`	`418`	`cvec_free_d(&vec);`
	`419`	`+ CU_ASSERT(vec.capacity == 0)`
	`420`	`+ CU_ASSERT(vec.size == 0)`
	`421`	`+ CU_ASSERT(vec.a == NULL)`
`416`	`422`	`}`
`417`	`423`
`418`	`424`	`void insert_d_test()`
`@@ -700,7 +706,7 @@ void remove_str_test()`
`700`	`706`
`701`	`707`	`}`
`702`	`708`
`703`		`-/* zeroing is valid initialization */`
	`709`	`+/* zeroing is valid initialization and cvec_free_s returns to this state */`
`704`	`710`	`void zero_init_str_test()`
`705`	`711`	`{`
`706`	`712`	`int i;`
`@@ -727,6 +733,9 @@ void zero_init_str_test()`
`727`	`733`	`}`
`728`	`734`
`729`	`735`	`cvec_free_str(&vec);`
	`736`	`+ CU_ASSERT(vec.capacity == 0)`
	`737`	`+ CU_ASSERT(vec.size == 0)`
	`738`	`+ CU_ASSERT(vec.a == NULL)`
`730`	`739`	`}`
`731`	`740`
`732`	`741`
`@@ -1392,6 +1401,12 @@ void zero_init_void_test()`
`1392`	`1401`
`1393`	`1402`	`cvec_free_void(&vec1);`
`1394`	`1403`	`cvec_free_void(&vec2);`
	`1404`	`+ CU_ASSERT(vec1.capacity == 0)`
	`1405`	`+ CU_ASSERT(vec1.size == 0)`
	`1406`	`+ CU_ASSERT(vec1.a == NULL)`
	`1407`	`+ CU_ASSERT(vec2.capacity == 0)`
	`1408`	`+ CU_ASSERT(vec2.size == 0)`
	`1409`	`+ CU_ASSERT(vec2.a == NULL)`
`1395`	`1410`	`}`
`1396`	`1411`
`1397`	`1412`
`@@ -1986,6 +2001,9 @@ void template_test()`
`1986`	`2001`	`CU_ASSERT_EQUAL(i, vec.a[i]);`
`1987`	`2002`
`1988`	`2003`	`cvec_free_short(&vec);`
	`2004`	`+ CU_ASSERT(vec.capacity == 0)`
	`2005`	`+ CU_ASSERT(vec.size == 0)`
	`2006`	`+ CU_ASSERT(vec.a == NULL)`
`1989`	`2007`	`}`
`1990`	`2008`
`1991`	`2009`	`void template_test2()`
`@@ -2194,6 +2212,9 @@ void template_test2()`
`2194`	`2212`	`CU_ASSERT_EQUAL(vec.size, 101);`
`2195`	`2213`
`2196`	`2214`	`cvec_free_f_struct(&vec);`
	`2215`	`+ CU_ASSERT(vec.capacity == 0)`
	`2216`	`+ CU_ASSERT(vec.size == 0)`
	`2217`	`+ CU_ASSERT(vec.a == NULL)`
`2197`	`2218`	`}`
`2198`	`2219`
`2199`	`2220`