| // Copyright 2022 The Dawn Authors |
| // |
| // 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 <string> |
| |
| #include "dawn/native/CacheKey.h" |
| |
| namespace dawn::native { |
| |
| // Testing classes/structs with serializing implemented for testing. |
| struct A {}; |
| template <> |
| void CacheKeySerializer<A>::Serialize(CacheKey* key, const A& t) { |
| std::string str = "structA"; |
| key->insert(key->end(), str.begin(), str.end()); |
| } |
| |
| class B {}; |
| template <> |
| void CacheKeySerializer<B>::Serialize(CacheKey* key, const B& t) { |
| std::string str = "classB"; |
| key->insert(key->end(), str.begin(), str.end()); |
| } |
| |
| namespace { |
| |
| // Matcher to compare CacheKey to a string for easier testing. |
| MATCHER_P(CacheKeyEq, |
| key, |
| "cache key " + std::string(negation ? "not" : "") + "equal to " + key) { |
| return std::string(arg.begin(), arg.end()) == key; |
| } |
| |
| TEST(CacheKeyTest, IntegralTypes) { |
| EXPECT_THAT(GetCacheKey((int)-1), CacheKeyEq("{0:-1}")); |
| EXPECT_THAT(GetCacheKey((uint8_t)2), CacheKeyEq("{0:2}")); |
| EXPECT_THAT(GetCacheKey((uint16_t)4), CacheKeyEq("{0:4}")); |
| EXPECT_THAT(GetCacheKey((uint32_t)8), CacheKeyEq("{0:8}")); |
| EXPECT_THAT(GetCacheKey((uint64_t)16), CacheKeyEq("{0:16}")); |
| |
| EXPECT_THAT(GetCacheKey((int)-1, (uint8_t)2, (uint16_t)4, (uint32_t)8, (uint64_t)16), |
| CacheKeyEq("{0:-1,1:2,2:4,3:8,4:16}")); |
| } |
| |
| TEST(CacheKeyTest, FloatingTypes) { |
| EXPECT_THAT(GetCacheKey((float)0.5), CacheKeyEq("{0:0.500000}")); |
| EXPECT_THAT(GetCacheKey((double)32.0), CacheKeyEq("{0:32.000000}")); |
| |
| EXPECT_THAT(GetCacheKey((float)0.5, (double)32.0), |
| CacheKeyEq("{0:0.500000,1:32.000000}")); |
| } |
| |
| TEST(CacheKeyTest, Strings) { |
| std::string str0 = "string0"; |
| std::string str1 = "string1"; |
| |
| EXPECT_THAT(GetCacheKey("string0"), CacheKeyEq(R"({0:7"string0"})")); |
| EXPECT_THAT(GetCacheKey(str0), CacheKeyEq(R"({0:7"string0"})")); |
| EXPECT_THAT(GetCacheKey("string0", str1), CacheKeyEq(R"({0:7"string0",1:7"string1"})")); |
| } |
| |
| TEST(CacheKeyTest, NestedCacheKey) { |
| EXPECT_THAT(GetCacheKey(GetCacheKey((int)-1)), CacheKeyEq("{0:{0:-1}}")); |
| EXPECT_THAT(GetCacheKey(GetCacheKey("string")), CacheKeyEq(R"({0:{0:6"string"}})")); |
| EXPECT_THAT(GetCacheKey(GetCacheKey(A{})), CacheKeyEq("{0:{0:structA}}")); |
| EXPECT_THAT(GetCacheKey(GetCacheKey(B())), CacheKeyEq("{0:{0:classB}}")); |
| |
| EXPECT_THAT(GetCacheKey(GetCacheKey((int)-1), GetCacheKey("string"), GetCacheKey(A{}), |
| GetCacheKey(B())), |
| CacheKeyEq(R"({0:{0:-1},1:{0:6"string"},2:{0:structA},3:{0:classB}})")); |
| } |
| |
| } // namespace |
| |
| } // namespace dawn::native |