refactor: [arrays,design] Use tests.h

Author: manid2

cpp/arrays/pointers.cpp

@@ -1,33 +1,47 @@
 /**
  * Pointer operators precedence
+ * ============================
  */
 
-#include <stdio.h>
-#include <stdlib.h>
+#include "tests.h"
 
-void print_a(int *a, int n)
+/* ===========================================================================
+ * Algorithms implementation
+ * ===========================================================================
+ */
+#define _fmt(i, v) format("\n    index: {}, value: {}", i, v)
+
+vi_t ptrOpPrec(const int n, string &am)
 {
-	printf("a: ");
-	for (int i = 0; i < n; i++) { printf("%d ", a[i]); }
+	int *p = (int *)malloc(n * sizeof(int)), *a = p;
+	fii (i, n) *(p + i) = i;
+
+	ostringstream out;
+	out << _fmt(0, *p++);   // *a -> index: 0, value: 0, ptr++
+	out << _fmt(1, (*p)++); // *a -> index: 1, value: 1, val++
+	out << _fmt(1, *p);     // *a -> index: 1, value: 2
+	out << _fmt(2, *++p);   // *a -> index: 2, value: 2, ++ptr
+	out << _fmt(2, ++*p);   // *a -> index: 2, value: 3, ++val
+	// indices: 3, 4 with values: 3, 4 are unmodified
+	vi_t ret(a, a + n);
+	out << format("\n    after: {}", to_string(ret));
+	free(a);
+	am = out.str();
+	return ret;
 }
 
-int main(int argc, char *argv[])
+/* ===========================================================================
+ * Test code
+ * ===========================================================================
+ */
+TEST(ptrOpPrec, "Pointer operators precedence")
 {
-	int *ptr = (int *)malloc(5 * sizeof(int));
-	int *p = ptr;
-	for (int i = 0; i < 5; i++) *(ptr + i) = i;
-	print_a(p, 5);
-	printf("\tp: %d\n", *ptr++); // ptr -> index: 0, value: 0, ptr++
-	print_a(p, 5);
-	printf("\tp: %d\n", (*ptr)++); // ptr -> index: 1, value: 1, val++
-	print_a(p, 5);
-	printf("\tp: %d\n", *ptr); // ptr -> index: 1, value: 2
-	print_a(p, 5);
-	printf("\tp: %d\n", *++ptr); // ptr -> index: 2, value: 2, ++ptr
-	print_a(p, 5);
-	printf("\tp: %d\n", ++*ptr); // ptr -> index: 2, value: 3, ++val
-	print_a(p, 5); // indices: 3, 4 with values: 3, 4 are unmodified
-	printf("\n");
-	free(p);
-	return 0;
+	const int n = 5;
+	string am;
+	vi_t e = {0, 2, 3, 3, 4};
+	vi_t a = ptrOpPrec(n, am);
+	CHECK_EQ(e, a);
+	SHOW_OUTPUT(n, am);
 }
+
+INIT_TEST_MAIN();

cpp/design/memmove.cpp

@@ -1,27 +1,47 @@
-#include <stdio.h>
-
 /**
- * Implement overlapping memcpy () or memmove () function
+ * Memmove with overlapping range
+ * ==============================
  */
-static void *_memmove(void *dst, const void *src, size_t n)
+
+#include "tests.h"
+
+/* ===========================================================================
+ * Algorithms implementation
+ * ===========================================================================
+ */
+void _memmove(void *dst, const void *src, size_t n)
 {
-	char *psrc = (char *)src;
-	char *pdst = (char *)dst;
-	if (!psrc || !pdst) return NULL;
-	if ((psrc < pdst) && (pdst < psrc + n)) {
+	char *s = (char *)src, *d = (char *)dst;
+	if (!s || !d) return;
+	if ((s < d) && (d < s + n)) {
 		// Buffer overlaps so copy backwards
-		for (pdst += n, psrc += n; n--;) { *--pdst = *--psrc; }
+		for (d += n, s += n; n--;) *--d = *--s;
 	} else {
 		// No buffer overlap so copy forwards (normal)
-		while (n--) { *pdst++ = *psrc++; }
+		while (n--) *d++ = *s++;
 	}
-	return dst;
 }
 
-int main(int argc, char *argv[])
+/* ===========================================================================
+ * Test code
+ * ===========================================================================
+ */
+TEST(_memmove, "Memmove with overlapping range")
 {
-	char str[] = "abcde";
-	char *d = _memmove(str + 3, str, 3);
-	printf("d: %s\n", d);
-	return 0;
+	const int n = 3;
+	char s[] = "abcde";
+	string i(s), e(s, n);
+
+	char *d = s + n;
+	_memmove((void *)d, (void *)s, n);
+
+	string a(d, n);
+	CHECK_EQ(e, a);
+
+	int di = d - s - 1, si = s - &s[0];
+	string im;
+	im += format("arr = {}, dst = {}, src = {}, size = {}", i, di, si, n);
+	SHOW_OUTPUT(im, a);
 }
+
+INIT_TEST_MAIN();