diff --git a/doc/starter.rst b/doc/starter.rst
index 7b17da6..54e3819 100644
--- a/doc/starter.rst
+++ b/doc/starter.rst
@@ -50,15 +50,26 @@ parameter, and an optional failure message:
 
 On top of those, more assertions are available for common operations:
 
-* ``{assert,expect}Equal(Actual, Expected, [Message])``
-* ``{assert,expect}NotEqual(Actual, Unexpected, [Message])``
-* ``{assert,expect}StringsEqual(Actual, Expected, [Message])``
-* ``{assert,expect}StringsNotEqual(Actual, Unexpected, [Message])``
-* ``{assert,expect}ArraysEqual(Actual, Expected, Size, [Message])``
-* ``{assert,expect}ArraysNotEqual(Actual, Unexpected, Size, [Message])``
+* ``{assert,expect}_not(Actual, Expected, [Message])``
+* ``{assert,expect}_equal(Actual, Expected, [Message])``
+* ``{assert,expect}_not_equal(Actual, Unexpected, [Message])``
+* ``{assert,expect}_lt(Actual, Expected, [Message])``
+* ``{assert,expect}_leq(Actual, Expected, [Message])``
+* ``{assert,expect}_gt(Actual, Expected, [Message])``
+* ``{assert,expect}_geq(Actual, Expected, [Message])``
+* ``{assert,expect}_float_equal(Actual, Expected, Epsilon, [Message])``
+* ``{assert,expect}_float_not_equal(Actual, Unexpected, Epsilon, [Message])``
+* ``{assert,expect}_strings_equal(Actual, Expected, [Message])``
+* ``{assert,expect}_strings_not_equal(Actual, Unexpected, [Message])``
+* ``{assert,expect}_strings_lt(Actual, Expected, [Message])``
+* ``{assert,expect}_strings_leq(Actual, Expected, [Message])``
+* ``{assert,expect}_strings_gt(Actual, Expected, [Message])``
+* ``{assert,expect}_strings_geq(Actual, Expected, [Message])``
+* ``{assert,expect}_arrays_equal(Actual, Expected, Size, [Message])``
+* ``{assert,expect}_arrays_not_equal(Actual, Unexpected, Size, [Message])``
 
-Initialization and finalization
--------------------------------
+Fixtures
+--------
 
 Tests that need some setup and teardown can register functions that will
 run before and after the test function:
diff --git a/include/criterion/assert.h b/include/criterion/assert.h
index 21da10c..a5a6bed 100644
--- a/include/criterion/assert.h
+++ b/include/criterion/assert.h
@@ -37,7 +37,7 @@ enum criterion_assert_kind {
     FATAL
 };
 
