tests/vector.c: Add most missing tests

1 files changed, 146 insertions, 24 deletions

diff --git a/tests/vector.c b/tests/vector.c
index 118651b..607a46a 100644
--- a/tests/vector.c
+++ b/tests/vector.c
@@ -185,10 +185,7 @@ test_vector_count(void) {
 		assert(v->count        == 0);
 
 		const unsigned long value = 123;
-		if (vector_push_back(v, &value)) {
-			logerr("vector_push_back()");
-			goto out;
-		}
+		assert(vector_push_back(v, &value) == 0);
 
 		assert(vector_count(v) == 1);
 		assert(v->count        == 1);
@@ -210,14 +207,82 @@ out:
 
 static void
 test_next_capacity(void) {
+	size_t capacity;
+
 	test_start("next_capacity()");
-	// FIXME: write tests
+	{
+		testing("noop multipliers");
+
+		capacity = next_capacity(&(struct Vector) {
+			.capacity     = 1U,
+			.multiplier   = 1U,
+			.max_capacity = 0U,
+		});
+		assert(capacity == 1U);
+
+		capacity = next_capacity(&(struct Vector) {
+			.capacity     = SIZE_MAX,
+			.multiplier   = 1U,
+			.max_capacity = 0U,
+		});
+		assert(capacity == SIZE_MAX);
+
+		capacity = next_capacity(&(struct Vector) {
+			.capacity     = 1U,
+			.multiplier   = SIZE_MAX,
+			.max_capacity = 0U,
+		});
+		assert(capacity == SIZE_MAX);
+
+		test_ok();
+	}
+	{
+		testing("small value");
+
+		capacity = next_capacity(&(struct Vector) {
+			.capacity     = 10U,
+			.multiplier   = 10U,
+			.max_capacity = 0U,
+		});
+		assert(capacity == 100U);
+
+		test_ok();
+	}
+	{
+		testing("big value");
+
+		capacity = next_capacity(&(struct Vector) {
+			.capacity     = SIZE_MAX / 4U,
+			.multiplier   = 4U,
+			.max_capacity = 0U,
+		});
+		assert(capacity == SIZE_MAX - 3U);
+
+		test_ok();
+	}
+	{
+		testing("big value with overflow");
+
+		capacity = next_capacity(&(struct Vector) {
+			.capacity     = SIZE_MAX / 2U,
+			.multiplier   = 3U,
+			.max_capacity = 0U,
+		});
+		assert(capacity == 0U);
+
+		test_ok();
+	}
 }
 
 static void
 test_next_size(void) {
 	test_start("next_size()");
-	// FIXME: write tests
+
+	{
+		testing("same as multiplication");
+		// FIXME:
+		test_ok();
+	}
 }
 
 static int
@@ -240,11 +305,9 @@ test_vector_nth(void) {
 			goto out;
 		}
 
+		assert(v->capacity >= values_len);
 		for (unsigned int i = 0; i < values_len; i++) {
-			if (vector_push_back(v, &values[i])) {
-				logerr("vector_push_back()");
-				goto out;
-			}
+			assert(vector_push_back(v, &values[i]) == 0);
 		}
 
 		int nth;
@@ -269,11 +332,9 @@ test_vector_nth(void) {
 			goto out;
 		}
 
+		assert(v->capacity >= values_len);
 		for (unsigned int i = 0; i < values_len; i++) {
-			if (vector_push_back(v, &values[i])) {
-				logerr("vector_push_back()");
-				goto out;
-			}
+			assert(vector_push_back(v, &values[i]) == 0);
 		}
 
 		int nth = 222;
@@ -313,10 +374,7 @@ test_vector_push_back(void) {
 		const long long before = 123;
 		const long long after  = 321;
 		v->values[0] = (void *)before;
-		if (vector_push_back(v, &after)) {
-			logerr("vector_push_back()");
-			goto out;
-		}
+		assert(vector_push_back(v, &after) == 0);
 		assert(v->values[0] == (void *)after);
 
 		vector_free(v);
@@ -337,17 +395,13 @@ test_vector_push_back(void) {
 		assert(vector_count(v) == 0);
 
 		for (unsigned int i = 0; i < v->capacity; i++) {
-			if (vector_push_back(v, &data)) {
-				logerr("vector_push_back()");
-				goto out;
-			}
+			assert(vector_push_back(v, &data) == 0);
 		}
 		assert(v->values[0] == (void *)data);
 
 		const size_t capacity = v->capacity;
 		assert(capacity == vector_count(v));
 
-		// we grow the vector here
 		if (vector_push_back(v, &data)) {
 			logerr("vector_push_back()");
 			goto out;
@@ -377,8 +431,76 @@ out:
 
 static int
 test_vector_pop_back(void) {
+	int rc = -1;
+
+	const struct Vector *v = NULL;
+
 	test_start("vector_pop_back()");
-	return 0;
+	{
+		testing("an empty vector underflows");
+
+		if (vector_new(sizeof(int), &v)) {
+			logerr("vector_new()");
+			goto out;
+		}
+
+		int val = 222;
+		assert(vector_pop_back(v, (void *)&val) != 0);
+		assert(val == 222);
+
+		vector_free(v);
+		v = NULL;
+
+		test_ok();
+	}
+	{
+		testing("a pop never shrinks a vector back");
+
+		const unsigned long long data = 1234U;
+		unsigned long long val = 0U;
+
+		if (vector_new(sizeof(data), &v)) {
+			logerr("vector_new()");
+			goto out;
+		}
+
+		const size_t capacity = v->capacity;
+		for (unsigned int i = 0U; i < capacity; i++) {
+			assert(vector_push_back(v, &data) == 0);
+		}
+
+		assert(v->values[0U]            == (void *)data);
+		assert(v->values[capacity - 1U] == (void *)data);
+		assert(capacity == vector_count(v));
+
+		if (vector_push_back(v, &data)) {
+			logerr("vector_push_back()");
+			goto out;
+		}
+		const size_t new_capacity = capacity * v->multiplier;
+		assert(v->capacity     == new_capacity);
+		assert(vector_count(v) == capacity + 1U);
+
+		for (unsigned int i = 0U; i < capacity + 1U; i++) {
+			val = 0U;
+			assert(vector_pop_back(v, (void *)&val) == 0);
+			assert(val == 1234U);
+		}
+
+		assert(vector_pop_back(v, (void *)&val) != 0);
+
+		vector_free(v);
+		v = NULL;
+		test_ok();
+	}
+
+	rc = 0;
+out:
+	if (v != NULL) {
+		vector_free(v);
+		v = NULL;
+	}
+	return rc;
 }
 
 static int