diff options
author | TreeHugger Robot <treehugger-gerrit@google.com> | 2019-10-19 04:06:37 +0000 |
---|---|---|
committer | Android (Google) Code Review <android-gerrit@google.com> | 2019-10-19 04:06:37 +0000 |
commit | 223ebb0e595947c080fa183b3ce9a77437e8c94b (patch) | |
tree | 578f87f3f9da2ff482e926093701487099baace5 | |
parent | db06750cdc754e2fffd866c439f436e4e7631ba9 (diff) | |
parent | a41be6abbe852291bdd71a2b29f040dc18a271bf (diff) | |
download | native-223ebb0e595947c080fa183b3ce9a77437e8c94b.tar.gz |
Merge "SF: Scheduler add strong typing helpers."
-rw-r--r-- | services/surfaceflinger/Scheduler/StrongTyping.h | 67 | ||||
-rw-r--r-- | services/surfaceflinger/tests/unittests/Android.bp | 1 | ||||
-rw-r--r-- | services/surfaceflinger/tests/unittests/StrongTypingTest.cpp | 73 |
3 files changed, 141 insertions, 0 deletions
diff --git a/services/surfaceflinger/Scheduler/StrongTyping.h b/services/surfaceflinger/Scheduler/StrongTyping.h new file mode 100644 index 0000000000..02db022e08 --- /dev/null +++ b/services/surfaceflinger/Scheduler/StrongTyping.h @@ -0,0 +1,67 @@ +/* + * Copyright 2019 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 +namespace android { + +template <typename T, template <typename> class AbilityType> +struct Ability { + T& base() { return static_cast<T&>(*this); } + T const& base() const { return static_cast<T const&>(*this); } +}; + +template <typename T> +struct Add : Ability<T, Add> { + inline T operator+(T const& other) const { return T(this->base().value() + other.value()); } + inline T& operator++() { + ++this->base().value(); + return this->base(); + }; + inline T operator++(int) { + T tmp(this->base()); + operator++(); + return tmp; + }; + inline T& operator+=(T const& other) { + this->base().value() += other.value(); + return this->base(); + }; +}; + +template <typename T> +struct Compare : Ability<T, Compare> { + inline bool operator==(T const& other) const { return this->base().value() == other.value(); }; + inline bool operator<(T const& other) const { return this->base().value() < other.value(); } + inline bool operator<=(T const& other) const { return (*this < other) || (*this == other); } + inline bool operator!=(T const& other) const { return !(*this == other); } + inline bool operator>=(T const& other) const { return !(*this < other); } + inline bool operator>(T const& other) const { return !(*this < other || *this == other); } +}; + +template <typename T, typename W, template <typename> class... Ability> +struct StrongTyping : Ability<StrongTyping<T, W, Ability...>>... { + StrongTyping() : mValue(0) {} + explicit StrongTyping(T const& value) : mValue(value) {} + StrongTyping(StrongTyping const&) = default; + StrongTyping& operator=(StrongTyping const&) = default; + inline operator T() const { return mValue; } + T const& value() const { return mValue; } + T& value() { return mValue; } + +private: + T mValue; +}; +} // namespace android diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp index 2183d34866..f85da205c0 100644 --- a/services/surfaceflinger/tests/unittests/Android.bp +++ b/services/surfaceflinger/tests/unittests/Android.bp @@ -53,6 +53,7 @@ cc_test { "TimeStatsTest.cpp", "FrameTracerTest.cpp", "TransactionApplicationTest.cpp", + "StrongTypingTest.cpp", "mock/DisplayHardware/MockComposer.cpp", "mock/DisplayHardware/MockDisplay.cpp", "mock/DisplayHardware/MockPowerAdvisor.cpp", diff --git a/services/surfaceflinger/tests/unittests/StrongTypingTest.cpp b/services/surfaceflinger/tests/unittests/StrongTypingTest.cpp new file mode 100644 index 0000000000..b9ddcd77d0 --- /dev/null +++ b/services/surfaceflinger/tests/unittests/StrongTypingTest.cpp @@ -0,0 +1,73 @@ +/* + * Copyright 2019 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 <gmock/gmock.h> +#include <gtest/gtest.h> +#include "Scheduler/StrongTyping.h" + +using namespace testing; + +namespace android { + +TEST(StrongTypeTest, comparison) { + using SpunkyType = StrongTyping<int, struct SpunkyTypeTag, Compare>; + SpunkyType f2(22); + SpunkyType f1(10); + + EXPECT_TRUE(f1 == f1); + EXPECT_TRUE(SpunkyType(10) != SpunkyType(11)); + EXPECT_FALSE(SpunkyType(31) != SpunkyType(31)); + + EXPECT_TRUE(SpunkyType(10) < SpunkyType(11)); + EXPECT_TRUE(SpunkyType(-1) < SpunkyType(0)); + EXPECT_FALSE(SpunkyType(-10) < SpunkyType(-20)); + + EXPECT_TRUE(SpunkyType(10) <= SpunkyType(11)); + EXPECT_TRUE(SpunkyType(10) <= SpunkyType(10)); + EXPECT_TRUE(SpunkyType(-10) <= SpunkyType(1)); + EXPECT_FALSE(SpunkyType(10) <= SpunkyType(9)); + + EXPECT_TRUE(SpunkyType(11) >= SpunkyType(11)); + EXPECT_TRUE(SpunkyType(12) >= SpunkyType(11)); + EXPECT_FALSE(SpunkyType(11) >= SpunkyType(12)); + + EXPECT_FALSE(SpunkyType(11) > SpunkyType(12)); + EXPECT_TRUE(SpunkyType(-11) < SpunkyType(7)); +} + +TEST(StrongTypeTest, addition) { + using FunkyType = StrongTyping<int, struct FunkyTypeTag, Compare, Add>; + FunkyType f2(22); + FunkyType f1(10); + + EXPECT_THAT(f1 + f2, Eq(FunkyType(32))); + EXPECT_THAT(f2 + f1, Eq(FunkyType(32))); + + EXPECT_THAT(++f1, Eq(11)); + EXPECT_THAT(f1, Eq(11)); + EXPECT_THAT(f1++, Eq(11)); + EXPECT_THAT(f1++, Eq(12)); + EXPECT_THAT(f1, Eq(13)); + + auto f3 = f1; + EXPECT_THAT(f1, Eq(f3)); + EXPECT_THAT(f1, Lt(f2)); + + f3 += f1; + EXPECT_THAT(f1, Eq(13)); + EXPECT_THAT(f3, Eq(26)); +} +} // namespace android |