diff --git a/Android.bp b/Android.bp
index 461f1db..ef56692 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,
@@ -80,10 +83,12 @@
         "chrono_utils.cpp",
         "cmsg.cpp",
         "file.cpp",
+        "hex.cpp",
         "logging.cpp",
         "mapped_file.cpp",
         "parsebool.cpp",
         "parsenetaddress.cpp",
+        "posix_strerror_r.cpp",
         "process.cpp",
         "properties.cpp",
         "stringprintf.cpp",
@@ -146,7 +151,6 @@
         "libbase_headers",
     ],
     export_header_lib_headers: ["libbase_headers"],
-    static_libs: ["fmtlib"],
     whole_static_libs: ["fmtlib"],
     export_static_lib_headers: ["fmtlib"],
     apex_available: [
@@ -161,9 +165,7 @@
     sdk_version: "current",
     stl: "c++_static",
     export_include_dirs: ["include"],
-    static_libs: ["fmtlib_ndk"],
     whole_static_libs: ["fmtlib_ndk"],
-    export_static_lib_headers: ["fmtlib_ndk"],
 }
 
 // Tests
@@ -180,6 +182,7 @@
         "expected_test.cpp",
         "file_test.cpp",
         "function_ref_test.cpp",
+        "hex_test.cpp",
         "logging_splitters_test.cpp",
         "logging_test.cpp",
         "macros_test.cpp",
@@ -215,6 +218,7 @@
     },
     local_include_dirs: ["."],
     shared_libs: ["libbase"],
+    static_libs: ["libgmock"],
     compile_multilib: "both",
     multilib: {
         lib32: {
@@ -244,6 +248,37 @@
     test_suites: ["device_tests"],
 }
 
+// Can be removed when we move to c++20
+cc_test {
+    name: "libbase_result_constraint_test",
+    defaults: ["libbase_cflags_defaults"],
+    host_supported: true,
+    srcs: [
+        "result_test_constraint.cpp",
+    ],
+    target: {
+        android: {
+            sanitize: {
+                misc_undefined: ["integer"],
+            },
+        },
+    },
+    cpp_std: "gnu++20",
+    local_include_dirs: ["."],
+    shared_libs: ["libbase"],
+    static_libs: ["libgmock"],
+    compile_multilib: "both",
+    multilib: {
+        lib32: {
+            suffix: "32",
+        },
+        lib64: {
+            suffix: "64",
+        },
+    },
+    test_suites: ["device-tests"],
+}
+
 cc_benchmark {
     name: "libbase_benchmark",
     defaults: ["libbase_cflags_defaults"],
diff --git a/OWNERS b/OWNERS
index 97777f7..682a067 100644
--- a/OWNERS
+++ b/OWNERS
@@ -1,3 +1 @@
 enh@google.com
-jmgao@google.com
-tomcherry@google.com
diff --git a/TEST_MAPPING b/TEST_MAPPING
index 3659bee..a3b2bfc 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -3,5 +3,10 @@
     {
       "name": "libbase_test"
     }
+  ],
+  "hwasan-postsubmit": [
+    {
+      "name": "libbase_test"
+    }
   ]
 }
diff --git a/hex.cpp b/hex.cpp
new file mode 100644
index 0000000..a4b7715
--- /dev/null
+++ b/hex.cpp
@@ -0,0 +1,42 @@
+/*
+ * 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.
+ */
+
+#include "android-base/hex.h"
+
+#include "android-base/logging.h"
+
+namespace android {
+namespace base {
+
+std::string HexString(const void* bytes, size_t len) {
+  CHECK(bytes != nullptr || len == 0) << bytes << " " << len;
+
+  // b/132916539: Doing this the 'C way', std::setfill triggers ubsan implicit conversion
+  const uint8_t* bytes8 = static_cast<const uint8_t*>(bytes);
+  const char chars[] = "0123456789abcdef";
+  std::string result;
+  result.resize(len * 2);
+
+  for (size_t i = 0; i < len; i++) {
+    result[2 * i] = chars[bytes8[i] >> 4];
+    result[2 * i + 1] = chars[bytes8[i] & 0xf];
+  }
+
+  return result;
+}
+
+}  // namespace base
+}  // namespace android
diff --git a/hex_test.cpp b/hex_test.cpp
new file mode 100644
index 0000000..ebf798c
--- /dev/null
+++ b/hex_test.cpp
@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#include "android-base/hex.h"
+
+#include <gtest/gtest.h>
+
+TEST(hex, empty) {
+  ASSERT_EQ("", android::base::HexString(nullptr, 0));
+  ASSERT_EQ("", android::base::HexString(reinterpret_cast<void*>(int32_t(0)), 0));
+}
+
+TEST(hex, short) {
+  const int32_t kShortData = 0xDEADBEEF;
+  ASSERT_EQ("ef", android::base::HexString(&kShortData, 1));
+  ASSERT_EQ("efbe", android::base::HexString(&kShortData, 2));
+  ASSERT_EQ("efbead", android::base::HexString(&kShortData, 3));
+  ASSERT_EQ("efbeadde", android::base::HexString(&kShortData, 4));
+}
+
+TEST(hex, all) {
+  constexpr size_t kSize = 256;
+  uint8_t kLongData[kSize];
+  for (size_t i = 0; i < kSize; i++) {
+    kLongData[i] = i;
+  }
+
+  ASSERT_EQ(
+      "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d"
+      "2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b"
+      "5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f80818283848586878889"
+      "8a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7"
+      "b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5"
+      "e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
+      android::base::HexString(&kLongData, kSize));
+}
diff --git a/include/android-base/endian.h b/include/android-base/endian.h
index 8fa6365..b47494b 100644
--- a/include/android-base/endian.h
+++ b/include/android-base/endian.h
@@ -25,18 +25,19 @@
 
 #include <sys/endian.h>
 
-#elif defined(__GLIBC__)
+#elif defined(__GLIBC__) || defined(ANDROID_HOST_MUSL)
 
-/* glibc's <endian.h> is like bionic's <sys/endian.h>. */
+/* glibc and musl's <endian.h> are like bionic's <sys/endian.h>. */
 #include <endian.h>
 
-/* glibc keeps htons and htonl in <netinet/in.h>. */
+/* glibc and musl keep htons and htonl in <netinet/in.h>. */
 #include <netinet/in.h>
 
-/* glibc doesn't have the 64-bit variants. */
+/* glibc and musl don't have the 64-bit variants. */
 #define htonq(x) htobe64(x)
 #define ntohq(x) be64toh(x)
 
+#if defined(__GLIBC__)
 /* glibc has different names to BSD for these. */
 #define betoh16(x) be16toh(x)
 #define betoh32(x) be32toh(x)
@@ -44,6 +45,7 @@
 #define letoh16(x) le16toh(x)
 #define letoh32(x) le32toh(x)
 #define letoh64(x) le64toh(x)
+#endif
 
 #else
 
diff --git a/include/android-base/errors.h b/include/android-base/errors.h
index 06f29fc..61fdbd8 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,102 @@
 
 }  // 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.
