mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-06-16 19:43:31 +00:00
4d1d143977
* Added a class template argument deduction guide (CTAD) to infer the
`T` and `N` template arguments. This lets you write `Vector{1,2,3}`
instead of `Vector<int, 3>{1,2,3}`. This is important as a mismatch
between the number of constructor arguments and the `N` template
argument can cause silent heap allocations, which we're trying to
avoid. The `T` deduction uses the same smarts as the return-type
deduction of `Switch()`, so:
* `Vector{1, 2.0}` would construct a `Vector<double, 2>`
* `Vector{i32, u32}` would construct a `Vector<const sem::Type*, 2>`
* Removed the Vector(size_t) and Vector(size_t, const T&) constructors.
This is a move away from the std::vector style API, but these are
rarely more efficient than calling Reserve() and Push(), as you remove
the redundant initialization. The main reason for doing this is to
remove ambiguity between `Vector{1}` and `Vector(1)`.
* Added support for covariance conversion
(`Vector<Derived*, N>` -> `Vector<Base*, N>`).
Only supports pointers to `Castable`, as this can only safely work
with single-inheritance.
* Added support for conversion of `Vector<T*, N>` -> `Vector<const T*, N>`.
This will remove pointless vector copies from the sem package.
Bug: tint:1613
Change-Id: I79b9f82d623f90afa14f8ba1613ee49cccceafeb
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/97020
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
Commit-Queue: Ben Clayton <bclayton@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
89 lines
3.1 KiB
C++
89 lines
3.1 KiB
C++
// Copyright 2021 The Tint 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 "src/tint/utils/hash.h"
|
|
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <unordered_map>
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "src/tint/utils/vector.h"
|
|
|
|
namespace tint::utils {
|
|
namespace {
|
|
|
|
TEST(HashTests, Basic) {
|
|
EXPECT_EQ(Hash(123), Hash(123));
|
|
EXPECT_NE(Hash(123), Hash(321));
|
|
EXPECT_EQ(Hash(123, 456), Hash(123, 456));
|
|
EXPECT_NE(Hash(123, 456), Hash(456, 123));
|
|
EXPECT_NE(Hash(123, 456), Hash(123));
|
|
EXPECT_EQ(Hash(123, 456, false), Hash(123, 456, false));
|
|
EXPECT_NE(Hash(123, 456, false), Hash(123, 456));
|
|
EXPECT_EQ(Hash(std::string("hello")), Hash(std::string("hello")));
|
|
EXPECT_NE(Hash(std::string("hello")), Hash(std::string("world")));
|
|
}
|
|
|
|
TEST(HashTests, StdVector) {
|
|
EXPECT_EQ(Hash(std::vector<int>({})), Hash(std::vector<int>({})));
|
|
EXPECT_EQ(Hash(std::vector<int>({1, 2, 3})), Hash(std::vector<int>({1, 2, 3})));
|
|
EXPECT_NE(Hash(std::vector<int>({1, 2, 3})), Hash(std::vector<int>({1, 2, 4})));
|
|
EXPECT_NE(Hash(std::vector<int>({1, 2, 3})), Hash(std::vector<int>({1, 2, 3, 4})));
|
|
}
|
|
|
|
TEST(HashTests, TintVector) {
|
|
EXPECT_EQ(Hash(Vector<int, 0>({})), Hash(Vector<int, 0>({})));
|
|
EXPECT_EQ(Hash(Vector<int, 0>({1, 2, 3})), Hash(Vector<int, 0>({1, 2, 3})));
|
|
EXPECT_NE(Hash(Vector<int, 0>({1, 2, 3})), Hash(Vector<int, 0>({1, 2, 4})));
|
|
EXPECT_NE(Hash(Vector<int, 0>({1, 2, 3})), Hash(Vector<int, 0>({1, 2, 3, 4})));
|
|
EXPECT_EQ(Hash(Vector<int, 3>({1, 2, 3})), Hash(Vector<int, 4>({1, 2, 3})));
|
|
EXPECT_EQ(Hash(Vector<int, 3>({1, 2, 3})), Hash(Vector<int, 2>({1, 2, 3})));
|
|
}
|
|
|
|
TEST(HashTests, Tuple) {
|
|
EXPECT_EQ(Hash(std::make_tuple(1)), Hash(std::make_tuple(1)));
|
|
EXPECT_EQ(Hash(std::make_tuple(1, 2, 3)), Hash(std::make_tuple(1, 2, 3)));
|
|
EXPECT_NE(Hash(std::make_tuple(1, 2, 3)), Hash(std::make_tuple(1, 2, 4)));
|
|
EXPECT_NE(Hash(std::make_tuple(1, 2, 3)), Hash(std::make_tuple(1, 2, 3, 4)));
|
|
}
|
|
|
|
TEST(HashTests, UnorderedKeyWrapper) {
|
|
using W = UnorderedKeyWrapper<std::vector<int>>;
|
|
|
|
std::unordered_map<W, int> m;
|
|
|
|
m.emplace(W{{1, 2}}, -1);
|
|
EXPECT_EQ(m.size(), 1u);
|
|
EXPECT_EQ(m[W({1, 2})], -1);
|
|
|
|
m.emplace(W{{3, 2}}, 1);
|
|
EXPECT_EQ(m.size(), 2u);
|
|
EXPECT_EQ(m[W({3, 2})], 1);
|
|
EXPECT_EQ(m[W({1, 2})], -1);
|
|
|
|
m.emplace(W{{100}}, 100);
|
|
EXPECT_EQ(m.size(), 3u);
|
|
EXPECT_EQ(m[W({100})], 100);
|
|
EXPECT_EQ(m[W({3, 2})], 1);
|
|
EXPECT_EQ(m[W({1, 2})], -1);
|
|
|
|
// Reversed vector element order
|
|
EXPECT_EQ(m[W({2, 3})], 0);
|
|
EXPECT_EQ(m[W({2, 1})], 0);
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace tint::utils
|