cassert

---

1. Boundary Checking

int array[10];
cassert(index >= 0 && index < 10);  // Ensure index is within array bounds

2. Parameter Validation

void function(int x) {
  cassert(x > 0);  // Validate that x is positive
}

3. Invariant Maintenance

class MyClass {
public:
  MyClass() { invariant = true; }  // Initialize invariant
  void setX(int x) {
    cassert(x >= 0);  // Check invariant before changing x
    x_ = x;
  }

private:
  int x_;
  bool invariant;
};

4. Precondition Checking

void function(const vector<int>& v) {
  cassert(!v.empty());  // Ensure vector is not empty before using it
}

5. Postcondition Checking

void function(int& x) {
  cassert(x > 0);  // Check that x is positive after modifying it
}

6. Assertions for Numerical Accuracy

double epsilon = 1e-6;
cassert(abs(result - expected) < epsilon);  // Check if result is close enough to expected

7. Assertions for Object Ownership

class MyObject {
public:
  MyObject() { owner = nullptr; }
  void setOwner(Object* o) {
    cassert(owner == nullptr);  // Ensure object is not already owned
    owner = o;
  }

private:
  Object* owner;
};

8. Conditional Assertions

#ifdef DEBUG
  cassert(condition);  // Only check condition if DEBUG is defined
#endif

9. Exceptions with Assertions

try {
  // ...
  cassert(false);  // Throw exception if condition is false
} catch(exception& e) {
  // ...
}

10. Assertions for NULL Pointers

int* ptr;
cassert(ptr != nullptr);  // Ensure pointer is not NULL

11. Assertions for Empty Containers

vector<int> v;
cassert(!v.empty());  // Ensure vector is not empty

12. Assertions for Specific Values

cassert(value == 42);  // Check if value is equal to 42

13. Assertions for Booleans

cassert(flag);  // Check if flag is true

14. Assertions for Ranges of Values

int x = 5;
cassert(1 <= x && x <= 10);  // Check if x is in range [1, 10]

15. Assertions for Subobjects

struct MyStruct {
  int x;
  int y;
};

MyStruct s = {5, 10};
cassert(s.x == 5 && s.y == 10);  // Check subobject values

16. Assertions for Pointer Equality

int* ptr1;
int* ptr2 = nullptr;
cassert(ptr1 == ptr2);  // Check if pointers are equal

17. Assertions for Pointer Inequality

int* ptr1;
int* ptr2;
cassert(ptr1 != ptr2);  // Check if pointers are not equal

18. Assertions for Pointer Dereferencing

int* ptr;
cassert(*ptr == 42);  // Check the value pointed to by pointer

19. Assertions for Reference Counting

class MyObject {
public:
  MyObject() { refcount = 0; }
  ~MyObject() { assert(refcount == 0); }
  void addRef() { refcount++; }
  void releaseRef() { refcount--; }

private:
  int refcount;
};

20. Assertions for Resource Allocation

void* memory = malloc(1024);
cassert(memory != nullptr);  // Check if memory allocation succeeded
free(memory);

21. Assertions for File I/O

FILE* file = fopen("myfile.txt", "r");
cassert(file != nullptr);  // Check if file opening succeeded
fclose(file);

22. Assertions for Thread Safety

class ThreadSafeClass {
public:
  void lock() { assert(mutex_.try_lock()); }
  void unlock() { assert(mutex_.unlock()); }

private:
  mutex mutex_;
};

23. Assertions for Concurrency

condition_variable cv;
mutex cv_mutex;

void thread1() {
  unique_lock<mutex> lock(cv_mutex);
  cv.wait(lock);
}

void thread2() {
  unique_lock<mutex> lock(cv_mutex);
  cv.notify_one();
}

24. Assertions for Singletons

class Singleton {
public:
  static Singleton& getInstance() {
    cassert(instance_ == nullptr);
    if (instance_ == nullptr) {
      instance_ = new Singleton();
    }
    return *instance_;
  }

private:
  Singleton() {}
  static Singleton* instance_;
};

25. Assertions for Memory Leaks

void* memory = malloc(1024);
atexit([]() { assert(memory == nullptr); });  // Check if memory is freed on exit

26. Assertions for Resource Leaks

class Resource {
public:
  Resource() { acquire(); }
  ~Resource() { release(); }
  void acquire() { assert(usage_count_ == 0); usage_count_++; }
  void release() { assert(usage_count_ > 0); usage_count_--; }

private:
  int usage_count_;
};

27. Assertions for Type Safety

