diff --git a/Android.bp b/Android.bp
index 5648d06..c98cd21 100644
--- a/Android.bp
+++ b/Android.bp
@@ -57,6 +57,9 @@
     native_bridge_supported: true,
     export_include_dirs: ["include"],
 
+    header_libs: ["fmtlib_headers"],
+    export_header_lib_headers: ["fmtlib_headers"],
+
     target: {
         linux_bionic: {
             enabled: true,
@@ -85,6 +88,7 @@
         "mapped_file.cpp",
         "parsebool.cpp",
         "parsenetaddress.cpp",
+        "posix_strerror_r.cpp",
         "process.cpp",
         "properties.cpp",
         "stringprintf.cpp",
@@ -148,6 +152,7 @@
     ],
     export_header_lib_headers: ["libbase_headers"],
     whole_static_libs: ["fmtlib"],
+    export_static_lib_headers: ["fmtlib"],
     apex_available: [
         "//apex_available:anyapex",
         "//apex_available:platform",
diff --git a/include/android-base/errors.h b/include/android-base/errors.h
index 06f29fc..f67e6eb 100644
--- a/include/android-base/errors.h
+++ b/include/android-base/errors.h
@@ -29,6 +29,8 @@
 
 #pragma once
 
+#include <assert.h>
+
 #include <string>
 
 namespace android {
@@ -41,3 +43,99 @@
 
 }  // namespace base
 }  // namespace android
+
+// Convenient macros for evaluating a statement, checking if the result is error, and returning it
+// to the caller.
+//
+// Usage with Result<T>:
+//
+// Result<Foo> getFoo() {...}
+//
+// Result<Bar> getBar() {
+//   Foo foo = OR_RETURN(getFoo());
+//   return Bar{foo};
+// }
+//
+// Usage with status_t:
+//
+// status_t getFoo(Foo*) {...}
+//
+// status_t getBar(Bar* bar) {
+//   Foo foo;
+//   OR_RETURN(getFoo(&foo));
+//   *bar = Bar{foo};
+//   return OK;
+// }
+//
+// Actually this can be used for any type as long as the OkOrFail<T> contract is satisfied. See
+// below.
+#define OR_RETURN(expr)                                                                 \
+  ({                                                                                    \
+    decltype(expr)&& tmp = (expr);                                                      \
+    typedef android::base::OkOrFail<std::remove_reference_t<decltype(tmp)>> ok_or_fail; \
+    if (!ok_or_fail::IsOk(tmp)) {                                                       \
+      return ok_or_fail::Fail(std::move(tmp));                                          \
+    }                                                                                   \
+    ok_or_fail::Unwrap(std::move(tmp));                                                 \
+  })
+
+// Same as OR_RETURN, but aborts if expr is a failure.
+#if defined(__BIONIC__)
+#define OR_FATAL(expr)                                                                  \
+  ({                                                                                    \
+    decltype(expr)&& tmp = (expr);                                                      \
+    typedef android::base::OkOrFail<std::remove_reference_t<decltype(tmp)>> ok_or_fail; \
+    if (!ok_or_fail::IsOk(tmp)) {                                                       \
+      __assert(__FILE__, __LINE__, ok_or_fail::ErrorMessage(tmp).c_str());              \
+    }                                                                                   \
+    ok_or_fail::Unwrap(std::move(tmp));                                                 \
+  })
+#else
+#define OR_FATAL(expr)                                                                  \
+  ({                                                                                    \
+    decltype(expr)&& tmp = (expr);                                                      \
+    typedef android::base::OkOrFail<std::remove_reference_t<decltype(tmp)>> ok_or_fail; \
+    if (!ok_or_fail::IsOk(tmp)) {                                                       \
+      fprintf(stderr, "%s:%d: assertion \"%s\" failed", __FILE__, __LINE__,             \
+              ok_or_fail::ErrorMessage(tmp).c_str());                                   \
+      abort();                                                                          \
+    }                                                                                   \
+    ok_or_fail::Unwrap(std::move(tmp));                                                 \
+  })
+#endif
+
+namespace android {
+namespace base {
+
+// The OkOrFail contract for a type T. This must be implemented for a type T if you want to use
+// OR_RETURN(stmt) where stmt evalues to a value of type T.
+template <typename T>
+struct OkOrFail {
+  // Checks if T is ok or fail.
+  static bool IsOk(const T&);
+
+  // Turns T into the success value.
+  template <typename U>
+  static U Unwrap(T&&);
+
+  // Moves T into OkOrFail<T>, so that we can convert it to other types
+  OkOrFail(T&& v);
+  OkOrFail() = delete;
+  OkOrFail(const T&) = delete;
+
+  // And there need to be one or more conversion operators that turns the error value of T into a
+  // target type. For example, for T = Result<V, E>, there can be ...
+  //
+  // // for the case where OR_RETURN is called in a function expecting E
+  // operator E()&& { return val_.error().code(); }
+  //
+  // // for the case where OR_RETURN is called in a function expecting Result<U, E>
+  // template <typename U>
+  // operator Result<U, E>()&& { return val_.error(); }
+
+  // Returns the string representation of the fail value.
+  static std::string ErrorMessage(const T& v);
+};
+
+}  // namespace base
+}  // namespace android
diff --git a/include/android-base/result.h b/include/android-base/result.h
index faa722e..a5016b9 100644
--- a/include/android-base/result.h
+++ b/include/android-base/result.h
@@ -41,17 +41,33 @@
 //
 // Using custom error code type:
 //
-// enum class MyError { A, B };
-// struct MyErrorPrinter {
-//   static std::string print(const MyError& e) {
-//     switch(e) {
+// enum class MyError { A, B }; // assume that this is the error code you already have
+//
+// // To use the error code with Result, define a wrapper class that provides the following
+// operations and use the wrapper class as the second type parameter (E) when instantiating
+// Result<T, E>
+//
+// 1. default constructor
+// 2. copy constructor / and move constructor if copying is expensive
+// 3. conversion operator to the error code type
+// 4. value() function that return the error code value
+// 5. print() function that gives a string representation of the error ode value
+//
+// struct MyErrorWrapper {
+//   MyError val_;
+//   MyErrorWrapper() : val_(/* reasonable default value */) {}
+//   MyErrorWrapper(MyError&& e) : val_(std:forward<MyError>(e)) {}
+//   operator const MyError&() const { return val_; }
+//   MyError value() const { return val_; }
+//   std::string print() const {
+//     switch(val_) {
 //       MyError::A: return "A";
 //       MyError::B: return "B";
 //     }
 //   }
 // };
 //
-// #define NewMyError(e) Error<MyError, MyErrorPrinter>(MyError::e)
+// #define NewMyError(e) Error<MyErrorWrapper>(MyError::e)
 //
 // Result<T, MyError> val = NewMyError(A) << "some message";
 //
@@ -81,16 +97,38 @@
 #include <sstream>
 #include <string>
 
+#include "android-base/errors.h"
 #include "android-base/expected.h"
 #include "android-base/format.h"
 
 namespace android {
 namespace base {
 
-template <typename E = int>
+// Errno is a wrapper class for errno(3). Use this type instead of `int` when instantiating
+// `Result<T, E>` and `Error<E>` template classes. This is required to distinguish errno from other
+// integer-based error code types like `status_t`.
+struct Errno {
+  Errno() : val_(0) {}
+  Errno(int e) : val_(e) {}
+  int value() const { return val_; }
+  operator int() const { return value(); }
+  std::string print() const { return strerror(value()); }
+
+  int val_;
+
+  // TODO(b/209929099): remove this conversion operator. This currently is needed to not break
+  // existing places where error().code() is used to construct enum values.
+  template <typename E, typename = std::enable_if_t<std::is_enum_v<E>>>
+  operator E() const {
+    return E(val_);
+  }
+};
+
+template <typename E = Errno, bool include_message = true>
 struct ResultError {
-  template <typename T>
-  ResultError(T&& message, E code) : message_(std::forward<T>(message)), code_(code) {}
+  template <typename T, typename P, typename = std::enable_if_t<std::is_convertible_v<P, E>>>
+  ResultError(T&& message, P&& code)
+      : message_(std::forward<T>(message)), code_(E(std::forward<P>(code))) {}
 
   template <typename T>
   // NOLINTNEXTLINE(google-explicit-constructor)
@@ -99,7 +137,7 @@
   }
 
   std::string message() const { return message_; }
-  E code() const { return code_; }
+  const E& code() const { return code_; }
 
  private:
   std::string message_;
@@ -107,6 +145,22 @@
 };
 
 template <typename E>
+struct ResultError<E, /* include_message */ false> {
+  template <typename P, typename = std::enable_if_t<std::is_convertible_v<P, E>>>
+  ResultError(P&& code) : code_(E(std::forward<P>(code))) {}
+
+  template <typename T>
+  operator android::base::expected<T, ResultError<E, false>>() const {
+    return android::base::unexpected(ResultError<E, false>(code_));
+  }
+
+  const E& code() const { return code_; }
+
+ private:
+  E code_;
+};
+
+template <typename E>
 inline bool operator==(const ResultError<E>& lhs, const ResultError<E>& rhs) {
   return lhs.message() == rhs.message() && lhs.code() == rhs.code();
 }
@@ -122,16 +176,28 @@
   return os;
 }
 
-struct ErrnoPrinter {
-  static std::string print(const int& e) { return strerror(e); }
-};
+namespace internal {
+// Stream class that does nothing and is has zero (actually 1) size. It is used instead of
+// std::stringstream when include_message is false so that we use less on stack.
+// sizeof(std::stringstream) is 280 on arm64.
+struct DoNothingStream {
+  template <typename T>
+  DoNothingStream& operator<<(T&&) {
+    return *this;
+  }
 
-template <typename E = int, typename ErrorCodePrinter = ErrnoPrinter>
+  std::string str() const { return ""; }
+};
+}  // namespace internal
+
+template <typename E = Errno, bool include_message = true,
+          typename = std::enable_if_t<!std::is_same_v<E, int>>>
 class Error {
  public:
   Error() : code_(0), has_code_(false) {}
+  template <typename P, typename = std::enable_if_t<std::is_convertible_v<P, E>>>
   // NOLINTNEXTLINE(google-explicit-constructor)
-  Error(E code) : code_(code), has_code_(true) {}
+  Error(P&& code) : code_(std::forward<P>(code)), has_code_(true) {}
 
   template <typename T, typename P, typename = std::enable_if_t<std::is_convertible_v<E, P>>>
   // NOLINTNEXTLINE(google-explicit-constructor)
@@ -139,8 +205,15 @@
     return android::base::unexpected(ResultError<P>(str(), static_cast<P>(code_)));
   }
 
+  template <typename T, typename P, typename = std::enable_if_t<std::is_convertible_v<E, P>>>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  operator android::base::expected<T, ResultError<P, false>>() const {
+    return android::base::unexpected(ResultError<P, false>(static_cast<P>(code_)));
+  }
+
   template <typename T>
   Error& operator<<(T&& t) {
+    static_assert(include_message, "<< not supported when include_message = false");
     // NOLINTNEXTLINE(bugprone-suspicious-semicolon)
     if constexpr (std::is_same_v<std::remove_cv_t<std::remove_reference_t<T>>, ResultError<E>>) {
       if (!has_code_) {
@@ -155,12 +228,13 @@
   }
 
   const std::string str() const {
+    static_assert(include_message, "str() not supported when include_message = false");
     std::string str = ss_.str();
     if (has_code_) {
       if (str.empty()) {
-        return ErrorCodePrinter::print(code_);
+        return code_.print();
       }
-      return std::move(str) + ": " + ErrorCodePrinter::print(code_);
+      return std::move(str) + ": " + code_.print();
     }
     return str;
   }
@@ -181,13 +255,13 @@
     (*this) << message;
   }
 
-  std::stringstream ss_;
+  std::conditional_t<include_message, std::stringstream, internal::DoNothingStream> ss_;
   E code_;
   const bool has_code_;
 };
 
-inline Error<int, ErrnoPrinter> ErrnoError() {
-  return Error<int, ErrnoPrinter>(errno);
+inline Error<Errno> ErrnoError() {
+  return Error<Errno>(Errno{errno});
 }
 
 template <typename E>
@@ -206,42 +280,67 @@
 }
 
 template <typename T, typename... Args>
-inline Error<int, ErrnoPrinter> ErrorfImpl(const T&& fmt, const Args&... args) {
-  return Error(false, ErrorCode(0, args...), fmt::format(fmt, args...));
+inline Error<Errno> ErrorfImpl(const T&& fmt, const Args&... args) {
+  return Error(false, ErrorCode(Errno{}, args...), fmt::format(fmt, args...));
 }
 
 template <typename T, typename... Args>
-inline Error<int, ErrnoPrinter> ErrnoErrorfImpl(const T&& fmt, const Args&... args) {
-  return Error<int, ErrnoPrinter>(true, errno, fmt::format(fmt, args...));
+inline Error<Errno> ErrnoErrorfImpl(const T&& fmt, const Args&... args) {
+  return Error<Errno>(true, Errno{errno}, fmt::format(fmt, args...));
 }
 
 #define Errorf(fmt, ...) android::base::ErrorfImpl(FMT_STRING(fmt), ##__VA_ARGS__)
 #define ErrnoErrorf(fmt, ...) android::base::ErrnoErrorfImpl(FMT_STRING(fmt), ##__VA_ARGS__)
 
-template <typename T, typename E = int>
-using Result = android::base::expected<T, ResultError<E>>;
+template <typename T, typename E = Errno, bool include_message = true>
+using Result = android::base::expected<T, ResultError<E, include_message>>;
+
+// Specialization of android::base::OkOrFail<V> for V = Result<T, E>. See android-base/errors.h
+// for the contract.
+template <typename T, typename E>
+struct OkOrFail<Result<T, E>> {
+  typedef Result<T, E> V;
+  // Checks if V is ok or fail
+  static bool IsOk(const V& val) { return val.ok(); }
+
+  // Turns V into a success value
+  static T Unwrap(V&& val) { return std::move(val.value()); }
+
+  // Consumes V when it's a fail value
+  static OkOrFail<V> Fail(V&& v) {
+    assert(!IsOk(v));
+    return OkOrFail<V>{std::move(v)};
+  }
+  V val_;
+
+  // Turns V into S (convertible from E) or Result<U, E>
+  template <typename S, typename = std::enable_if_t<std::is_convertible_v<E, S>>>
+  operator S() && {
+    return val_.error().code();
+  }
+  template <typename U>
+  operator Result<U, E>() && {
+    return val_.error();
+  }
+
+  static std::string ErrorMessage(const V& val) { return val.error().message(); }
+};
 
 // Macros for testing the results of functions that return android::base::Result.
 // These also work with base::android::expected.
 // For advanced matchers and customized error messages, see result-gtest.h.
 
-#define CHECK_RESULT_OK(stmt)       \
-  do {                              \
-    const auto& tmp = (stmt);       \
-    CHECK(tmp.ok()) << tmp.error(); \
-  } while (0)
+#define ASSERT_RESULT_OK(stmt)                            \
+  if (const auto& tmp = (stmt); !tmp.ok())                \
+  FAIL() << "Value of: " << #stmt << "\n"                 \
+         << "  Actual: " << tmp.error().message() << "\n" \
+         << "Expected: is ok\n"
 
-#define ASSERT_RESULT_OK(stmt)            \
-  do {                                    \
-    const auto& tmp = (stmt);             \
-    ASSERT_TRUE(tmp.ok()) << tmp.error(); \
-  } while (0)
-
-#define EXPECT_RESULT_OK(stmt)            \
-  do {                                    \
-    auto tmp = (stmt);                    \
-    EXPECT_TRUE(tmp.ok()) << tmp.error(); \
-  } while (0)
+#define EXPECT_RESULT_OK(stmt)                                   \
+  if (const auto& tmp = (stmt); !tmp.ok())                       \
+  ADD_FAILURE() << "Value of: " << #stmt << "\n"                 \
+                << "  Actual: " << tmp.error().message() << "\n" \
+                << "Expected: is ok\n"
 
 }  // namespace base
 }  // namespace android
diff --git a/include/android-base/scopeguard.h b/include/android-base/scopeguard.h
index 5a224d6..8293b2c 100644
--- a/include/android-base/scopeguard.h
+++ b/include/android-base/scopeguard.h
@@ -26,14 +26,14 @@
 template <typename F>
 class ScopeGuard {
  public:
-  ScopeGuard(F&& f) : f_(std::forward<F>(f)), active_(true) {}
+  constexpr ScopeGuard(F&& f) : f_(std::forward<F>(f)), active_(true) {}
 
-  ScopeGuard(ScopeGuard&& that) noexcept : f_(std::move(that.f_)), active_(that.active_) {
+  constexpr ScopeGuard(ScopeGuard&& that) noexcept : f_(std::move(that.f_)), active_(that.active_) {
     that.active_ = false;
   }
 
   template <typename Functor>
-  ScopeGuard(ScopeGuard<Functor>&& that) : f_(std::move(that.f_)), active_(that.active_) {
+  constexpr ScopeGuard(ScopeGuard<Functor>&& that) : f_(std::move(that.f_)), active_(that.active_) {
     that.active_ = false;
   }
 
@@ -48,7 +48,7 @@
 
   void Disable() { active_ = false; }
 
-  bool active() const { return active_; }
+  constexpr bool active() const { return active_; }
 
  private:
   template <typename Functor>
diff --git a/include/android-base/strings.h b/include/android-base/strings.h
index 95d6077..e794540 100644
--- a/include/android-base/strings.h
+++ b/include/android-base/strings.h
@@ -104,5 +104,8 @@
 [[nodiscard]] std::string StringReplace(std::string_view s, std::string_view from,
                                         std::string_view to, bool all);
 
+// Converts an errno number to its error message string.
+std::string ErrnoNumberAsString(int errnum);
+
 }  // namespace base
 }  // namespace android
diff --git a/mapped_file.cpp b/mapped_file.cpp
index fff3453..91d0b0f 100644
--- a/mapped_file.cpp
+++ b/mapped_file.cpp
@@ -63,8 +63,8 @@
     }
     return nullptr;
   }
