diff --git a/include/test/strerror.h b/include/test/strerror.h
new file mode 100644
index 0000000..da20f3d
--- /dev/null
+++ b/include/test/strerror.h
@@ -0,0 +1,37 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * C++ stream style string formatter and printer used in KUnit for outputting
+ * KUnit messages.
+ *
+ * Copyright (C) 2019, Google LLC.
+ * Author: Mike Krinkin <krinkin@google.com>
+ */
+#include <linux/types.h>
+
+/**
+ * strerror() - returns a string representation for the given error code.
+ * @errno: an error code defined in include/uapi/asm-generic/errno-base.h or
+ * include/uapi/asm-generic/errno.h
+ *
+ * This function returns mnemonic representation of error code (for example,
+ * EPERM, ENOENT, ESRCH, etc). For unsupported errors this function returns
+ * NULL.
+ */
+const char *strerror(int errno);
+
+/**
+ * strerror_r() - returns a string representation of the given error code.
+ * Unlike strerror() it may use provided buffer to store the string, so in
+ * the case of unknown error it returns a message containing an error code
+ * instead of returning NULL.
+ * @errno: an error code defined in include/uapi/asm-generic/errno-base.h or
+ * include/uapi/asm-generic/errno.h
+ * @buf: pointer to a buffer that could be used to store the string.
+ * @buflen: contains the capacity of the buffer
+ *
+ * When function uses provided buffer and it's capacity is not enough to
+ * store the whole string the string is truncated and always contains '\0'.
+ * If buflen == 0, the function returns NULL pointer as there is not enough
+ * space to store even '\0'.
+ */
+const char *strerror_r(int errno, char *buf, size_t buflen);
diff --git a/include/test/test.h b/include/test/test.h
index b5f2d24..b0007c4 100644
--- a/include/test/test.h
+++ b/include/test/test.h
@@ -11,6 +11,7 @@
 
 #include <linux/types.h>
 #include <linux/slab.h>