template<typename T>
class TypeSafeClass {
public:
  TypeSafeClass(T value) : value_(value) {}
  T getValue() const { assert(is_same<T, typename remove_reference<T>::type>::value); return value_; }

private:
  T value_;
};

28. Assertions for Static Assertions

static_assert(sizeof(int) == 4);  // Check if integer size is 4 bytes

29. Assertions for Type Traits

struct MyStruct {
};

static_assert(is_default_constructible<MyStruct>::value);  // Check if MyStruct has a default constructor

30. Assertions for Metaprogramming

template<typename T>
class EnableIf {
public:
  static constexpr bool value = false;
};

template<>
class EnableIf<int> {
public:
  static constexpr bool value = true;
};

static_assert(EnableIf<int>::value);  // Check if type is enabled

31. Assertions for Contract Programming

class Contract {
public:
  Contract() {
    cassert(precondition());
  }
  ~Contract() {
    cassert(postcondition());
  }

private:
  virtual bool precondition() const = 0;
  virtual bool postcondition() const = 0;
};

32. Assertions for Overloading

struct MyStruct {
  void operator()() { assert(true); }
  void operator()(int x) { assert(x > 0); }
};

33. Assertions for Constructors

class MyClass {
public:
  MyClass() { assert(condition()); }
  MyClass(int x) : x_(x) { assert(x > 0); }

private:
  int x_;
};

34. Assertions for Destructors

class MyClass {
public:
  ~MyClass() { assert(condition()); }
};

35. Assertions for Assignment Operators

class MyClass {
public:
  MyClass& operator=(const MyClass& other) {
    cassert(other.x_ == x_);
    return *this;
  }

private:
  int x_;
};

36. Assertions for Input Operators

istream& operator>>(istream& in, MyClass& obj) {
  cassert(in);
  in >> obj.x_;
  return in;
}

37. Assertions for Output Operators

ostream& operator<<(ostream& out, const MyClass& obj) {
  cassert(out);
  out << obj.x_;
  return out;
}

38. Assertions for Friend Functions

class MyClass {
public:
  friend void check(const MyClass& obj) { assert(obj.x_ > 0); }

private:
  int x_;
};

39. Assertions for Lambda Expressions

auto lambda = [](int x) { assert(x > 0); };

40. Assertions for Macros

#define ASSERT(condition) do { if (!(condition)) { __builtin_unreachable(); } } while (0)

41. Assertions for Unit Tests

#include "gtest/gtest.h"

TEST(MyTest, MyFunction) {
  EXPECT_EQ(myFunction(5), 10);
}

42. Assertions for Debugging

#include <assert.h>

void myFunction() {
  assert(condition());
}

43. Assertions for Exception Handling

try {
  // ...
  cassert(false);  // Throw exception if condition is false
} catch(std::exception& e) {
  // ...
}

44. Assertions for Error Handling

#include <stdexcept>

void myFunction() {
  if (condition()) {
    throw std::runtime_error("Error occurred");
  }
  cassert(false);  // Throw assertion if condition is true
}

45. Assertions for Performance Monitoring

#include <atomic>

std::atomic<int> counter;

void myFunction() {
  counter.fetch_add(1);
  cassert(counter.load() < 100);  // Check if counter is below threshold
}

46. Assertions for Memory Safety

#include <valgrind/valgrind.h>

void myFunction() {
  int* ptr = (int*)malloc(1024);
  cassert(ptr != nullptr);  // Check if memory allocation succeeded
  VALGRIND_CHECK_MEM_IS_VALID(ptr, 1024);  // Check for memory errors
  free(ptr);
}

47. Assertions for Internationalization

#include <locale>

void myFunction() {
  std::locale global_locale("");
  std::locale locale("en_US.UTF-8");
  cassert(std::locale().name() == global_locale.name());  // Check if locale is correct
}

48. Assertions for Thread-Local Storage

#include <thread>
#include <vector>

std::vector<thread> threads;

void myFunction() {
  std::thread::id id = std::this_thread::get_id();
  cassert(std::find(threads.begin(), threads.end(), id) != threads.end());  // Check if thread is in vector
}

49. Assertions for Resource Locking

#include <mutex>

std::mutex mutex;

void myFunction() {
  std::lock_guard<std::mutex> lock(mutex);
  cassert(mutex.try_lock());  // Check if mutex is locked
}

50. Assertions for Concurrency

#include <condition_variable>

std::condition_variable cv;
std::mutex cv_mutex;

void myFunction() {
  std::unique_lock<std::mutex> lock(cv_mutex);
  cassert(cv.wait_for(lock, std::chrono::milliseconds(100)) == std::cv_status::timeout);  // Check for timeout
}