-# define assertImpl(Kind, Condition, ...)                       \
+# define assert_impl(Kind, Condition, ...)                       \
     do {                                                        \
         int passed = !!(Condition);                             \
         struct criterion_assert_stats stat = {                  \
@@ -53,45 +53,110 @@ enum criterion_assert_kind {
             return;                                             \
     } while (0)
 
-# define assert(Condition, ...) assertImpl(FATAL, (Condition), ## __VA_ARGS__)
-# define expect(Condition, ...) assertImpl(NORMAL, (Condition), ## __VA_ARGS__)
+// Common asserts
 
-# define assertArraysEqual(A, B, Size, ...) \
-    assert(!memcmp((A), (B), (Size)), ## __VA_ARGS__)
-# define expectArraysEqual(A, B, Size, ...) \
-    expect(!memcmp((A), (B), (Size)), ## __VA_ARGS__)
+# define assert(Condition, ...) assert_impl(FATAL, Condition, "" __VA_ARGS__)
+# define expect(Condition, ...) assert_impl(NORMAL, Condition, "" __VA_ARGS__)
 
-# define assertEqual(Actual, Expected, ...) \
-    assert((Actual) == (Expected), ## __VA_ARGS__)
-# define expectEqual(Actual, Expected, ...) \
-    expect((Actual) == (Expected), ## __VA_ARGS__)
+# define assert_not(Condition, ...) assert(!(Condition), "" __VA_ARGS__)
+# define expect_not(Condition, ...) expect(!(Condition), "" __VA_ARGS__)
 
-# define assertFloatEqual(Actual, Expected, Epsilon, ...) \
-    assert((Expected) - (Actual) < (Epsilon) && (Actual) - (Expected) < (Epsilon), ## __VA_ARGS__)
-# define expectFloatEqual(Actual, Expected, Epsilon, ...) \
-    expect((Expected) - (Actual) < (Epsilon) && (Actual) - (Expected) < (Epsilon), ## __VA_ARGS__)
+// Native asserts
 
-# define assertStringsEqual(Actual, Expected, ...) \
-    assert(!strcmp((Actual), (Expected)), ## __VA_ARGS__)
-# define expectStringsEqual(Actual, Expected, ...) \
-    expect(!strcmp((Actual), (Expected)), ## __VA_ARGS__)
+# define assert_op(Actual, Expected, Op, ...) \
+    assert((Actual) Op (Expected), "" __VA_ARGS__)
+# define expect_op(Actual, Expected, Op, ...) \
+    expect((Actual) Op (Expected), "" __VA_ARGS__)
 
-# define assertNot(Condition, ...) assert(!(Condition), ## __VA_ARGS__)
-# define expectNot(Condition, ...) expect(!(Condition), ## __VA_ARGS__)
+# define assert_equal(Actual, Expected, ...) \
+    assert_op(Actual, Expected, ==, "" __VA_ARGS__)
+# define expect_equal(Actual, Expected, ...) \
+    expect_op(Actual, Expected, ==, "" __VA_ARGS__)
 
-# define assertNotEqual(Actual, Expected, ...) \
-    assert((Actual) != (Expected), ## __VA_ARGS__)
+# define assert_not_equal(Actual, Expected, ...) \
+    assert_op(Actual, Expected, !=, "" __VA_ARGS__)
 # define expectNotEqual(Actual, Expected, ...) \
-    expect((Actual) != (Expected), ## __VA_ARGS__)
+    expect_op(Actual, Expected, !=, "" __VA_ARGS__)
 
-# define assertArraysNotEqual(A, B, Size, ...) \
-    assert(memcmp((A), (B), (Size)), ## __VA_ARGS__)
-# define expectArraysNotEqual(A, B, Size, ...) \
-    expect(memcmp((A), (B), (Size)), ## __VA_ARGS__)
+# define assert_lt(Actual, Expected, ...) \
+    assert_op(Actual, Expected, <, "" __VA_ARGS__)
+# define expect_lt(Actual, Expected, ...) \
+    expect_op(Actual, Expected, <, "" __VA_ARGS__)
 
-# define assertStringsNotEqual(Actual, Expected, ...) \
-    assert(strcmp((Actual), (Expected)), ## __VA_ARGS__)
-# define expectStringsNotEqual(Actual, Expected, ...) \
-    expect(strcmp((Actual), (Expected)), ## __VA_ARGS__)
+# define assert_gt(Actual, Expected, ...) \
+    assert_op(Actual, Expected, >, "" __VA_ARGS__)
+# define expect_gt(Actual, Expected, ...) \
+    expect_op(Actual, Expected, >, "" __VA_ARGS__)
+
+# define assert_leq(Actual, Expected, ...) \
+    assert_op(Actual, Expected, <=, "" __VA_ARGS__)
+# define expect_leq(Actual, Expected, ...) \
+    expect_op(Actual, Expected, <=, "" __VA_ARGS__)
+
+# define assert_geq(Actual, Expected, ...) \
+    assert_op(Actual, Expected, >=, "" __VA_ARGS__)
+# define expect_geq(Actual, Expected, ...) \
+    expect_op(Actual, Expected, >=, "" __VA_ARGS__)
+
+// Floating-point asserts
+
+# define assert_float_equal(Actual, Expected, Epsilon, ...) \
+    assert((Expected) - (Actual) <= (Epsilon) && (Actual) - (Expected) <= (Epsilon), "" __VA_ARGS__)
+# define expect_float_equal(Actual, Expected, Epsilon, ...) \
+    expect((Expected) - (Actual) <= (Epsilon) && (Actual) - (Expected) <= (Epsilon), "" __VA_ARGS__)
+
+# define assert_float_not_equal(Actual, Expected, Epsilon, ...) \
+    assert((Expected) - (Actual) > (Epsilon) || (Actual) - (Expected) > (Epsilon), "" __VA_ARGS__)
+# define expect_float_not_equal(Actual, Expected, Epsilon, ...) \
+    expect((Expected) - (Actual) > (Epsilon) || (Actual) - (Expected) > (Epsilon), "" __VA_ARGS__)
+
+// String asserts
+
+# define assert_strings(Actual, Expected, Op, ...) \
+    assert(strcmp((Actual), (Expected)) Op 0, "" __VA_ARGS__)
+# define expect_strings(Actual, Expected, Op, ...) \
+    expect(strcmp((Actual), (Expected)) Op 0, "" __VA_ARGS__)
+
+# define assert_strings_equal(Actual, Expected, ...) \
+    assert_strings(Actual, Expected, ==, "" __VA_ARGS__)
+# define expect_strings_equal(Actual, Expected, ...) \
+    expect_strings(Actual, Expected, ==, "" __VA_ARGS__)
+
+# define assert_strings_gt(Actual, Expected, ...) \
+    assert_strings(Actual, Expected, >, "" __VA_ARGS__)
+# define expect_strings_gt(Actual, Expected, ...) \
+    expect_strings(Actual, Expected, >, "" __VA_ARGS__)
+
+# define assert_strings_lt(Actual, Expected, ...) \
+    assert_strings(Actual, Expected, <, "" __VA_ARGS__)
+# define expect_strings_lt(Actual, Expected, ...) \
+    expect_strings(Actual, Expected, <, "" __VA_ARGS__)
+
+# define assert_strings_geq(Actual, Expected, ...) \
+    assert_strings(Actual, Expected, >=, "" __VA_ARGS__)
+# define expect_strings_geq(Actual, Expected, ...) \
+    expect_strings(Actual, Expected, >=, "" __VA_ARGS__)
+
+# define assert_strings_leq(Actual, Expected, ...) \
+    assert_strings(Actual, Expected, <=, "" __VA_ARGS__)
+# define expect_strings_leq(Actual, Expected, ...) \
+    expect_strings(Actual, Expected, <=, "" __VA_ARGS__)
+
+# define assert_strings_not_equal(Actual, Expected, ...) \
+    assert_strings(Actual, Expected, !=, "" __VA_ARGS__)
+# define expect_strings_not_equal(Actual, Expected, ...) \
+    expect_strings(Actual, Expected, !=, "" __VA_ARGS__)
+
+// Array asserts
+
+# define assert_arrays_equal(A, B, Size, ...) \
+    assert(!memcmp((A), (B), (Size)), "" __VA_ARGS__)
+# define expect_arrays_equal(A, B, Size, ...) \
+    expect(!memcmp((A), (B), (Size)), "" __VA_ARGS__)
+
+# define assert_arrays_not_equal(A, B, Size, ...) \
+    assert(memcmp((A), (B), (Size)), "" __VA_ARGS__)
+# define expect_arrays_not_equal(A, B, Size, ...) \
+    expect(memcmp((A), (B), (Size)), "" __VA_ARGS__)
 
 #endif /* !CRITERION_ASSERT_H_ */
diff --git a/samples/Makefile.am b/samples/Makefile.am
index 0cdbd5b..3fb962a 100644
--- a/samples/Makefile.am
+++ b/samples/Makefile.am
@@ -3,10 +3,11 @@ TESTS = \
 	report \
 	suites \
 	fixtures \
+	asserts \
 	simple
 
 TESTS_ENVIRONMENT = CRITERION_ALWAYS_SUCCEED=1
 
 check_PROGRAMS = $(TESTS)
-CFLAGS = -I$(top_srcdir)/include/
+CFLAGS = -I$(top_srcdir)/include/ -std=c99
 LDADD = -L$(top_srcdir)/ -lcriterion
diff --git a/samples/asserts.c b/samples/asserts.c
new file mode 100644
index 0000000..deec0b4
--- /dev/null
+++ b/samples/asserts.c
@@ -0,0 +1,43 @@
+#include <criterion/criterion.h>
+
+Test(asserts, base) {
+    assert(true);
+    expect(true);
+
+    assert(true, "Assertions may take failure messages");
+
+    expect(false, "assert is fatal, expect isn't");
+    assert(false, "This assert runs");
+    assert(false, "This does not");
+}
+
+Test(asserts, string) {
+    assert_strings_equal("hello", "hello");
+    assert_strings_not_equal("hello", "olleh");
+
+    assert_strings_gt("hello", "hell");
+    assert_strings_geq("hello", "hell");
+    assert_strings_geq("hello", "hello");
+
+    assert_strings_lt("hell", "hello");
+    assert_strings_leq("hell", "hello");
+    assert_strings_leq("hello", "hello");
+}
+
+Test(asserts, native) {
+    assert_equal(1, 1);
+    assert_not_equal(1, 2);
+
+    assert_lt(1, 2);
+    assert_leq(1, 2);
+    assert_leq(2, 2);
+
+    assert_gt(2, 1);
+    assert_geq(2, 1);
+    assert_geq(2, 2);
+}
+
+Test(asserts, float) {
+    assert_not_equal(0.1 * 0.1, 0.01);
+    assert_float_equal(0.1 * 0.1, 0.01, 0.001);
+}