-  void* base = MapViewOfFile(handle, (prot & PROT_WRITE) ? FILE_MAP_ALL_ACCESS : FILE_MAP_READ, 0,
-                             file_offset, file_length);
+  void* base = MapViewOfFile(handle, (prot & PROT_WRITE) ? FILE_MAP_ALL_ACCESS : FILE_MAP_READ,
+                             (file_offset >> 32), file_offset, file_length);
   if (base == nullptr) {
     CloseHandle(handle);
     return nullptr;
diff --git a/posix_strerror_r.cpp b/posix_strerror_r.cpp
new file mode 100644
index 0000000..6428a98
--- /dev/null
+++ b/posix_strerror_r.cpp
@@ -0,0 +1,34 @@
+//
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+/* Undefine _GNU_SOURCE so that this compilation unit can access the
+ * posix version of strerror_r */
+#undef _GNU_SOURCE
+#include <string.h>
+
+namespace android {
+namespace base {
+
+extern "C" int posix_strerror_r(int errnum, char* buf, size_t buflen) {
+#ifdef _WIN32
+  return strerror_s(buf, buflen, errnum);
+#else
+  return strerror_r(errnum, buf, buflen);
+#endif
+}
+
+}  // namespace base
+}  // namespace android
diff --git a/result_test.cpp b/result_test.cpp
index 592b0b8..47feeee 100644
--- a/result_test.cpp
+++ b/result_test.cpp
@@ -192,18 +192,24 @@
 }
 
 enum class CustomError { A, B };