+// If implicit conversion compilation errors occur involving a value type with a templated
+// forwarding ref ctor, compilation with cpp20 or explicitly converting to the desired
+// return type is required.
+#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, typename = void>
+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/expected.h b/include/android-base/expected.h
index 11cf1ac..3b9d45f 100644
--- a/include/android-base/expected.h
+++ b/include/android-base/expected.h
@@ -37,7 +37,7 @@
 //
 // void test() {
 //   auto q = safe_divide(10, 0);
-//   if (q) { printf("%f\n", q.value()); }
+//   if (q.ok()) { printf("%f\n", q.value()); }
 //   else { printf("%s\n", q.error().c_str()); }
 // }
 //
diff --git a/include/android-base/hex.h b/include/android-base/hex.h
new file mode 100644
index 0000000..cbb26a8
--- /dev/null
+++ b/include/android-base/hex.h
@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace android {
+namespace base {
+
+// Converts binary data into a hexString.
+//
+// Hex values are printed in order, e.g. 0xDEAD will result in 'adde' because
+// Android is little-endian.
+std::string HexString(const void* bytes, size_t len);
+
+}  // namespace base
+}  // namespace android
diff --git a/include/android-base/result-gmock.h b/include/android-base/result-gmock.h
new file mode 100644
index 0000000..1fd9f00
--- /dev/null
+++ b/include/android-base/result-gmock.h
@@ -0,0 +1,101 @@
+/*
+ * 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.
+ */
+
+#pragma once
+#include <android-base/result.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+/*
+ * Matchers for android::base::Result<T> that produces human-readable test results.
+ *
+ * Example:
+ *
+ * Result<int> result = ...
+ *
+ * using namespace ::android::base::testing;
+ * using namespace ::testing;
+ *
+ * EXPECT_THAT(result, Ok());
+ * EXPECT_THAT(result, Not(Ok()));
+ * EXPECT_THAT(result, HasValue(5));
+ * EXPECT_THAT(result, HasError(WithCode(EBADF)));
+ * EXPECT_THAT(result, HasError(WithMessageMessage("expected error message")));
+ *
+ * // Advance usage
+ * EXPECT_THAT(result, AnyOf(Ok(), HasError(WithCode(EACCES)));
+ * EXPECT_THAT(result, HasError(WithCode(AnyOf(EBADF, EACCES))) << "Unexpected code from library";
+ */
+
+namespace android::base {
+
+template <typename T>
+inline void PrintTo(const Result<T>& result, std::ostream* os) {
+  if (result.ok()) {
+    *os << "OK: " << ::testing::PrintToString(result.value());
+  } else {
+    *os << "Error: " << result.error();
+  }
+}
+
+template <>
+inline void PrintTo(const Result<void>& result, std::ostream* os) {
+  if (result.ok()) {
+    *os << "OK";
+  } else {
+    *os << "Error: " << result.error();
+  }
+}
+
+namespace testing {
+
+MATCHER(Ok, "") {
+  if (arg.ok()) {
+    *result_listener << "result is OK";
+    return true;
+  }
+  *result_listener << "error is " << arg.error();
+  return false;
+}
+
+MATCHER_P(HasValue, value_matcher, "") {
+  if (arg.ok()) {
+    return ::testing::ExplainMatchResult(value_matcher, arg.value(), result_listener);
+  }
+  *result_listener << "error is " << arg.error();
+  return false;
+}
+
+MATCHER_P(HasError, error_matcher, "") {
+  if (!arg.ok()) {
+    return ::testing::ExplainMatchResult(error_matcher, arg.error(), result_listener);
+  }
+  *result_listener << "result is OK";
+  return false;
+}
+
+MATCHER_P(WithCode, code_matcher, "") {
+  *result_listener << "actual error is " << arg;
+  return ::testing::ExplainMatchResult(code_matcher, arg.code(), result_listener);
+}
+
+MATCHER_P(WithMessage, message_matcher, "") {
+  *result_listener << "actual error is " << arg;
+  return ::testing::ExplainMatchResult(message_matcher, arg.message(), result_listener);
+}
+
+}  // namespace testing
+}  // namespace android::base
diff --git a/include/android-base/result.h b/include/android-base/result.h
index 56a4f3e..9715a8c 100644
--- a/include/android-base/result.h
+++ b/include/android-base/result.h
@@ -14,125 +14,212 @@
  * limitations under the License.
  */
 
-// This file contains classes for returning a successful result along with an optional
-// arbitrarily typed return value or for returning a failure result along with an optional string
-// indicating why the function failed.
-
-// There are 3 classes that implement this functionality and one additional helper type.
+// Result<T, E> is the type that is used to pass a success value of type T or an error code of type
+// E, optionally together with an error message. T and E can be any type. If E is omitted it
+// defaults to int, which is useful when errno(3) is used as the error code.
 //
-// Result<T> either contains a member of type T that can be accessed using similar semantics as
-// std::optional<T> or it contains a ResultError describing an error, which can be accessed via
-// Result<T>::error().
+// Passing a success value or an error value:
 //
-// ResultError is a type that contains both a std::string describing the error and a copy of errno
-// from when the error occurred.  ResultError can be used in an ostream directly to print its
-// string value.
-//
-// Result<void> is the correct return type for a function that either returns successfully or
-// returns an error value.  Returning {} from a function that returns Result<void> is the
-// correct way to indicate that a function without a return type has completed successfully.
-//
-// A successful Result<T> is constructed implicitly from any type that can be implicitly converted
-// to T or from the constructor arguments for T.  This allows you to return a type T directly from
-// a function that returns Result<T>.
-//
-// Error and ErrnoError are used to construct a Result<T> that has failed.  The Error class takes
-// an ostream as an input and are implicitly cast to a Result<T> containing that failure.
-// ErrnoError() is a helper function to create an Error class that appends ": " + strerror(errno)
-// to the end of the failure string to aid in interacting with C APIs.  Alternatively, an errno
-// value can be directly specified via the Error() constructor.
-//
-// Errorf and ErrnoErrorf accept the format string syntax of the fmblib (https://fmt.dev).
-// Errorf("{} errors", num) is equivalent to Error() << num << " errors".
-//
-// ResultError can be used in the ostream and when using Error/Errorf to construct a Result<T>.
-// In this case, the string that the ResultError takes is passed through the stream normally, but
-// the errno is passed to the Result<T>. This can be used to pass errno from a failing C function up
-// multiple callers. Note that when the outer Result<T> is created with ErrnoError/ErrnoErrorf then
-// the errno from the inner ResultError is not passed. Also when multiple ResultError objects are
-// used, the errno of the last one is respected.
-//
-// ResultError can also directly construct a Result<T>.  This is particularly useful if you have a
-// function that return Result<T> but you have a Result<U> and want to return its error.  In this
-// case, you can return the .error() from the Result<U> to construct the Result<T>.
-
-// An example of how to use these is below:
-// Result<U> CalculateResult(const T& input) {
-//   U output;
-//   if (!SomeOtherCppFunction(input, &output)) {
-//     return Errorf("SomeOtherCppFunction {} failed", input);
+// Result<std::string> readFile() {
+//   std::string content;
+//   if (base::ReadFileToString("path", &content)) {
+//     return content; // ok case
+//   } else {
+//     return ErrnoError() << "failed to read"; // error case
 //   }
-//   if (!c_api_function(output)) {
-//     return ErrnoErrorf("c_api_function {} failed", output);
-//   }
-//   return output;
 // }
 //
-// auto output = CalculateResult(input);
-// if (!output) return Error() << "CalculateResult failed: " << output.error();
-// UseOutput(*output);
+// Checking the result and then unwrapping the value or propagating the error:
+//
+// Result<bool> hasAWord() {
+//   auto content = readFile();
+//   if (!content.ok()) {
+//     return Error() << "failed to process: " << content.error();
+//   }
+//   return (*content.find("happy") != std::string::npos);
+// }
+//
+// Using custom error code type:
+//
+// 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<MyErrorWrapper>(MyError::e)
+//
+// Result<T, MyError> val = NewMyError(A) << "some message";
+//
+// Formatting the error message using fmtlib:
+//
+// Errorf("{} errors", num); // equivalent to Error() << num << " errors";
+// ErrnoErrorf("{} errors", num); // equivalent to ErrnoError() << num << " errors";
+//
+// Returning success or failure, but not the value:
+//
+// Result<void> doSomething() {
+//   if (success) return {};
+//   else return Error() << "error occurred";
+// }
+//
+// Extracting error code:
+//
+// Result<T> val = Error(3) << "some error occurred";
+// assert(3 == val.error().code());
+//
 
 #pragma once
 
+#include <assert.h>
 #include <errno.h>
 
 #include <sstream>
 #include <string>
+#include <type_traits>
 
+#include "android-base/errors.h"
 #include "android-base/expected.h"
 #include "android-base/format.h"
 
 namespace android {
 namespace base {
 
+// 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, int 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)
-  operator android::base::expected<T, ResultError>() {
-    return android::base::unexpected(ResultError(message_, code_));
+  operator android::base::expected<T, ResultError<E>>() const {
+    return android::base::unexpected(ResultError<E>(message_, code_));
   }
 
   std::string message() const { return message_; }
-  int code() const { return code_; }
+  const E& code() const { return code_; }
 
  private:
   std::string message_;
-  int code_;
+  E code_;
 };
 
-inline bool operator==(const ResultError& lhs, const ResultError& rhs) {
+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();
 }
 
-inline bool operator!=(const ResultError& lhs, const ResultError& rhs) {
+template <typename E>
+inline bool operator!=(const ResultError<E>& lhs, const ResultError<E>& rhs) {
   return !(lhs == rhs);
 }
 
-inline std::ostream& operator<<(std::ostream& os, const ResultError& t) {
+template <typename E>
+inline std::ostream& operator<<(std::ostream& os, const ResultError<E>& t) {
   os << t.message();
   return os;
 }
 
+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;
+  }
+
+  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() : errno_(0), append_errno_(false) {}
+  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(int errno_to_append) : errno_(errno_to_append), append_errno_(true) {}
+  Error(P&& code) : code_(std::forward<P>(code)), has_code_(true) {}
 
-  template <typename T>
+  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>() {
-    return android::base::unexpected(ResultError(str(), errno_));
+  operator android::base::expected<T, ResultError<P>>() const {
+    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>) {
-      errno_ = t.code();
+    if constexpr (std::is_same_v<std::remove_cv_t<std::remove_reference_t<T>>, ResultError<E>>) {
+      if (!has_code_) {
+        code_ = t.code();
+      }
       return (*this) << t.message();
     }
     int saved = errno;
@@ -142,12 +229,13 @@
   }
 
   const std::string str() const {
+    static_assert(include_message, "str() not supported when include_message = false");
     std::string str = ss_.str();
-    if (append_errno_) {
+    if (has_code_) {
       if (str.empty()) {
-        return strerror(errno_);
+        return code_.print();
       }
-      return std::move(str) + ": " + strerror(errno_);
+      return std::move(str) + ": " + code_.print();
     }
     return str;
   }
@@ -164,72 +252,183 @@
   friend Error ErrnoErrorfImpl(const T&& fmt, const Args&... args);
 
  private:
-  Error(bool append_errno, int errno_to_append, const std::string& message)
-      : errno_(errno_to_append), append_errno_(append_errno) {
+  Error(bool has_code, E code, const std::string& message) : code_(code), has_code_(has_code) {
     (*this) << message;
   }
 
-  std::stringstream ss_;
-  int errno_;
-  const bool append_errno_;
+  std::conditional_t<include_message, std::stringstream, internal::DoNothingStream> ss_;
+  E code_;
+  const bool has_code_;
 };
 
-inline Error ErrnoError() {
-  return Error(errno);
+inline Error<Errno> ErrnoError() {
+  return Error<Errno>(Errno{errno});
 }
 
-inline int ErrorCode(int code) {
+template <typename E>
+inline E ErrorCode(E code) {
   return code;
 }
 
 // Return the error code of the last ResultError object, if any.
 // Otherwise, return `code` as it is.
-template <typename T, typename... Args>
-inline int ErrorCode(int code, T&& t, const Args&... args) {
-  if constexpr (std::is_same_v<std::remove_cv_t<std::remove_reference_t<T>>, ResultError>) {
+template <typename T, typename E, typename... Args>
+inline E ErrorCode(E code, T&& t, const Args&... args) {
+  if constexpr (std::is_same_v<std::remove_cv_t<std::remove_reference_t<T>>, ResultError<E>>) {
     return ErrorCode(t.code(), args...);
   }
   return ErrorCode(code, args...);
 }
 
 template <typename T, typename... Args>
-inline Error 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 ErrnoErrorfImpl(const T&& fmt, const Args&... args) {
-  return Error(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 = 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.
+
+namespace impl {
+template <typename U>
+using Code = std::decay_t<decltype(std::declval<U>().error().code())>;
+
+template <typename U>
+using ErrorType = std::decay_t<decltype(std::declval<U>().error())>;
+
+template <typename U>
+constexpr bool IsNumeric = std::is_integral_v<U> || std::is_floating_point_v<U> ||
+                           (std::is_enum_v<U> && std::is_convertible_v<U, size_t>);
+
+// This base class exists to take advantage of shadowing
+// We include the conversion in this base class so that if the conversion in NumericConversions
+// overlaps, we (arbitrarily) choose the implementation in NumericConversions due to shadowing.
 template <typename T>
-using Result = android::base::expected<T, ResultError>;
+struct ConversionBase {
+  ErrorType<T> error_;
+  // T is a expected<U, ErrorType<T>>.
+  operator const T() const && {
+    return unexpected(std::move(error_));
+  }
+
+  operator const Code<T>() const && {
+    return error_.code();
+  }
+
+};
+
+// User defined conversions can be followed by numeric conversions
+// Although we template specialize for the exact code type, we need
+// specializations for conversions to all numeric types to avoid an
+// ambiguous conversion sequence.
+template <typename T, typename = void>
+struct NumericConversions : public ConversionBase<T> {};
+template <typename T>
+struct NumericConversions<T,
+    std::enable_if_t<impl::IsNumeric<impl::Code<T>>>
+    > : public ConversionBase<T>
+{
+#pragma push_macro("SPECIALIZED_CONVERSION")
+#define SPECIALIZED_CONVERSION(type)\
+  operator const expected<type, ErrorType<T>>() const &&\
+  { return unexpected(std::move(this->error_));}
+
+  SPECIALIZED_CONVERSION(int)
+  SPECIALIZED_CONVERSION(short int)
+  SPECIALIZED_CONVERSION(unsigned short int)
+  SPECIALIZED_CONVERSION(unsigned int)
+  SPECIALIZED_CONVERSION(long int)
+  SPECIALIZED_CONVERSION(unsigned long int)
+  SPECIALIZED_CONVERSION(long long int)
+  SPECIALIZED_CONVERSION(unsigned long long int)
+  SPECIALIZED_CONVERSION(bool)
+  SPECIALIZED_CONVERSION(char)
+  SPECIALIZED_CONVERSION(unsigned char)
+  SPECIALIZED_CONVERSION(signed char)
+  SPECIALIZED_CONVERSION(wchar_t)
+  SPECIALIZED_CONVERSION(char16_t)
+  SPECIALIZED_CONVERSION(char32_t)
+  SPECIALIZED_CONVERSION(float)
+  SPECIALIZED_CONVERSION(double)
+  SPECIALIZED_CONVERSION(long double)
+
+#undef SPECIALIZED_CONVERSION
+#pragma pop_macro("SPECIALIZED_CONVERSION")
+  // For debugging purposes
+  using IsNumericT = std::true_type;
+};
+
+#ifdef __cpp_concepts
+template<class U>
+concept Trivial = std::is_same_v<U, U>;
+#endif
+} // namespace impl
+
+template <typename T, typename E, bool include_message>
+struct OkOrFail<Result<T, E, include_message>>
+    : public impl::NumericConversions<Result<T, E, include_message>> {
+  using V = Result<T, E, include_message>;
+  using Err = impl::ErrorType<V>;
+  using C = impl::Code<V>;
+private:
+   OkOrFail(Err&& v): impl::NumericConversions<V>{std::move(v)} {}
+   OkOrFail(const OkOrFail& other) = delete;
+   OkOrFail(const OkOrFail&& other) = delete;
+public:
+  // 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 const OkOrFail<V> Fail(V&& v) {
+    assert(!IsOk(v));
+    return OkOrFail<V>{std::move(v.error())};
+  }
+
+  // We specialize as much as possible to avoid ambiguous conversion with
+  // templated expected ctor
+  operator const Result<C, E, include_message>() const && {
+    return unexpected(std::move(this->error_));
+  }
+#ifdef __cpp_concepts
+  template <impl::Trivial U>
+#else
+  template <typename U>
+#endif
+  operator const Result<U, E, include_message>() const && {
+    return unexpected(std::move(this->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)
-
-// TODO: Maybe add RETURN_IF_ERROR() and ASSIGN_OR_RETURN()
+#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/silent_death_test.h b/include/android-base/silent_death_test.h
index 2aec890..261fa74 100644
--- a/include/android-base/silent_death_test.h
+++ b/include/android-base/silent_death_test.h
@@ -17,34 +17,113 @@
 #pragma once
 
 #include <signal.h>
-
 #include <gtest/gtest.h>
 
+#include <array>
+#include <memory>
+
 #if !defined(__BIONIC__)
 #define sigaction64 sigaction
 #endif
 
-// Disables debuggerd stack traces to speed up death tests and make them less
-// noisy in logcat.
+// INTRODUCTION
 //
-// Use `using my_DeathTest = SilentDeathTest;` instead of inheriting from
-// testing::Test yourself.
-class SilentDeathTest : public testing::Test {
- protected:
-  virtual void SetUp() {
-    // Suppress debuggerd stack traces. Too slow.
-    for (int signo : {SIGABRT, SIGBUS, SIGSEGV, SIGSYS}) {
+// It can be useful to disable debuggerd stack traces/tombstones in death tests.
+// Reasons include:
+//
+//   1. speeding up death tests
+//   2. reducing the noise in logcat (for humans)
+//   3. avoiding bots from thinking that expected deaths should be reported in
+//      stability metrics/have bugs auto-filed
+//
+// When writing new death tests, inherit the test suite from SilentDeathTest
+// defined below.
+//
+// Only use ScopedSilentDeath in a test case/suite if changing the test base
+// class from testing::Test to SilentDeathTest adds additional complextity when
+// test suite code is shared between death and non-death tests.
+//
+// EXAMPLES
+//
+// For example, use SilentDeathTest for this simple case where there's no shared
+// setup or teardown:
+//
+//   using FooDeathTest = SilentDeathTest;
+//
+//   TEST(FooTest, DoesThis) {
+//     // normal test
+//   }
+//
+//   TEST_F(FooDeathTest, DoesThat) {
+//     // death test
+//   }
+//
+// Alternatively, use ScopedSilentDeath if you already have a Test subclass for
+// shared setup or teardown:
+//
+//   class FooTest : public testing::Test { ... /* shared setup/teardown */ };
+//
+//   using FooDeathTest = FooTest;
+//
+//   TEST_F(FooTest, DoesThis) {
+//     // normal test
+//   }
+//
+//   TEST_F(FooDeathTest, DoesThat) {
+//     ScopedSilentDeath _silentDeath;
+//     // death test
+//   }
+//
+// NOTES
+//
+// When writing death tests, consider using ASSERT_EXIT() and EXPECT_EXIT()
+// rather than the more obvious ASSERT_DEATH()/EXPECT_DEATH() macros... The
+// advantage is that you can specify a regular expression that you expect
+// the abort message to match, and can be explicit about what signal you expect
+// to die with, and you can also test for *successful* exits too. Examples:
+//
+//   ASSERT_DEATH(foo(), "some text\\. some more\\.");
+//
+//   ASSERT_EXIT(bar(), testing::ExitedWithCode(0), "Success");
+//
+//   ASSERT_EXIT(baz(), testing::KilledBySignal(SIGABRT),
+//               "expected detail message \\(blah\\)");
+//
+// As you can see the regular expression functionality is there for
+// ASSERT_DEATH() too, but it's important to realize that it's a regular
+// expression, so (as in the first and third examples), you'll need to quote
+// any metacharacters (and because it's a string literal, you'll either need
+// extra quoting or want to use a raw string).
+
+class ScopedSilentDeath {
+ public:
+  ScopedSilentDeath() {
+    for (int signo : SUPPRESSED_SIGNALS) {
       struct sigaction64 action = {.sa_handler = SIG_DFL};
       sigaction64(signo, &action, &previous_);
     }
   }
 
-  virtual void TearDown() {
-    for (int signo : {SIGABRT, SIGBUS, SIGSEGV, SIGSYS}) {
+  ~ScopedSilentDeath() {
+    for (int signo : SUPPRESSED_SIGNALS) {
       sigaction64(signo, &previous_, nullptr);
     }
   }
 
  private:
+  static constexpr std::array<int, 4> SUPPRESSED_SIGNALS = {SIGABRT, SIGBUS, SIGSEGV, SIGSYS};
+
   struct sigaction64 previous_;
 };
+
+class SilentDeathTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    silent_death_ = std::unique_ptr<ScopedSilentDeath>(new ScopedSilentDeath);
+  }
+
+  void TearDown() override { silent_death_.reset(); }
+
+ private:
+  std::unique_ptr<ScopedSilentDeath> silent_death_;
+};
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/include/android-base/test_utils.h b/include/android-base/test_utils.h
index f3d7cb0..29dc394 100644
--- a/include/android-base/test_utils.h
+++ b/include/android-base/test_utils.h
@@ -18,6 +18,7 @@
 
 #include <regex>
 #include <string>
+#include <type_traits>
 
 #include <android-base/file.h>
 #include <android-base/macros.h>
@@ -53,34 +54,44 @@
   CapturedStdout() : CapturedStdFd(STDOUT_FILENO) {}
 };
 
-#define ASSERT_MATCH(str, pattern)                                           \
-  do {                                                                       \
-    auto __s = (str);                                                        \
-    if (!std::regex_search(__s, std::regex((pattern)))) {                    \
-      FAIL() << "regex mismatch: expected " << (pattern) << " in:\n" << __s; \
-    }                                                                        \
+#define __LIBBASE_GENERIC_REGEX_SEARCH(__s, __pattern) \
+  (std::regex_search(__s, std::basic_regex<std::decay<decltype(__s[0])>::type>((__pattern))))
+
+#define ASSERT_MATCH(__string, __pattern)                                      \
+  do {                                                                         \
+    auto __s = (__string);                                                     \
+    if (!__LIBBASE_GENERIC_REGEX_SEARCH(__s, (__pattern))) {                   \
+      FAIL() << "regex mismatch: expected " << (__pattern) << " in:\n" << __s; \
+    }                                                                          \
   } while (0)
 
-#define ASSERT_NOT_MATCH(str, pattern)                                                   \
-  do {                                                                                   \
-    auto __s = (str);                                                                    \
-    if (std::regex_search(__s, std::regex((pattern)))) {                                 \
-      FAIL() << "regex mismatch: expected to not find " << (pattern) << " in:\n" << __s; \
-    }                                                                                    \
+#define ASSERT_NOT_MATCH(__string, __pattern)                                              \
+  do {                                                                                     \
+    auto __s = (__string);                                                                 \
+    if (__LIBBASE_GENERIC_REGEX_SEARCH(__s, (__pattern))) {                                \
+      FAIL() << "regex mismatch: expected to not find " << (__pattern) << " in:\n" << __s; \
+    }                                                                                      \
   } while (0)
 
-#define EXPECT_MATCH(str, pattern)                                                  \
-  do {                                                                              \
-    auto __s = (str);                                                               \
-    if (!std::regex_search(__s, std::regex((pattern)))) {                           \
-      ADD_FAILURE() << "regex mismatch: expected " << (pattern) << " in:\n" << __s; \
-    }                                                                               \
+#define EXPECT_MATCH(__string, __pattern)                                             \
+  do {                                                                                \
+    auto __s = (__string);                                                            \
+    if (!__LIBBASE_GENERIC_REGEX_SEARCH(__s, (__pattern))) {                          \
+      ADD_FAILURE() << "regex mismatch: expected " << (__pattern) << " in:\n" << __s; \
+    }                                                                                 \
   } while (0)
 
-#define EXPECT_NOT_MATCH(str, pattern)                                                          \
-  do {                                                                                          \
-    auto __s = (str);                                                                           \
-    if (std::regex_search(__s, std::regex((pattern)))) {                                        \
-      ADD_FAILURE() << "regex mismatch: expected to not find " << (pattern) << " in:\n" << __s; \
-    }                                                                                           \
+#define EXPECT_NOT_MATCH(__string, __pattern)                                                     \
+  do {                                                                                            \
+    auto __s = (__string);                                                                        \
+    if (__LIBBASE_GENERIC_REGEX_SEARCH(__s, (__pattern))) {                                       \
+      ADD_FAILURE() << "regex mismatch: expected to not find " << (__pattern) << " in:\n" << __s; \
+    }                                                                                             \
   } while (0)
+
+extern "C" void __hwasan_init() __attribute__((weak));
+static inline bool running_with_hwasan() {
+  return &__hwasan_init != 0;
+}
+
+#define SKIP_WITH_HWASAN if (running_with_hwasan()) GTEST_SKIP()
diff --git a/include/android-base/threads.h b/include/android-base/threads.h
index dba1fc6..dbf1b47 100644
--- a/include/android-base/threads.h
+++ b/include/android-base/threads.h
@@ -24,7 +24,7 @@
 }
 }  // namespace android
 
-#if defined(__GLIBC__)
-// bionic has this Linux-specifix call, but glibc doesn't.
+#if defined(__GLIBC__) || defined(ANDROID_HOST_MUSL)
+// bionic has this Linux-specifix call, but glibc and musl don't.
 extern "C" int tgkill(int tgid, int tid, int sig);
 #endif
diff --git a/include/android-base/unique_fd.h b/include/android-base/unique_fd.h
index 9ceb5db..e929e4c 100644
--- a/include/android-base/unique_fd.h
+++ b/include/android-base/unique_fd.h
@@ -20,19 +20,25 @@
 #include <errno.h>
 #include <fcntl.h>
 
-#if !defined(_WIN32)
-#include <sys/socket.h>
-#endif
-
 #include <stdio.h>
 #include <sys/types.h>
 #include <unistd.h>
 
-// DO NOT INCLUDE OTHER LIBBASE HEADERS!
+// DO NOT INCLUDE OTHER LIBBASE HEADERS HERE!
 // This file gets used in libbinder, and libbinder is used everywhere.
 // Including other headers from libbase frequently results in inclusion of
 // android-base/macros.h, which causes macro collisions.
 
+#if defined(__BIONIC__)
+#include <android/fdsan.h>
+#endif
+#if !defined(_WIN32)
+#include <sys/socket.h>
+#endif
+
+namespace android {
+namespace base {
+
 // Container for a file descriptor that automatically closes the descriptor as
 // it goes out of scope.
 //
@@ -43,47 +49,14 @@
 //
 //      return 0; // Descriptor is closed for you.
 //
+// See also the Pipe()/Socketpair()/Fdopen()/Fdopendir() functions in this file
+// that provide interoperability with the libc functions with the same (but
+// lowercase) names.
+//
 // unique_fd is also known as ScopedFd/ScopedFD/scoped_fd; mentioned here to help
 // you find this class if you're searching for one of those names.
-
-#if defined(__BIONIC__)
-#include <android/fdsan.h>
-#endif
-
-namespace android {
-namespace base {
-
-struct DefaultCloser {
-#if defined(__BIONIC__)
-  static void Tag(int fd, void* old_addr, void* new_addr) {
-    if (android_fdsan_exchange_owner_tag) {
-      uint64_t old_tag = android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD,
-                                                        reinterpret_cast<uint64_t>(old_addr));
-      uint64_t new_tag = android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD,
-                                                        reinterpret_cast<uint64_t>(new_addr));
-      android_fdsan_exchange_owner_tag(fd, old_tag, new_tag);
-    }
-  }
-  static void Close(int fd, void* addr) {
-    if (android_fdsan_close_with_tag) {
-      uint64_t tag = android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD,
-                                                    reinterpret_cast<uint64_t>(addr));
-      android_fdsan_close_with_tag(fd, tag);
-    } else {
-      close(fd);
-    }
-  }
-#else
-  static void Close(int fd) {
-    // Even if close(2) fails with EINTR, the fd will have been closed.
-    // Using TEMP_FAILURE_RETRY will either lead to EBADF or closing someone
-    // else's fd.
-    // http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
-    ::close(fd);
-  }
-#endif
-};
-
+//
+// unique_fd itself is a specialization of unique_fd_impl with a default closer.
 template <typename Closer>
 class unique_fd_impl final {
  public:
@@ -175,11 +148,48 @@
   }
 };
 
+// The actual details of closing are factored out to support unusual cases.
+// Almost everyone will want this DefaultCloser, which handles fdsan on bionic.
+struct DefaultCloser {
+#if defined(__BIONIC__)
+  static void Tag(int fd, void* old_addr, void* new_addr) {
+    if (android_fdsan_exchange_owner_tag) {
+      uint64_t old_tag = android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD,
+                                                        reinterpret_cast<uint64_t>(old_addr));
+      uint64_t new_tag = android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD,
+                                                        reinterpret_cast<uint64_t>(new_addr));
+      android_fdsan_exchange_owner_tag(fd, old_tag, new_tag);
+    }
+  }
+  static void Close(int fd, void* addr) {
+    if (android_fdsan_close_with_tag) {
+      uint64_t tag = android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD,
+                                                    reinterpret_cast<uint64_t>(addr));
+      android_fdsan_close_with_tag(fd, tag);
+    } else {
+      close(fd);
+    }
+  }
+#else
+  static void Close(int fd) {
+    // Even if close(2) fails with EINTR, the fd will have been closed.
+    // Using TEMP_FAILURE_RETRY will either lead to EBADF or closing someone
+    // else's fd.
+    // http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
+    ::close(fd);
+  }
+#endif
+};
+
 using unique_fd = unique_fd_impl<DefaultCloser>;
 
 #if !defined(_WIN32)
 
 // Inline functions, so that they can be used header-only.
+
+// See pipe(2).
+// This helper hides the details of converting to unique_fd, and also hides the
+// fact that macOS doesn't support O_CLOEXEC or O_NONBLOCK directly.
 template <typename Closer>
 inline bool Pipe(unique_fd_impl<Closer>* read, unique_fd_impl<Closer>* write,
                  int flags = O_CLOEXEC) {
@@ -218,6 +228,8 @@
   return true;
 }
 
+// See socketpair(2).
+// This helper hides the details of converting to unique_fd.
 template <typename Closer>
 inline bool Socketpair(int domain, int type, int protocol, unique_fd_impl<Closer>* left,
                        unique_fd_impl<Closer>* right) {
@@ -230,11 +242,14 @@
   return true;
 }
 
+// See socketpair(2).
+// This helper hides the details of converting to unique_fd.
 template <typename Closer>
 inline bool Socketpair(int type, unique_fd_impl<Closer>* left, unique_fd_impl<Closer>* right) {
   return Socketpair(AF_UNIX, type, 0, left, right);
 }
 
+// See fdopen(3).
 // Using fdopen with unique_fd correctly is more annoying than it should be,
 // because fdopen doesn't close the file descriptor received upon failure.
 inline FILE* Fdopen(unique_fd&& ufd, const char* mode) {
@@ -246,6 +261,7 @@
   return file;
 }
 
+// See fdopendir(3).
 // Using fdopendir with unique_fd correctly is more annoying than it should be,
 // because fdopen doesn't close the file descriptor received upon failure.
 inline DIR* Fdopendir(unique_fd&& ufd) {
@@ -259,7 +275,20 @@
 
 #endif  // !defined(_WIN32)
 
-// A wrapper type that can be implicitly constructed from either int or unique_fd.
+// A wrapper type that can be implicitly constructed from either int or
+// unique_fd. This supports cases where you don't actually own the file
+// descriptor, and can't take ownership, but are temporarily acting as if
+// you're the owner.
+//
+// One example would be a function that needs to also allow
+// STDERR_FILENO, not just a newly-opened fd. Another example would be JNI code
+// that's using a file descriptor that's actually owned by a
+// ParcelFileDescriptor or whatever on the Java side, but where the JNI code
+// would like to enforce this weaker sense of "temporary ownership".
+//
+// If you think of unique_fd as being like std::string in that represents
+// ownership, borrowed_fd is like std::string_view (and int is like const
+// char*).
 struct borrowed_fd {
   /* implicit */ borrowed_fd(int fd) : fd_(fd) {}  // NOLINT
   template <typename T>
diff --git a/logging.cpp b/logging.cpp
index 4942e2f..e6c02ba 100644
--- a/logging.cpp
+++ b/logging.cpp
@@ -62,11 +62,9 @@
 namespace base {
 
 // BSD-based systems like Android/macOS have getprogname(). Others need us to provide one.
-#if defined(__GLIBC__) || defined(_WIN32)
+#if !defined(__APPLE__) && !defined(__BIONIC__)
 static const char* getprogname() {
-#if defined(__GLIBC__)
-  return program_invocation_short_name;
-#elif defined(_WIN32)
+#ifdef _WIN32
   static bool first = true;
   static char progname[MAX_PATH] = {};
 
@@ -77,6 +75,8 @@
   }
 
   return progname;
+#else
+  return program_invocation_short_name;
 #endif
 }
 #endif
@@ -100,7 +100,7 @@
 #if defined(__linux__)
 static int OpenKmsg() {
 #if defined(__ANDROID__)
-  // pick up 'file w /dev/kmsg' environment from daemon's init rc file
+  // pick up 'file /dev/kmsg w' environment from daemon's init rc file
   const auto val = getenv("ANDROID_FILE__dev_kmsg");
   if (val != nullptr) {
     int fd;
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 c0ac0fd..19b48c3 100644
--- a/result_test.cpp
+++ b/result_test.cpp
@@ -15,15 +15,25 @@
  */
 
 #include "android-base/result.h"
-
+#include <utils/ErrorsMacros.h>
 #include "errno.h"
 
 #include <istream>
+#include <memory>
 #include <string>
+#include <type_traits>
 
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "android-base/result-gmock.h"
+
 using namespace std::string_literals;
+using ::testing::Eq;
+using ::testing::ExplainMatchResult;
+using ::testing::HasSubstr;
+using ::testing::Not;
+using ::testing::StartsWith;
 
 namespace android {
 namespace base {
@@ -183,6 +193,49 @@
   EXPECT_EQ(error_text + ": " + strerror(test_errno), result2.error().message());
 }
 
+enum class CustomError { A, B };
+
+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<CustomErrorWrapper>(CustomError::e)
+
+TEST(result, result_with_custom_errorcode) {
+  Result<void, CustomError> ok = {};
+  EXPECT_RESULT_OK(ok);
+  ok.value();  // should not crash
+  EXPECT_DEATH(ok.error(), "");
+
+  auto error_text = "test error"s;
+  Result<void, CustomError> err = NewCustomError(A) << error_text;
+
+  EXPECT_FALSE(err.ok());
+  EXPECT_FALSE(err.has_value());
+
+  EXPECT_EQ(CustomError::A, err.error().code());
+  EXPECT_EQ(error_text + ": A", err.error().message());
+}
+
+Result<std::string, CustomError> success_or_fail(bool success) {
+  if (success)
+    return "success";
+  else
+    return NewCustomError(A) << "fail";
+}
+
 TEST(result, constructor_forwarding) {
   auto result = Result<std::string>(std::in_place, 5, 'a');
 
@@ -192,6 +245,249 @@
   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");
+}
+
+TEST(result, unwrap_ambiguous_int) {
+  const std::string firstSuccess{"a"};
+  constexpr int secondSuccess = 5;
+  auto enum_success_or_fail = [&](bool success) -> Result<std::string, StatusT> {
+    if (success) return firstSuccess;
+    return ResultError<StatusT>("Fail", 10);
+  };
+  auto f = [&](bool success) -> Result<int, StatusT> {
+    auto val = OR_RETURN(enum_success_or_fail(success));
+    EXPECT_EQ(firstSuccess, val);
+    return secondSuccess;
+  };
+
+  auto r = f(true);
+  ASSERT_TRUE(r.ok());
+  EXPECT_EQ(r.value(), secondSuccess);
+  auto s = f(false);
+  ASSERT_TRUE(!s.ok());
+  EXPECT_EQ(s.error().code(), 10);
+}
+
+TEST(result, unwrap_ambiguous_uint_conv) {
+  const std::string firstSuccess{"a"};
+  constexpr size_t secondSuccess = 5ull;
+  auto enum_success_or_fail = [&](bool success) -> Result<std::string, StatusT> {
+    if (success) return firstSuccess;
+    return ResultError<StatusT>("Fail", 10);
+  };
+
+  auto f = [&](bool success) -> Result<size_t, StatusT> {
+    auto val = OR_RETURN(enum_success_or_fail(success));
+    EXPECT_EQ(firstSuccess, val);
+    return secondSuccess;
+  };
+
+  auto r = f(true);
+  ASSERT_TRUE(r.ok());
+  EXPECT_EQ(r.value(), secondSuccess);
+  auto s = f(false);
+  ASSERT_TRUE(!s.ok());
+  EXPECT_EQ(s.error().code(), 10);
+}
+
+struct IntConst {
+    int val_;
+    template <typename T, typename = std::enable_if_t<std::is_convertible_v<T, int>>>
+    IntConst(T&& val) : val_(val) {}
+    operator status_t() {return val_;}
+};
+
+TEST(result, unwrap_ambiguous_constructible) {
+  constexpr int firstSuccess = 5;
+  constexpr int secondSuccess = 7;
+  struct A {
+    A (int val) : val_(val) {}
+    operator status_t() { return 0; }
+    int val_;
+  };
+  // If this returns Result<A, ...> instead of Result<IntConst, ...>,
+  // compilation fails unless we compile with c++20
+  auto enum_success_or_fail = [&](bool success) -> Result<IntConst, StatusT, false> {
+    if (success) return firstSuccess;
+    return ResultError<StatusT, false>(10);
+  };
+  auto f = [&](bool success) -> Result<IntConst, StatusT, false> {
+    auto val = OR_RETURN(enum_success_or_fail(success));
+    EXPECT_EQ(firstSuccess, val.val_);
+    return secondSuccess;
+  };
+  auto r = f(true);
+  EXPECT_EQ(r.value().val_, secondSuccess);
+  auto s = f(false);
+  EXPECT_EQ(s.error().code(), 10);
+}
+
+struct Dangerous {};
+struct ImplicitFromDangerous {
+  ImplicitFromDangerous(Dangerous);
+};
+template <typename U>
+struct Templated {
+    U val_;
+    template <typename T, typename=std::enable_if_t<std::is_convertible_v<T, U>>>
+    Templated(T val) : val_(val) {}
+};
+
+
+TEST(result, dangerous_result_conversion) {
+  ResultError<Dangerous, false> error {Dangerous{}};
+  Result<Templated<Dangerous>, Dangerous, false> surprise {error};
+  EXPECT_TRUE(!surprise.ok());
+  Result<Templated<ImplicitFromDangerous>, Dangerous, false> surprise2 {error};
+  EXPECT_TRUE(!surprise2.ok());
+}
+
+TEST(result, generic_convertible) {
+  const std::string firstSuccess{"a"};
+  struct A {};
+  struct B {
+    operator A() {return A{};}
+  };
+
+  auto enum_success_or_fail = [&](bool success) -> Result<std::string, B> {
+    if (success) return firstSuccess;
+    return ResultError<B>("Fail", B{});
+  };
+  auto f = [&](bool success) -> Result<A, B> {
+    auto val = OR_RETURN(enum_success_or_fail(success));
+    EXPECT_EQ(firstSuccess, val);
+    return A{};
+  };
+
+  auto r = f(true);
+  EXPECT_TRUE(r.ok());
+  auto s = f(false);
+  EXPECT_TRUE(!s.ok());
+}
+
+TEST(result, generic_exact) {
+  const std::string firstSuccess{"a"};
+  struct A {};
+  auto enum_success_or_fail = [&](bool success) -> Result<std::string, A> {
+    if (success) return firstSuccess;
+    return ResultError<A>("Fail", A{});
+  };
+  auto f = [&](bool success) -> Result<A, A> {
+    auto val = OR_RETURN(enum_success_or_fail(success));
+    EXPECT_EQ(firstSuccess, val);
+    return A{};
+  };
+
+  auto r = f(true);
+  EXPECT_TRUE(r.ok());
+  auto s = f(false);
+  EXPECT_TRUE(!s.ok());
+}
+
+struct MyData {
+  const int data;
+  static int copy_constructed;
+  static int move_constructed;
+  explicit MyData(int d) : data(d) {}
+  MyData(const MyData& other) : data(other.data) { copy_constructed++; }
+  MyData(MyData&& other) : data(other.data) { move_constructed++; }
+  MyData& operator=(const MyData&) = delete;
+  MyData& operator=(MyData&&) = delete;
+};
+
+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 {};
+  }();
+}
+
+TEST(result, supports_move_only_type) {
+  auto f = [](bool success) -> Result<std::unique_ptr<std::string>> {
+    if (success) return std::make_unique<std::string>("hello");
+    return Error() << "error";
+  };
+
+  auto g = [&](bool success) -> Result<std::unique_ptr<std::string>> {
+    auto r = OR_RETURN(f(success));
+    EXPECT_EQ("hello", *(r.get()));
+    return std::make_unique<std::string>("world");
+  };
+
+  auto s = g(true);
+  EXPECT_RESULT_OK(s);
+  EXPECT_EQ("world", *(s->get()));
+
+  auto t = g(false);
+  EXPECT_FALSE(t.ok());
+  EXPECT_EQ("error", t.error().message());
+}
+
+TEST(result, unique_ptr) {
+  using testing::Ok;
+
+  auto return_unique_ptr = [](bool success) -> Result<std::unique_ptr<int>> {
+    auto result = OR_RETURN(Result<std::unique_ptr<int>>(std::make_unique<int>(3)));
+    if (!success) {
+      return Error() << __func__ << " failed.";
+    }
+    return result;
+  };
+  Result<std::unique_ptr<int>> result1 = return_unique_ptr(false);
+  ASSERT_THAT(result1, Not(Ok()));
+  Result<std::unique_ptr<int>> result2 = return_unique_ptr(true);
+  ASSERT_THAT(result2, Ok());
+  EXPECT_EQ(**result2, 3);
+}
+
 struct ConstructorTracker {
   static size_t constructor_called;
   static size_t copy_constructor_called;
@@ -418,5 +714,107 @@
             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 {
+ public:
+  Listener() : MatchResultListener(&ss_) {}
+  ~Listener() = default;
+  std::string message() const { return ss_.str(); }
+
+ private:
+  std::stringstream ss_;
+};
+
+class ResultMatchers : public ::testing::Test {
+ public:
+  Result<int> result = 1;
+  Result<int> error = Error(EBADF) << "error message";
+  Listener listener;
+};
+
+TEST_F(ResultMatchers, ok_result) {
+  EXPECT_TRUE(ExplainMatchResult(Ok(), result, &listener));
+  EXPECT_THAT(listener.message(), Eq("result is OK"));
+}
+
+TEST_F(ResultMatchers, ok_error) {
+  EXPECT_FALSE(ExplainMatchResult(Ok(), error, &listener));
+  EXPECT_THAT(listener.message(), StartsWith("error is"));
+  EXPECT_THAT(listener.message(), HasSubstr(error.error().message()));
+  EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code())));
+}
+
+TEST_F(ResultMatchers, not_ok_result) {
+  EXPECT_FALSE(ExplainMatchResult(Not(Ok()), result, &listener));
+  EXPECT_THAT(listener.message(), Eq("result is OK"));
+}
+
+TEST_F(ResultMatchers, not_ok_error) {
+  EXPECT_TRUE(ExplainMatchResult(Not(Ok()), error, &listener));
+  EXPECT_THAT(listener.message(), StartsWith("error is"));
+  EXPECT_THAT(listener.message(), HasSubstr(error.error().message()));
+  EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code())));
+}
+
+TEST_F(ResultMatchers, has_value_result) {
+  EXPECT_TRUE(ExplainMatchResult(HasValue(*result), result, &listener));
+}
+
+TEST_F(ResultMatchers, has_value_wrong_result) {
+  EXPECT_FALSE(ExplainMatchResult(HasValue(*result + 1), result, &listener));
+}
+
+TEST_F(ResultMatchers, has_value_error) {
+  EXPECT_FALSE(ExplainMatchResult(HasValue(*result), error, &listener));
+  EXPECT_THAT(listener.message(), StartsWith("error is"));
+  EXPECT_THAT(listener.message(), HasSubstr(error.error().message()));
+  EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code())));
+}
+
+TEST_F(ResultMatchers, has_error_code_result) {
+  EXPECT_FALSE(ExplainMatchResult(HasError(WithCode(error.error().code())), result, &listener));
+  EXPECT_THAT(listener.message(), Eq("result is OK"));
+}
+
+TEST_F(ResultMatchers, has_error_code_wrong_code) {
+  EXPECT_FALSE(ExplainMatchResult(HasError(WithCode(error.error().code() + 1)), error, &listener));
+  EXPECT_THAT(listener.message(), StartsWith("actual error is"));
+  EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code())));
+}
+
+TEST_F(ResultMatchers, has_error_code_correct_code) {
+  EXPECT_TRUE(ExplainMatchResult(HasError(WithCode(error.error().code())), error, &listener));
+  EXPECT_THAT(listener.message(), StartsWith("actual error is"));
+  EXPECT_THAT(listener.message(), HasSubstr(strerror(error.error().code())));
+}
+
+TEST_F(ResultMatchers, has_error_message_result) {
+  EXPECT_FALSE(
+      ExplainMatchResult(HasError(WithMessage(error.error().message())), result, &listener));
+  EXPECT_THAT(listener.message(), Eq("result is OK"));
+}
+
+TEST_F(ResultMatchers, has_error_message_wrong_message) {
+  EXPECT_FALSE(ExplainMatchResult(HasError(WithMessage("foo")), error, &listener));
+  EXPECT_THAT(listener.message(), StartsWith("actual error is"));
+  EXPECT_THAT(listener.message(), HasSubstr(error.error().message()));
+}
+
+TEST_F(ResultMatchers, has_error_message_correct_message) {
+  EXPECT_TRUE(ExplainMatchResult(HasError(WithMessage(error.error().message())), error, &listener));
+  EXPECT_THAT(listener.message(), StartsWith("actual error is"));
+  EXPECT_THAT(listener.message(), HasSubstr(error.error().message()));
+}
+
+}  // namespace testing
 }  // namespace base
 }  // namespace android
diff --git a/result_test_constraint.cpp b/result_test_constraint.cpp
new file mode 100644
index 0000000..253a276
--- /dev/null
+++ b/result_test_constraint.cpp
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+// Since result has c++20 conditional behavior, we compile with std=c++20 to
+// ensure functionality in both cases. Instead of duplicating the file, we will
+// include, since this test is not linked against anything.
+// This test can be removed when we move to c++20.
+#include "result_test.cpp"
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));
+}
diff --git a/test_utils_test.cpp b/test_utils_test.cpp
index d08d5d6..10e8a2a 100644
--- a/test_utils_test.cpp
+++ b/test_utils_test.cpp
@@ -27,21 +27,33 @@
 TEST(TestUtilsTest, AssertMatch) {
   ASSERT_MATCH("foobar", R"(fo+baz?r)");
   EXPECT_FATAL_FAILURE(ASSERT_MATCH("foobar", R"(foobaz)"), "regex mismatch");
+
+  ASSERT_MATCH(L"foobar", LR"(fo+baz?r)");
+  EXPECT_FATAL_FAILURE(ASSERT_MATCH(L"foobar", LR"(foobaz)"), "regex mismatch");
 }
 
 TEST(TestUtilsTest, AssertNotMatch) {
   ASSERT_NOT_MATCH("foobar", R"(foobaz)");
   EXPECT_FATAL_FAILURE(ASSERT_NOT_MATCH("foobar", R"(foobar)"), "regex mismatch");
+
+  ASSERT_NOT_MATCH(L"foobar", LR"(foobaz)");
+  EXPECT_FATAL_FAILURE(ASSERT_NOT_MATCH(L"foobar", LR"(foobar)"), "regex mismatch");
 }
 
 TEST(TestUtilsTest, ExpectMatch) {
   EXPECT_MATCH("foobar", R"(fo+baz?r)");
   EXPECT_NONFATAL_FAILURE(EXPECT_MATCH("foobar", R"(foobaz)"), "regex mismatch");
+
+  EXPECT_MATCH(L"foobar", LR"(fo+baz?r)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_MATCH(L"foobar", LR"(foobaz)"), "regex mismatch");
 }
 
 TEST(TestUtilsTest, ExpectNotMatch) {
   EXPECT_NOT_MATCH("foobar", R"(foobaz)");
   EXPECT_NONFATAL_FAILURE(EXPECT_NOT_MATCH("foobar", R"(foobar)"), "regex mismatch");
+
+  EXPECT_NOT_MATCH(L"foobar", LR"(foobaz)");
+  EXPECT_NONFATAL_FAILURE(EXPECT_NOT_MATCH(L"foobar", LR"(foobar)"), "regex mismatch");
 }
 
 TEST(TestUtilsTest, CaptureStdout_smoke) {
diff --git a/threads.cpp b/threads.cpp
index 48f6197..6d7d7c6 100644
--- a/threads.cpp
+++ b/threads.cpp
@@ -47,7 +47,7 @@
 }  // namespace base
 }  // namespace android
 
-#if defined(__GLIBC__)
+#if defined(__GLIBC__) || defined(ANDROID_HOST_MUSL)
 int tgkill(int tgid, int tid, int sig) {
   return syscall(__NR_tgkill, tgid, tid, sig);
 }