+#include <test/strerror.h>
 #include <test/test-stream.h>
 
 /**
@@ -384,6 +385,81 @@
 		EXPECT(test, !(condition),				       \
 		       "Expected " #condition " is false, but is true.")
 
+/**
+ * EXPECT_NOT_NULL() - Causes a test failure when @expression is NULL.
+ * @test: The test context object.
+ * @expression: an arbitrary pointer expression. The test fails when this
+ * evaluates to NULL.
+ *
+ * Sets an expectation that @expression does not evaluate to NULL. Similar to
+ * EXPECT_TRUE() but supposed to be used with pointer expressions.
+ */
+#define EXPECT_NOT_NULL(test, expression)				       \
+		EXPECT(test, (expression),				       \
+		       "Expected " #expression " is not NULL, but is NULL.")
+
+/**
+ * EXPECT_NULL() - Causes a test failure when @expression is not NULL.
+ * @test: The test context object.
+ * @expression: an arbitrary pointer expression. The test fails when this does
+ * not evaluate to NULL.
+ *
+ * Sets an expectation that @expression evaluates to NULL. Similar to
+ * EXPECT_FALSE() but supposed to be used with pointer expressions.
+ */
+#define EXPECT_NULL(test, expression)					       \
+		EXPECT(test, !(expression),				       \
+		       "Expected " #expression " is NULL, but is not NULL.")
+
+/**
+ * EXPECT_SUCCESS() - Causes a test failure if @expression does not evaluate
+ * to 0.
+ * @test: The test context object.
+ * @expression: an arbitrary expression evaluating to an int error code. The
+ * test fails when this does not evaluate to 0.
+ *
+ * Sets an expectation that @expression evaluates to 0. Implementation assumes
+ * that error codes are represented as negative values and if expression
+ * evaluates to a negative value failure message will contain a mnemonic
+ * representation of the error code (for example, for -1 it will contain EPERM).
+ */
+#define EXPECT_SUCCESS(test, expression) do {				       \
+	struct test_stream *__stream = EXPECT_START(test);		       \
+	typeof(expression) __result = (expression);			       \
+	char buf[64];							       \
+									       \
+	if (result != 0)						       \
+		__stream->add(__stream,					       \
+			      "Expected " #expression " is not error, "	       \
+			      "but is: %s.",				       \
+			      strerror_r(-result, buf, sizeof(buf)));	       \
+	EXPECT_END(test, result != 0, __stream);			       \
+} while (0)
+
+/**
+ * EXPECT_ERROR() - Causes a test failure when @expression evaluates to @errno.
+ * @test: The test context object.
+ * @expression: an arbitrary expression evaluating to an int error code. The
+ * test fails when this does not evaluate to @errno.
+ * @errno: expected error value, error values are expected to be negative.
+ *
+ * Sets an expectation that @expression evaluates to @errno, so as opposed to
+ * EXPECT_SUCCESS it verifies that @expression evaluates to an error.
+ */
+#define EXPECT_ERROR(test, expression, errno) do {			       \
+	struct test_stream *__stream = EXPECT_START(test);		       \
+	typeof(expression) __result = (expression);			       \
+	char buf1[64];							       \
+	char buf2[64];							       \
+									       \
+	if (result != errno)						       \
+		__stream->add(__stream,					       \
+			      "Expected " #expression " is %s, but is: %s.",   \
+			      strerror_t(-errno, buf1, sizeof(buf1)),	       \
+			      strerror_r(-result, buf2, sizeof(buf2)));	       \
+	EXPECT_END(test, result == errno, __stream);			       \
+} while (0)
+
 static inline void test_expect_binary(struct test *test,
 				      long long left, const char *left_name,
 				      long long right, const char *right_name,
@@ -531,22 +607,23 @@
  * @test: The test context object.
  * @ptr: an arbitrary pointer.
  *
- * Sets an expectation that the value that @ptr evaluates to is not null and not
- * an errno stored in a pointer. This is semantically equivalent to
+ * Sets an expectation that the value that @ptr evaluates to is not null and
+ * not an errno stored in a pointer. This is semantically equivalent to
  * EXPECT_TRUE(@test, !IS_ERR_OR_NULL(@ptr)). See EXPECT_TRUE() for more
  * information.
  */
 #define EXPECT_NOT_ERR_OR_NULL(test, ptr) do {				       \
 	struct test_stream *__stream = EXPECT_START(test);		       \
 	typeof(ptr) __ptr = (ptr);					       \
+	char buf[64];							       \
 									       \
 	if (!__ptr)							       \
 		__stream->add(__stream,					       \
 			      "Expected " #ptr " is not null, but is.");       \
 	if (IS_ERR(__ptr))						       \
 		__stream->add(__stream,					       \
-			      "Expected " #ptr " is not error, but is: %ld",   \
-			      PTR_ERR(__ptr));				       \
+			      "Expected " #ptr " is not error, but is: %s",    \
+			      strerror_r(-PTR_ERR(__ptr), buf, sizeof(buf)));  \
 									       \
 	EXPECT_END(test, !IS_ERR_OR_NULL(__ptr), __stream);		       \
 } while (0)
