CPP test case

jsinglet · jsinglet · commit adfb4f0a5449 · 2022-07-15T11:05:05.000-04:00
diff --git a/cpp/common/test/rules/preventdeadlockbylockinginpredefinedorder/PreventDeadlockByLockingInPredefinedOrder.expected b/cpp/common/test/rules/preventdeadlockbylockinginpredefinedorder/PreventDeadlockByLockingInPredefinedOrder.expected
@@ -0,0 +1,3 @@
+| test.cpp:30:5:30:6 | d2 | Threaded function may be called from a context that uses $@ and $@ which may lead to deadlocks. | test.cpp:31:41:31:49 | call to lock_guard | lock 1 | test.cpp:36:39:36:45 | call to lock_guard | lock 2 |
+| test.cpp:44:5:44:6 | d3 | Threaded function may be called from a context that uses $@ and $@ which may lead to deadlocks. | test.cpp:45:41:45:49 | call to lock_guard | lock 1 | test.cpp:50:39:50:45 | call to lock_guard | lock 2 |
+| test.cpp:86:5:86:6 | d5 | Threaded function may be called from a context that uses $@ and $@ which may lead to deadlocks. | test.cpp:103:41:103:49 | call to lock_guard | lock 1 | test.cpp:104:39:104:45 | call to lock_guard | lock 2 |
diff --git a/cpp/common/test/rules/preventdeadlockbylockinginpredefinedorder/PreventDeadlockByLockingInPredefinedOrder.ql b/cpp/common/test/rules/preventdeadlockbylockinginpredefinedorder/PreventDeadlockByLockingInPredefinedOrder.ql
@@ -0,0 +1,2 @@
+// GENERATED FILE - DO NOT MODIFY
+import codingstandards.cpp.rules.preventdeadlockbylockinginpredefinedorder.PreventDeadlockByLockingInPredefinedOrder
diff --git a/cpp/common/test/rules/preventdeadlockbylockinginpredefinedorder/test.cpp b/cpp/common/test/rules/preventdeadlockbylockinginpredefinedorder/test.cpp
@@ -0,0 +1,145 @@
+#include <mutex>
+#include <stdlib.h>
+#include <thread>
+
+class B {
+  int sum;
+
+public:
+  std::mutex mu;
+  B() = delete;
+  explicit B(int initialAmount) : sum(initialAmount) {}
+  int get() const { return sum; }
+  void set(int amount) { sum = amount; }
+};
+
+int d1(B *from, B *to, int amount) { // COMPLIANT
+  std::unique_lock<std::mutex> lk1(from->mu, std::defer_lock);
+  std::unique_lock<std::mutex> lk2(to->mu, std::defer_lock);
+
+  std::lock(lk1, lk2);
+
+  if (from->get() >= amount) {
+    from->set(from->get() - amount);
+    to->set(to->get() + amount);
+    return 0;
+  }
+  return -1;
+}
+
+int d2(B *from, B *to, int amount) { // NON_COMPLIANT
+  std::lock_guard<std::mutex> from_lock(from->mu);
+
+  if (from->get() < amount) {
+    return -1;
+  }
+  std::lock_guard<std::mutex> to_lock(to->mu);
+
+  from->set(from->get() - amount);
+  to->set(to->get() + amount);
+
+  return 0;
+}
+
+int d3(B *from, B *to, int amount) { // NON_COMPLIANT
+  std::lock_guard<std::mutex> from_lock(from->mu);
+
+  if (from->get() < amount) {
+    return -1;
+  }
+  std::lock_guard<std::mutex> to_lock(to->mu);
+
+  from->set(from->get() - amount);
+  to->set(to->get() + amount);
+
+  return 0;
+}
+
+int getA() { return 0; }
+
+int d4(B *from, B *to, int amount) { // COMPLIANT
+  std::mutex *one;
+  std::mutex *two;
+
+  int a = getA();
+
+  // here a may take on multiple different
+  // values and thus different values may flow
+  // into the locks
+  if (a == 9) {
+    one = &from->mu;
+    two = &to->mu;
+  } else {
+    one = &to->mu;
+    two = &from->mu;
+  }
+
+  std::lock_guard<std::mutex> from_lock(*one);
+  std::lock_guard<std::mutex> to_lock(*two);
+
+  from->set(from->get() - amount);
+  to->set(to->get() + amount);
+
+  return 0;
+}
+
+int d5(B *from, B *to, int amount) { // NON_COMPLIANT
+  std::mutex *one;
+  std::mutex *two;
+
+  int a = getA();
+
+  // here a may take on multiple different
+  // values and thus different values may flow
+  // into the locks
+  if (a == 9) {
+    one = &from->mu;
+    two = &to->mu;
+  } else {
+    one = &to->mu;
+    two = &from->mu;
+  }
+
+  std::lock_guard<std::mutex> from_lock(from->mu);
+  std::lock_guard<std::mutex> to_lock(to->mu);
+
+  from->set(from->get() - amount);
+  to->set(to->get() + amount);
+
+  return 0;
+}
+
+void f(B *ba1, B *ba2) {
+  std::thread thr1(d1, ba1, ba2, 100);
+  std::thread thr2(d1, ba2, ba1, 100);
+  thr1.join();
+  thr2.join();
+}
+
+void f2(B *ba1, B *ba2) {
+  std::thread thr1(d2, ba1, ba2, 100);
+  std::thread thr2(d2, ba2, ba1, 100);
+  thr1.join();
+  thr2.join();
+}
+
+void f3(B *ba1, B *ba2) {
+  std::thread thr1(d3, ba1, ba2, 100);
+  std::thread thr2(d3, ba1, ba2, 100);
+  thr1.join();
+  thr2.join();
+}
+
+void f4(B *ba1, B *ba2) {
+  std::thread thr1(d4, ba1, ba2, 100);
+  std::thread thr2(d4, ba1, ba2, 100);
+  thr1.join();
+  thr2.join();
+}
+
+void f5(B *ba1, B *ba2) {
+  std::thread thr1(d5, ba1, ba2, 100);
+  std::thread thr2(d5, ba1, ba2, 100);
+  thr1.join();
+  thr2.join();
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+\| test.cpp:30:5:30:6 \| d2 \| Threaded function may be called from a context that uses $@ and $@ which may lead to deadlocks. \| test.cpp:31:41:31:49 \| call to lock_guard \| lock 1 \| test.cpp:36:39:36:45 \| call to lock_guard \| lock 2 \|`
	`2`	`+\| test.cpp:44:5:44:6 \| d3 \| Threaded function may be called from a context that uses $@ and $@ which may lead to deadlocks. \| test.cpp:45:41:45:49 \| call to lock_guard \| lock 1 \| test.cpp:50:39:50:45 \| call to lock_guard \| lock 2 \|`
	`3`	`+\| test.cpp:86:5:86:6 \| d5 \| Threaded function may be called from a context that uses $@ and $@ which may lead to deadlocks. \| test.cpp:103:41:103:49 \| call to lock_guard \| lock 1 \| test.cpp:104:39:104:45 \| call to lock_guard \| lock 2 \|`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+// GENERATED FILE - DO NOT MODIFY`
	`2`	`+import codingstandards.cpp.rules.preventdeadlockbylockinginpredefinedorder.PreventDeadlockByLockingInPredefinedOrder`