-struct CustomErrorPrinter {
-  static std::string print(const CustomError& e) {
-    switch (e) {
+
+struct CustomErrorWrapper {
+  CustomErrorWrapper() : val_(CustomError::A) {}
+  CustomErrorWrapper(const CustomError& e) : val_(e) {}
+  CustomError value() const { return val_; }
+  operator CustomError() const { return value(); }
+  std::string print() const {
+    switch (val_) {
       case CustomError::A:
         return "A";
       case CustomError::B:
         return "B";
     }
   }
+  CustomError val_;
 };
 
-#define NewCustomError(e) Error<CustomError, CustomErrorPrinter>(CustomError::e)
+#define NewCustomError(e) Error<CustomErrorWrapper>(CustomError::e)
 
 TEST(result, result_with_custom_errorcode) {
   Result<void, CustomError> ok = {};
@@ -237,6 +243,72 @@
   EXPECT_EQ("aaaaa", *result);
 }
 
+TEST(result, unwrap_or_return) {
+  auto f = [](bool success) -> Result<size_t, CustomError> {
+    return OR_RETURN(success_or_fail(success)).size();
+  };
+
+  auto r = f(true);
+  EXPECT_TRUE(r.ok());
+  EXPECT_EQ(strlen("success"), *r);
+
+  auto s = f(false);
+  EXPECT_FALSE(s.ok());
+  EXPECT_EQ(CustomError::A, s.error().code());
+  EXPECT_EQ("fail: A", s.error().message());
+}
+
+TEST(result, unwrap_or_return_errorcode) {
+  auto f = [](bool success) -> CustomError {
+    // Note that we use the same OR_RETURN macro for different return types: Result<U, CustomError>
+    // and CustomError.
+    std::string val = OR_RETURN(success_or_fail(success));
+    EXPECT_EQ("success", val);
+    return CustomError::B;
+  };
+
+  auto r = f(true);
+  EXPECT_EQ(CustomError::B, r);
+
+  auto s = f(false);
+  EXPECT_EQ(CustomError::A, s);
+}
+
+TEST(result, unwrap_or_fatal) {
+  auto r = OR_FATAL(success_or_fail(true));
+  EXPECT_EQ("success", r);
+
+  EXPECT_DEATH(OR_FATAL(success_or_fail(false)), "fail: A");
+}
+
+struct MyData {
+  const int data;
+  static int copy_constructed;
+  static int move_constructed;
+  MyData(int d) : data(d) {}
+  MyData(const MyData& other) : data(other.data) { copy_constructed++; }
+  MyData(MyData&& other) : data(other.data) { move_constructed++; }
+};
+
+int MyData::copy_constructed = 0;
+int MyData::move_constructed = 0;
+
+TEST(result, unwrap_does_not_incur_additional_copying) {
+  MyData::copy_constructed = 0;
+  MyData::move_constructed = 0;
+  auto f = []() -> Result<MyData> { return MyData{10}; };
+
+  [&]() -> Result<void> {
+    int data = OR_RETURN(f()).data;
+    EXPECT_EQ(10, data);
+    EXPECT_EQ(0, MyData::copy_constructed);
+    // Moved once when MyData{10} is returned as Result<MyData> in the lambda f.
+    // Moved once again when the variable d is constructed from OR_RETURN.
+    EXPECT_EQ(2, MyData::move_constructed);
+    return {};
+  }();
+}
+
 struct ConstructorTracker {
   static size_t constructor_called;
   static size_t copy_constructor_called;
@@ -463,6 +535,14 @@
             outer.error().message());
 }
 
+TEST(result, error_without_message) {
+  constexpr bool include_message = false;
+  Result<void, Errno, include_message> res = Error<Errno, include_message>(10);
+  EXPECT_FALSE(res.ok());
+  EXPECT_EQ(10, res.error().code());
+  EXPECT_EQ(sizeof(int), sizeof(res.error()));
+}
+
 namespace testing {
 
 class Listener : public ::testing::MatchResultListener {
diff --git a/strings.cpp b/strings.cpp
index 8f3c7d9..deb6e28 100644
--- a/strings.cpp
+++ b/strings.cpp
@@ -16,12 +16,18 @@
 
 #include "android-base/strings.h"
 
+#include "android-base/stringprintf.h"
+
 #include <stdlib.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
 
+// Wraps the posix version of strerror_r to make it available in translation units
+// that define _GNU_SOURCE.
+extern "C" int posix_strerror_r(int errnum, char* buf, size_t buflen);
+
 namespace android {
 namespace base {
 
@@ -152,5 +158,15 @@
   return result;
 }
 
+std::string ErrnoNumberAsString(int errnum) {
+  char buf[100];
+  buf[0] = '\0';
+  int strerror_err = posix_strerror_r(errnum, buf, sizeof(buf));
+  if (strerror_err < 0) {
+    return StringPrintf("Failed to convert errno %d to string: %d", errnum, strerror_err);
+  }
+  return buf;
+}
+
 }  // namespace base
 }  // namespace android
diff --git a/strings_test.cpp b/strings_test.cpp
index 7a57489..fb111b8 100644
--- a/strings_test.cpp
+++ b/strings_test.cpp
@@ -400,3 +400,7 @@
   ASSERT_EQ("xxyzx", android::base::StringReplace("abcxyzabc", "abc", "x", true));
   ASSERT_EQ("<xx>", android::base::StringReplace("<abcabc>", "abc", "x", true));
 }
+
+TEST(strings, ErrnoNumberAsString) {
+  EXPECT_EQ("No such file or directory", android::base::ErrnoNumberAsString(ENOENT));
+}