refactor: [bits,dsa] Use tests.h

Author: manid2

cpp/bits/shift-gt-type-width.cpp

@@ -10,47 +10,54 @@
 
 #include "tests.h"
 
+/* ===========================================================================
+ * Algorithms implementation
+ * ===========================================================================
+ */
 template <class T>
-constexpr bitset<sizeof(size_t) * 8> bits(T x)
+constexpr bitset<sizeof(T) * 8> bits(T x)
 {
-	return bitset<sizeof(size_t) * 8>(x);
+	return bitset<sizeof(T) * 8>(x);
 }
 
 #define nbits(x) (sizeof(x) * 8)
+#define b2s(x)   bits(x).to_string()
+#define sb(x, i) x << (nbits(x) - i)
 
 template <class T>
-inline void check(T x)
+T check(T x, string &im, string &om)
 {
-	if (getenv("SHOW_TEST_OUTPUT")) {
-		cout << "Testing implementation " << 1 << " "
-		     << "Bit shifting more than type width"
-		     << "\n"
-		     << "  test-0:  "
-		     << "\n"
-		     << "    input  x: " << bits(x)
-		     << " sizeof(x): " << nbits(x) << "\n"
-		     << "    output:  "
-		     << "\n";
+	T r;
+	im = format("x: {}, sizeof(x): {}", b2s(x), nbits(x));
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wshift-count-overflow"
-		cout << "       x << sizeof(x): " << bits(x << nbits(x))
-		     << "\n"
-		     << "       x << (sizeof(x) + 1): "
-		     << bits(x << (nbits(x) + 1)) << "\n";
+	om = format("x << (sizeof(x) - 1): {},  x << sizeof(x): {}",
+	            b2s(sb(x, 1)), b2s(sb(x, 0)));
+	r = sb(x, 0);
 #pragma GCC diagnostic pop
+	return r;
+}
 
-		cout << endl;
+/* ===========================================================================
+ * Test code
+ * ===========================================================================
+ */
+#define _bsg_check(T)                                                        \
+	{                                                                    \
+		T i = 1, a = i, e = 0;                                       \
+		string im, om;                                               \
+		a = check(a, im, om);                                        \
+		CHECK_EQ(e, a);                                              \
+		SHOW_OUTPUT(im, om);                                         \
 	}
-}
 
-int main(int, char **)
+TEST(check, "Bit shifting more than type width (undefined behavior)")
 {
-	size_t a = 1;
-
-	check(a);
-
-	cout << "Executed " << 1 << " implementations"
-	     << " with " << 1 << " tests." << endl;
-	return 0;
+	_bsg_check(char);
+	_bsg_check(short);
+	_bsg_check(int);
+	_bsg_check(size_t);
 }
+
+INIT_TEST_MAIN();

cpp/dsa/lru_cache.cpp

@@ -1,5 +1,18 @@
+/**
+ * Least Recently Used (LRU) Cache
+ * ===============================
+ *
+ * Refer:
+ *
+ * https://leetcode.com/problems/lru-cache
+ */
+
 #include "tests.h"
 
+/* ===========================================================================
+ * Algorithms implementation
+ * ===========================================================================
+ */
 struct Node;
 using NodePtr = Node *;
 
@@ -79,8 +92,51 @@ class LRUCache
 	NodePtr head, tail; // anchor nodes
 };
 
-int main(int, char **)
+/* ===========================================================================
+ * Test code
+ * ===========================================================================
+ */
+string to_string(const vector<string> &c, const vi2_t &d)
+{
+	int n = size(c), i = 0;
+	string im = format("LRUCache({})", d[i++][0]);
+	for (; i < n; i++) {
+		im += format(", {}", c[i]);
+		int k = d[i][0];
+		if (c[i] == "put") {
+			int v = d[i][1];
+			im += format("({}, {})", k, v);
+		} else if (c[i] == "get")
+			im += format("({})", k);
+	}
+	return im;
+}
+
+#define _lru_check(c, d, e)                                                  \
+	{                                                                    \
+		int n = size(c), i = 0;                                      \
+		LRUCache cch(d[i++][0]);                                     \
+		vi_t a;                                                      \
+		for (; i < n; i++) {                                         \
+			int k = d[i][0];                                     \
+			if (c[i] == "put") {                                 \
+				int v = d[i][1];                             \
+				cch.put(k, v);                               \
+			} else if (c[i] == "get")                            \
+				a.push_back(cch.get(k));                     \
+		}                                                            \
+		CHECK_EQ(e, a);                                              \
+		SHOW_OUTPUT(to_string(c, d), a);                             \
+	}
+
+TEST(LRUCache, "Least Recently Used (LRU) Cache")
 {
-	cout << "Executed 1 implementations with 1 tests." << endl;
-	return 0;
+	vector<string> _c = {"LRUCache", "put", "put", "get", "put",
+	                     "get",      "put", "get", "get", "get"};
+	vi2_t _d = {{2}, {1, 1}, {2, 2}, {1}, {3, 3},
+	            {2}, {4, 4}, {1},    {3}, {4}};
+	vi_t _e = {1, -1, -1, 3, 4};
+	_lru_check(_c, _d, _e);
 }
+
+INIT_TEST_MAIN();