Merge "Add new MotionEvent orientation flags to rust" into main
diff --git a/include/ftl/expected.h b/include/ftl/expected.h
index 57448dc..7e765c5 100644
--- a/include/ftl/expected.h
+++ b/include/ftl/expected.h
@@ -69,6 +69,36 @@
exp_.value(); \
})
+// Given an expression `expr` that evaluates to an ftl::Expected<T, E> result (R for short),
+// FTL_EXPECT unwraps T out of R, or bails out of the enclosing function F if R has an error E.
+// While FTL_TRY bails out with R, FTL_EXPECT bails out with E, which is useful when F does not
+// need to propagate R because T is not relevant to the caller.
+//
+// Example usage:
+//
+// using StringExp = ftl::Expected<std::string, std::errc>;
+//
+// std::errc repeat(StringExp exp, std::string& out) {
+// const std::string str = FTL_EXPECT(exp);
+// out = str + str;
+// return std::errc::operation_in_progress;
+// }
+//
+// std::string str;
+// assert(std::errc::operation_in_progress == repeat(StringExp("ha"s), str));
+// assert("haha"s == str);
+// assert(std::errc::bad_message == repeat(ftl::Unexpected(std::errc::bad_message), str));
+// assert("haha"s == str);
+//
+#define FTL_EXPECT(expr) \
+ ({ \
+ auto exp_ = (expr); \
+ if (!exp_.has_value()) { \
+ return std::move(exp_.error()); \
+ } \
+ exp_.value(); \
+ })
+
namespace android::ftl {
// Superset of base::expected<T, E> with monadic operations.
diff --git a/include/ftl/function.h b/include/ftl/function.h
index 3538ca4..bda5b75 100644
--- a/include/ftl/function.h
+++ b/include/ftl/function.h
@@ -123,7 +123,7 @@
// // Create a typedef to give a more meaningful name and bound the size.
// using MyFunction = ftl::Function<int(std::string_view), 2>;
// int* ptr = nullptr;
-// auto f1 = MyFunction::make_function(
+// auto f1 = MyFunction::make(
// [cls = &cls, ptr](std::string_view sv) {
// return cls->on_string(ptr, sv);
// });
diff --git a/libs/binder/tests/binderRpcWireProtocolTest.cpp b/libs/binder/tests/binderRpcWireProtocolTest.cpp
index e59dc82..91145f0 100644
--- a/libs/binder/tests/binderRpcWireProtocolTest.cpp
+++ b/libs/binder/tests/binderRpcWireProtocolTest.cpp
@@ -14,14 +14,15 @@
* limitations under the License.
*/
-#include <android-base/logging.h>
-#include <android-base/properties.h>
-#include <android-base/strings.h>
#include <binder/Parcel.h>
#include <binder/RpcSession.h>
#include <binder/Status.h>
#include <gtest/gtest.h>
+#ifdef __ANDROID__
+#include <android-base/properties.h>
+#endif
+
#include "../Debug.h"
#include "../Utils.h"
@@ -69,8 +70,8 @@
[](Parcel* p) { ASSERT_EQ(OK, p->writeString16(String16(u"a"))); },
[](Parcel* p) { ASSERT_EQ(OK, p->writeString16(String16(u"baba"))); },
[](Parcel* p) { ASSERT_EQ(OK, p->writeStrongBinder(nullptr)); },
- [](Parcel* p) { ASSERT_EQ(OK, p->writeInt32Array(arraysize(kInt32Array), kInt32Array)); },
- [](Parcel* p) { ASSERT_EQ(OK, p->writeByteArray(arraysize(kByteArray), kByteArray)); },
+ [](Parcel* p) { ASSERT_EQ(OK, p->writeInt32Array(countof(kInt32Array), kInt32Array)); },
+ [](Parcel* p) { ASSERT_EQ(OK, p->writeByteArray(countof(kByteArray), kByteArray)); },
[](Parcel* p) { ASSERT_EQ(OK, p->writeBool(true)); },
[](Parcel* p) { ASSERT_EQ(OK, p->writeBool(false)); },
[](Parcel* p) { ASSERT_EQ(OK, p->writeChar('a')); },
@@ -162,8 +163,8 @@
static void setParcelForRpc(Parcel* p, uint32_t version) {
auto session = RpcSession::make();
- CHECK(session->setProtocolVersion(version));
- CHECK_EQ(OK, session->addNullDebuggingClient());
+ EXPECT_TRUE(session->setProtocolVersion(version));
+ EXPECT_EQ(OK, session->addNullDebuggingClient());
p->markForRpc(session);
}
@@ -180,13 +181,25 @@
return result;
}
+// To be replaced with std::views::split (and std::views::zip) once C++ compilers catch up.
+static std::vector<std::string> split(std::string_view s, char delimiter) {
+ std::vector<std::string> result;
+ size_t pos = 0;
+ while (true) {
+ const auto found = s.find(delimiter, pos);
+ result.emplace_back(s.substr(pos, found - pos));
+ if (found == s.npos) return result;
+ pos = found + 1;
+ }
+}
+
static void checkRepr(const std::string& repr, uint32_t version) {
const std::string actualRepr = buildRepr(version);
- auto expected = base::Split(repr, "|");
+ auto expected = split(repr, '|');
ASSERT_EQ(expected.size(), kFillFuns.size());
- auto actual = base::Split(actualRepr, "|");
+ auto actual = split(actualRepr, '|');
ASSERT_EQ(actual.size(), kFillFuns.size());
for (size_t i = 0; i < kFillFuns.size(); i++) {
@@ -257,8 +270,13 @@
TEST(RpcWire, ReleaseBranchHasFrozenRpcWireProtocol) {
if (RPC_WIRE_PROTOCOL_VERSION == RPC_WIRE_PROTOCOL_VERSION_EXPERIMENTAL) {
- EXPECT_FALSE(base::GetProperty("ro.build.version.codename", "") == "REL")
- << "Binder RPC wire protocol must be frozen on a release branch!";
+#ifdef __ANDROID__
+ bool isRelease = base::GetProperty("ro.build.version.codename", "") == "REL";
+#else
+ bool isRelease = true;
+#endif
+ EXPECT_FALSE(isRelease)
+ << "Binder RPC wire protocol must be frozen in release configuration!";
}
}
diff --git a/libs/ftl/expected_test.cpp b/libs/ftl/expected_test.cpp
index 9b7f017..d5b1d7e 100644
--- a/libs/ftl/expected_test.cpp
+++ b/libs/ftl/expected_test.cpp
@@ -79,16 +79,28 @@
namespace {
-IntExp increment(IntExp exp) {
+IntExp increment_try(IntExp exp) {
const int i = FTL_TRY(exp);
return IntExp(i + 1);
}
-StringExp repeat(StringExp exp) {
+std::errc increment_expect(IntExp exp, int& out) {
+ const int i = FTL_EXPECT(exp);
+ out = i + 1;
+ return std::errc::operation_in_progress;
+}
+
+StringExp repeat_try(StringExp exp) {
const std::string str = FTL_TRY(exp);
return StringExp(str + str);
}
+std::errc repeat_expect(StringExp exp, std::string& out) {
+ const std::string str = FTL_EXPECT(exp);
+ out = str + str;
+ return std::errc::operation_in_progress;
+}
+
void uppercase(char& c, ftl::Optional<char> opt) {
c = std::toupper(FTL_TRY(std::move(opt).ok_or(ftl::Unit())));
}
@@ -97,13 +109,13 @@
// Keep in sync with example usage in header file.
TEST(Expected, Try) {
- EXPECT_EQ(IntExp(100), increment(IntExp(99)));
- EXPECT_TRUE(repeat(ftl::Unexpected(std::errc::value_too_large)).has_error([](std::errc e) {
+ EXPECT_EQ(IntExp(100), increment_try(IntExp(99)));
+ EXPECT_TRUE(increment_try(ftl::Unexpected(std::errc::value_too_large)).has_error([](std::errc e) {
return e == std::errc::value_too_large;
}));
- EXPECT_EQ(StringExp("haha"s), repeat(StringExp("ha"s)));
- EXPECT_TRUE(repeat(ftl::Unexpected(std::errc::bad_message)).has_error([](std::errc e) {
+ EXPECT_EQ(StringExp("haha"s), repeat_try(StringExp("ha"s)));
+ EXPECT_TRUE(repeat_try(ftl::Unexpected(std::errc::bad_message)).has_error([](std::errc e) {
return e == std::errc::bad_message;
}));
@@ -115,4 +127,19 @@
EXPECT_EQ(c, 'A');
}
+TEST(Expected, Expect) {
+ int i = 0;
+ EXPECT_EQ(std::errc::operation_in_progress, increment_expect(IntExp(99), i));
+ EXPECT_EQ(100, i);
+ EXPECT_EQ(std::errc::value_too_large,
+ increment_expect(ftl::Unexpected(std::errc::value_too_large), i));
+ EXPECT_EQ(100, i);
+
+ std::string str;
+ EXPECT_EQ(std::errc::operation_in_progress, repeat_expect(StringExp("ha"s), str));
+ EXPECT_EQ("haha"s, str);
+ EXPECT_EQ(std::errc::bad_message, repeat_expect(ftl::Unexpected(std::errc::bad_message), str));
+ EXPECT_EQ("haha"s, str);
+}
+
} // namespace android::test