@@ -616,6 +693,74 @@
 		ASSERT(test, !(condition),				       \
 		       "Asserted " #condition " is false, but is true.")
 
+/**
+ * ASSERT_NOT_NULL() - Asserts that @expression does not evaluate to NULL.
+ * @test: The test context object.
+ * @expression: an arbitrary pointer expression. The test fails when this
+ * evaluates to NULL.
+ *
+ * Asserts that @expression does not evaluate to NULL, see EXPECT_NOT_NULL().
+ */
+#define ASSERT_NOT_NULL(test, expression)				       \
+		ASSERT(test, (expression),				       \
+		       "Expected " #expression " is not NULL, but is NULL.")
+
+/**
+ * ASSERT_NULL() - Asserts that @expression evaluates to NULL.
+ * @test: The test context object.
+ * @expression: an arbitrary pointer expression. The test fails when this does
+ * not evaluate to NULL.
+ *
+ * Asserts that @expression evaluates to NULL, see EXPECT_NULL().
+ */
+#define ASSERT_NULL(test, expression)					       \
+		ASSERT(test, !(expression),				       \
+		       "Expected " #expression " is NULL, but is not NULL.")
+
+/**
+ * ASSERT_SUCCESS() - Asserts that @expression is 0.
+ * @test: The test context object.
+ * @expression: an arbitrary expression evaluating to an int error code.
+ *
+ * Asserts that @expression evaluates to 0. It's the same as EXPECT_SUCCESS.
+ */
+#define ASSERT_SUCCESS(test, expression) do {				       \
+	struct test_stream *__stream = ASSERT_START(test);		       \
+	typeof(expression) __result = (expression);			       \
+	char buf[64];							       \
+									       \
+	if (result != 0)						       \
+		__stream->add(__stream,					       \
+			      "Asserted " #expression " is not error, "	       \
+			      "but is: %s.",				       \
+			      strerror_r(-result, buf, sizeof(buf)));	       \
+	ASSERT_END(test, result != 0, __stream);			       \
+} while (0)
+
+/**
+ * ASSERT_ERROR() - Causes a test failure when @expression does not evaluate to
+ * @errno.
+ * @test: The test context object.
+ * @expression: an arbitrary expression evaluating to an int error code. The
+ * test fails when this does not evaluate to @errno.
+ * @errno: expected error value, error values are expected to be negative.
+ *
+ * Asserts that @expression evaluates to @errno, similar to EXPECT_ERROR.
+ */
+#define ASSERT_ERROR(test, expression, errno) do {			       \
+	struct test_stream *__stream = ASSERT_START(test);		       \
+	typeof(expression) __result = (expression);			       \
+	char buf1[64];							       \
+	char buf2[64];							       \
+									       \
+	if (result != errno)						       \
+		__stream->add(__stream,					       \
+			      "Expected " #expression " is %s, but is: %s.",   \
+			      strerror_t(-errno, buf1, sizeof(buf1)),	       \
+			      strerror_r(-result, buf2, sizeof(buf2)));	       \
+	ASSERT_END(test, result == errno, __stream);			       \
+} while (0)
+
 static inline void test_assert_binary(struct test *test,
 				      long long left, const char *left_name,
 				      long long right, const char *right_name,
@@ -770,6 +915,7 @@
 #define ASSERT_NOT_ERR_OR_NULL(test, ptr) do {				       \
 	struct test_stream *__stream = ASSERT_START(test);		       \
 	typeof(ptr) __ptr = (ptr);					       \
+	char buf[64];							       \
 									       \
 	if (!__ptr)							       \
 		__stream->add(__stream,					       \
@@ -777,7 +923,7 @@
 	if (IS_ERR(__ptr))						       \
 		__stream->add(__stream,					       \
 			      "Asserted " #ptr " is not error, but is: %ld",   \
-			      PTR_ERR(__ptr));				       \
+			      strerror_r(-PTR_ERR(__ptr), buf, sizeof(buf)));  \
 									       \
 	ASSERT_END(test, !IS_ERR_OR_NULL(__ptr), __stream);		       \
 } while (0)
diff --git a/test/Makefile b/test/Makefile
index 84a336f..f840886 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -1,7 +1,7 @@
-obj-$(CONFIG_TEST)		+= test.o mock.o common-mocks.o string-stream.o \
-  test-stream.o test-executor.o
+obj-$(CONFIG_TEST)		+= test.o mock.o common-mocks.o strerror.o \
+  string-stream.o test-stream.o test-executor.o
 obj-$(CONFIG_TEST_TEST)		+= \
-  test-mock.o mock-macro-test.o mock-test.o string-stream-test.o \
-  test-stream-test.o test-test.o
+  test-mock.o mock-macro-test.o mock-test.o strerror-test.o \
+  string-stream-test.o test-stream-test.o test-test.o
 obj-$(CONFIG_TEST_DEATH_TEST)	+= test-death-test.o
 obj-$(CONFIG_EXAMPLE_TEST)	+= example-test.o
diff --git a/test/strerror-test.c b/test/strerror-test.c
new file mode 100644
index 0000000..2de126a
--- /dev/null
+++ b/test/strerror-test.c
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit test for strerror and strerror_r
+ *
+ * Copyright (C) 2019, Google LLC.
+ * Author: Mike Krinkin <krinkin@google.com>
+ */
+
+#include <linux/err.h>
+#include <test/strerror.h>
+#include <test/test.h>
+
+
+static void test_strerror_returns_null_for_unknown_errors(struct test *test)
+{
+	EXPECT_NULL(test, strerror(-1));
+	EXPECT_NULL(test, strerror(MAX_ERRNO + 1));
+}
+
+static void test_strerror_r_returns_null_if_buflen_is_zero(struct test *test)
+{
+	EXPECT_NULL(test, strerror_r(-1, NULL, 0));
+}
+
+static void test_strerror_returns_string(struct test *test)
+{
+	const char *err;
+	char buf[64];
+
+	err = strerror(EAGAIN);
+	ASSERT_NOT_NULL(test, err);
+	EXPECT_STREQ(test, err, "EAGAIN");
+
+	err = strerror_r(EAGAIN, buf, sizeof(buf));
+	ASSERT_NOT_NULL(test, err);
+	EXPECT_STREQ(test, err, "EAGAIN");
+}
+
+static void test_strerror_r_correctly_truncates_message_to_buffer_size(
+		struct test *test)
+{
+	const char *err;
+	char buf[64];
+
+	err = strerror_r(EAGAIN, buf, 1);
+	ASSERT_NOT_NULL(test, err);
+	EXPECT_EQ(test, strlen(err), 0);
+
+	err = strerror_r(EAGAIN, buf, 2);
+	ASSERT_NOT_NULL(test, err);
+	EXPECT_EQ(test, strlen(err), 1);
+
+	err = strerror_r(EAGAIN, buf, sizeof(buf));
+	ASSERT_NOT_NULL(test, err);
+	EXPECT_STREQ(test, err, "EAGAIN");
+}
+
+static void test_strerror_r_returns_string_for_unknown_errors(struct test *test)
+{
+	char buf[64];
+
+	EXPECT_NOT_NULL(test, strerror_r(-1, buf, sizeof(buf)));
+	EXPECT_NOT_NULL(test, strerror_r(MAX_ERRNO + 1, buf, sizeof(buf)));
+}
+
+static struct test_case strerror_test_cases[] = {
+	TEST_CASE(test_strerror_returns_null_for_unknown_errors),
+	TEST_CASE(test_strerror_r_returns_null_if_buflen_is_zero),
+	TEST_CASE(test_strerror_returns_string),
+	TEST_CASE(test_strerror_r_correctly_truncates_message_to_buffer_size),
+	TEST_CASE(test_strerror_r_returns_string_for_unknown_errors),
+	{},
+};
+
+static struct test_module strerror_test_module = {
+	.name = "strerror-test",
+	.test_cases = strerror_test_cases,
+};
+module_test(strerror_test_module);
diff --git a/test/strerror.c b/test/strerror.c
new file mode 100644
index 0000000..0bdfbc7
--- /dev/null
+++ b/test/strerror.c
@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * C++ stream style string formatter and printer used in KUnit for outputting
+ * KUnit messages.
+ *
+ * Copyright (C) 2019, Google LLC.
+ * Author: Mike Krinkin <krinkin@google.com>
+ */
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/string.h>
+#include <test/strerror.h>
+
+
+#define SUCCESS	0
+#define MAKE_ERROR(errno)	[errno] = #errno
+
+static const char * const errmap[] = {
+	MAKE_ERROR(SUCCESS),
+	MAKE_ERROR(EPERM),
+	MAKE_ERROR(ENOENT),
+	MAKE_ERROR(ESRCH),
+	MAKE_ERROR(EINTR),
+	MAKE_ERROR(EIO),
+	MAKE_ERROR(ENXIO),
+	MAKE_ERROR(E2BIG),
+	MAKE_ERROR(ENOEXEC),
+	MAKE_ERROR(EBADF),
+	MAKE_ERROR(ECHILD),
+	MAKE_ERROR(EAGAIN),
+	MAKE_ERROR(ENOMEM),
+	MAKE_ERROR(EACCES),
+	MAKE_ERROR(EFAULT),
+	MAKE_ERROR(ENOTBLK),
+	MAKE_ERROR(EBUSY),
+	MAKE_ERROR(EEXIST),
+	MAKE_ERROR(EXDEV),
+	MAKE_ERROR(ENODEV),
+	MAKE_ERROR(ENOTDIR),
+	MAKE_ERROR(EISDIR),
+	MAKE_ERROR(EINVAL),
+	MAKE_ERROR(ENFILE),
+	MAKE_ERROR(EMFILE),
+	MAKE_ERROR(ENOTTY),
+	MAKE_ERROR(ETXTBSY),
+	MAKE_ERROR(EFBIG),
+	MAKE_ERROR(ENOSPC),
+	MAKE_ERROR(ESPIPE),
+	MAKE_ERROR(EROFS),
+	MAKE_ERROR(EMLINK),
+	MAKE_ERROR(EPIPE),
+	MAKE_ERROR(EDOM),
+	MAKE_ERROR(ERANGE),
+	MAKE_ERROR(EDEADLK),
+	MAKE_ERROR(ENAMETOOLONG),
+	MAKE_ERROR(ENOLCK),
+	MAKE_ERROR(ENOSYS),
+	MAKE_ERROR(ENOTEMPTY),
+	MAKE_ERROR(ELOOP),
+	MAKE_ERROR(ENOMSG),
+	MAKE_ERROR(EIDRM),
+	MAKE_ERROR(ECHRNG),
+	MAKE_ERROR(EL2NSYNC),
+	MAKE_ERROR(EL3HLT),
+	MAKE_ERROR(EL3RST),
+	MAKE_ERROR(ELNRNG),
+	MAKE_ERROR(EUNATCH),
+	MAKE_ERROR(ENOCSI),
+	MAKE_ERROR(EL2HLT),
+	MAKE_ERROR(EBADE),
+	MAKE_ERROR(EBADR),
+	MAKE_ERROR(EXFULL),
+	MAKE_ERROR(ENOANO),
+	MAKE_ERROR(EBADRQC),
+	MAKE_ERROR(EBADSLT),
+	MAKE_ERROR(EBFONT),
+	MAKE_ERROR(ENOSTR),
+	MAKE_ERROR(ENODATA),
+	MAKE_ERROR(ETIME),
+	MAKE_ERROR(ENOSR),
+	MAKE_ERROR(ENONET),
+	MAKE_ERROR(ENOPKG),
+	MAKE_ERROR(EREMOTE),
+	MAKE_ERROR(ENOLINK),
+	MAKE_ERROR(EADV),
+	MAKE_ERROR(ESRMNT),
+	MAKE_ERROR(ECOMM),
+	MAKE_ERROR(EPROTO),
+	MAKE_ERROR(EMULTIHOP),
+	MAKE_ERROR(EDOTDOT),
+	MAKE_ERROR(EBADMSG),
+	MAKE_ERROR(EOVERFLOW),
+	MAKE_ERROR(ENOTUNIQ),
+	MAKE_ERROR(EBADFD),
+	MAKE_ERROR(EREMCHG),
+	MAKE_ERROR(ELIBACC),
+	MAKE_ERROR(ELIBBAD),
+	MAKE_ERROR(ELIBSCN),
+	MAKE_ERROR(ELIBMAX),
+	MAKE_ERROR(ELIBEXEC),
+	MAKE_ERROR(EILSEQ),
+	MAKE_ERROR(ERESTART),
+	MAKE_ERROR(ESTRPIPE),
+	MAKE_ERROR(EUSERS),
+	MAKE_ERROR(ENOTSOCK),
+	MAKE_ERROR(EDESTADDRREQ),
+	MAKE_ERROR(EMSGSIZE),
+	MAKE_ERROR(EPROTOTYPE),
+	MAKE_ERROR(ENOPROTOOPT),
+	MAKE_ERROR(EPROTONOSUPPORT),
+	MAKE_ERROR(ESOCKTNOSUPPORT),
+	MAKE_ERROR(EOPNOTSUPP),
+	MAKE_ERROR(EPFNOSUPPORT),
+	MAKE_ERROR(EAFNOSUPPORT),
+	MAKE_ERROR(EADDRINUSE),
+	MAKE_ERROR(EADDRNOTAVAIL),
+	MAKE_ERROR(ENETDOWN),
+	MAKE_ERROR(ENETUNREACH),
+	MAKE_ERROR(ENETRESET),
+	MAKE_ERROR(ECONNABORTED),
+	MAKE_ERROR(ECONNRESET),
+	MAKE_ERROR(ENOBUFS),
+	MAKE_ERROR(EISCONN),
+	MAKE_ERROR(ENOTCONN),
+	MAKE_ERROR(ESHUTDOWN),
+	MAKE_ERROR(ETOOMANYREFS),
+	MAKE_ERROR(ETIMEDOUT),
+	MAKE_ERROR(ECONNREFUSED),
+	MAKE_ERROR(EHOSTDOWN),
+	MAKE_ERROR(EHOSTUNREACH),
+	MAKE_ERROR(EALREADY),
+	MAKE_ERROR(EINPROGRESS),
+	MAKE_ERROR(ESTALE),
+	MAKE_ERROR(EUCLEAN),
+	MAKE_ERROR(ENOTNAM),
+	MAKE_ERROR(ENAVAIL),
+	MAKE_ERROR(EISNAM),
+	MAKE_ERROR(EREMOTEIO),
+	MAKE_ERROR(EDQUOT),
+	MAKE_ERROR(ENOMEDIUM),
+	MAKE_ERROR(EMEDIUMTYPE),
+	MAKE_ERROR(ECANCELED),
+	MAKE_ERROR(ENOKEY),
+	MAKE_ERROR(EKEYEXPIRED),
+	MAKE_ERROR(EKEYREVOKED),
+	MAKE_ERROR(EKEYREJECTED),
+	MAKE_ERROR(EOWNERDEAD),
+	MAKE_ERROR(ENOTRECOVERABLE),
+	MAKE_ERROR(ERFKILL),
+	MAKE_ERROR(EHWPOISON)
+};
+
+const char *strerror(int errno)
+{
+	if (errno < 0 || errno >= ARRAY_SIZE(errmap))
+		return NULL;
+	return errmap[errno];
+}
+
+const char *strerror_r(int errno, char *buf, size_t buflen)
+{
+	const char *err = strerror(errno);
+
+	if (!buflen)
+		return NULL;
+
+	// GNU version of strerror_r() may sometimes return a pointer to a
+	// static string, this implementation doesn't do it mostly to keep
+	// the behavior consistent and predicatble.
+	buf[buflen - 1] = '\0';
+	if (err)
+		return strncpy(buf, err, buflen - 1);
+	snprintf(buf, buflen - 1, "%d (unknown error)", errno);
+	return buf;
+}