test/opt/types_test.cpp - external/github.com/KhronosGroup/SPIRV-Tools - Git at Google

 // Copyright (c) 2016 Google Inc.
 //
 // 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 "source/opt/types.h"

 #include <memory>
 #include <utility>
 #include <vector>

 #include "gtest/gtest.h"
 #include "source/util/make_unique.h"

 namespace spvtools {
 namespace opt {
 namespace analysis {
 namespace {

 // Fixture class providing some element types.
 class SameTypeTest : public ::testing::Test {
  protected:
   void SetUp() override {
     void_t_ = MakeUnique<Void>();
     u32_t_ = MakeUnique<Integer>(32, false);
     f64_t_ = MakeUnique<Float>(64);
     v3u32_t_ = MakeUnique<Vector>(u32_t_.get(), 3);
     image_t_ =
         MakeUnique<Image>(f64_t_.get(), SpvDim2D, 1, 1, 0, 0, SpvImageFormatR16,
                           SpvAccessQualifierReadWrite);
   }

   // Element types to be used for constructing other types for testing.
   std::unique_ptr<Type> void_t_;
   std::unique_ptr<Type> u32_t_;
   std::unique_ptr<Type> f64_t_;
   std::unique_ptr<Type> v3u32_t_;
   std::unique_ptr<Type> image_t_;
 };

 #define TestMultipleInstancesOfTheSameTypeQualified(ty, name, ...)        \
   TEST_F(SameTypeTest, MultiSame##ty##name) {                             \
     std::vector<std::unique_ptr<Type>> types;                             \
     for (int i = 0; i < 10; ++i) types.emplace_back(new ty(__VA_ARGS__)); \
     for (size_t i = 0; i < types.size(); ++i) {                           \
       for (size_t j = 0; j < types.size(); ++j) {                         \
         EXPECT_TRUE(types[i]->IsSame(types[j].get()))                     \
             << "expected '" << types[i]->str() << "' is the same as '"    \
             << types[j]->str() << "'";                                    \
         EXPECT_TRUE(*types[i] == *types[j])                               \
             << "expected '" << types[i]->str() << "' is the same as '"    \
             << types[j]->str() << "'";                                    \
       }                                                                   \
     }                                                                     \
   }
 #define TestMultipleInstancesOfTheSameType(ty, ...) \
   TestMultipleInstancesOfTheSameTypeQualified(ty, Simple, __VA_ARGS__)

 TestMultipleInstancesOfTheSameType(Void);
 TestMultipleInstancesOfTheSameType(Bool);
 TestMultipleInstancesOfTheSameType(Integer, 32, true);
 TestMultipleInstancesOfTheSameType(Float, 64);
 TestMultipleInstancesOfTheSameType(Vector, u32_t_.get(), 3);
 TestMultipleInstancesOfTheSameType(Matrix, v3u32_t_.get(), 4);
 TestMultipleInstancesOfTheSameType(Image, f64_t_.get(), SpvDimCube, 0, 0, 1, 1,
                                    SpvImageFormatRgb10A2,
                                    SpvAccessQualifierWriteOnly);
 TestMultipleInstancesOfTheSameType(Sampler);
 TestMultipleInstancesOfTheSameType(SampledImage, image_t_.get());
 // There are three classes of arrays, based on the kinds of length information
 // they have.
 // 1. Array length is a constant or spec constant without spec ID, with literals
 // for the constant value.
 TestMultipleInstancesOfTheSameTypeQualified(Array, LenConstant, u32_t_.get(),
                                             Array::LengthInfo{42,
                                                               {
                                                                   0,
                                                                   9999,
                                                               }});
 // 2. Array length is a spec constant with a given spec id.
 TestMultipleInstancesOfTheSameTypeQualified(Array, LenSpecId, u32_t_.get(),
                                             Array::LengthInfo{42, {1, 99}});
 // 3. Array length is an OpSpecConstantOp expression
 TestMultipleInstancesOfTheSameTypeQualified(Array, LenDefiningId, u32_t_.get(),
                                             Array::LengthInfo{42, {2, 42}});

 TestMultipleInstancesOfTheSameType(RuntimeArray, u32_t_.get());
 TestMultipleInstancesOfTheSameType(Struct, std::vector<const Type*>{
                                                u32_t_.get(), f64_t_.get()});
 TestMultipleInstancesOfTheSameType(Opaque, "testing rocks");
 TestMultipleInstancesOfTheSameType(Pointer, u32_t_.get(), SpvStorageClassInput);
 TestMultipleInstancesOfTheSameType(Function, u32_t_.get(),
                                    {f64_t_.get(), f64_t_.get()});
 TestMultipleInstancesOfTheSameType(Event);
 TestMultipleInstancesOfTheSameType(DeviceEvent);
 TestMultipleInstancesOfTheSameType(ReserveId);
 TestMultipleInstancesOfTheSameType(Queue);
 TestMultipleInstancesOfTheSameType(Pipe, SpvAccessQualifierReadWrite);
 TestMultipleInstancesOfTheSameType(ForwardPointer, 10, SpvStorageClassUniform);
 TestMultipleInstancesOfTheSameType(PipeStorage);
 TestMultipleInstancesOfTheSameType(NamedBarrier);
 TestMultipleInstancesOfTheSameType(AccelerationStructureNV);
 #undef TestMultipleInstanceOfTheSameType
 #undef TestMultipleInstanceOfTheSameTypeQual

 std::vector<std::unique_ptr<Type>> GenerateAllTypes() {
   // Types in this test case are only equal to themselves, nothing else.
   std::vector<std::unique_ptr<Type>> types;

   // Forward Pointer
   types.emplace_back(new ForwardPointer(10000, SpvStorageClassInput));
   types.emplace_back(new ForwardPointer(20000, SpvStorageClassInput));

   // Void, Bool
   types.emplace_back(new Void());
   auto* voidt = types.back().get();
   types.emplace_back(new Bool());
   auto* boolt = types.back().get();

   // Integer
   types.emplace_back(new Integer(32, true));
   auto* s32 = types.back().get();
   types.emplace_back(new Integer(32, false));
   types.emplace_back(new Integer(64, true));
   types.emplace_back(new Integer(64, false));
   auto* u64 = types.back().get();

   // Float
   types.emplace_back(new Float(32));
   auto* f32 = types.back().get();
   types.emplace_back(new Float(64));

   // Vector
   types.emplace_back(new Vector(s32, 2));
   types.emplace_back(new Vector(s32, 3));
   auto* v3s32 = types.back().get();
   types.emplace_back(new Vector(u64, 4));
   types.emplace_back(new Vector(f32, 3));
   auto* v3f32 = types.back().get();

   // Matrix
   types.emplace_back(new Matrix(v3s32, 3));
   types.emplace_back(new Matrix(v3s32, 4));
   types.emplace_back(new Matrix(v3f32, 4));

   // Images
   types.emplace_back(new Image(s32, SpvDim2D, 0, 0, 0, 0, SpvImageFormatRg8,
                                SpvAccessQualifierReadOnly));
   auto* image1 = types.back().get();
   types.emplace_back(new Image(s32, SpvDim2D, 0, 1, 0, 0, SpvImageFormatRg8,
                                SpvAccessQualifierReadOnly));
   types.emplace_back(new Image(s32, SpvDim3D, 0, 1, 0, 0, SpvImageFormatRg8,
                                SpvAccessQualifierReadOnly));
   types.emplace_back(new Image(voidt, SpvDim3D, 0, 1, 0, 1, SpvImageFormatRg8,
                                SpvAccessQualifierReadWrite));
   auto* image2 = types.back().get();

   // Sampler
   types.emplace_back(new Sampler());

   // Sampled Image
   types.emplace_back(new SampledImage(image1));
   types.emplace_back(new SampledImage(image2));

   // Array
   // Length is constant with integer bit representation of 42.
   types.emplace_back(new Array(f32, Array::LengthInfo{99u, {0, 42u}}));
   auto* a42f32 = types.back().get();
   // Differs from previous in length value only.
   types.emplace_back(new Array(f32, Array::LengthInfo{99u, {0, 44u}}));
   // Length is 64-bit constant integer value 42.
   types.emplace_back(new Array(u64, Array::LengthInfo{100u, {0, 42u, 0u}}));
   // Differs from previous in length value only.
   types.emplace_back(new Array(u64, Array::LengthInfo{100u, {0, 44u, 0u}}));

   // Length is spec constant with spec id 18 and default value 44.
   types.emplace_back(new Array(f32, Array::LengthInfo{99u,
                                                       {
                                                           1,
                                                           18u,
                                                           44u,
                                                       }}));
   // Differs from previous in spec id only.
   types.emplace_back(new Array(f32, Array::LengthInfo{99u, {1, 19u, 44u}}));
   // Differs from previous in literal value only.
   types.emplace_back(new Array(f32, Array::LengthInfo{99u, {1, 19u, 48u}}));
   // Length is spec constant op with id 42.
   types.emplace_back(new Array(f32, Array::LengthInfo{42u, {2, 42}}));
   // Differs from previous in result id only.
   types.emplace_back(new Array(f32, Array::LengthInfo{43u, {2, 43}}));

   // RuntimeArray
   types.emplace_back(new RuntimeArray(v3f32));
   types.emplace_back(new RuntimeArray(v3s32));
   auto* rav3s32 = types.back().get();

   // Struct
   types.emplace_back(new Struct(std::vector<const Type*>{s32}));
   types.emplace_back(new Struct(std::vector<const Type*>{s32, f32}));
   auto* sts32f32 = types.back().get();
   types.emplace_back(
       new Struct(std::vector<const Type*>{u64, a42f32, rav3s32}));

   // Opaque
   types.emplace_back(new Opaque(""));
   types.emplace_back(new Opaque("hello"));
   types.emplace_back(new Opaque("world"));

   // Pointer
   types.emplace_back(new Pointer(f32, SpvStorageClassInput));
   types.emplace_back(new Pointer(sts32f32, SpvStorageClassFunction));
   types.emplace_back(new Pointer(a42f32, SpvStorageClassFunction));
   types.emplace_back(new Pointer(voidt, SpvStorageClassFunction));

   // Function
   types.emplace_back(new Function(voidt, {}));
   types.emplace_back(new Function(voidt, {boolt}));
   types.emplace_back(new Function(voidt, {boolt, s32}));
   types.emplace_back(new Function(s32, {boolt, s32}));

   // Event, Device Event, Reserve Id, Queue,
   types.emplace_back(new Event());
   types.emplace_back(new DeviceEvent());
   types.emplace_back(new ReserveId());
   types.emplace_back(new Queue());

   // Pipe, Forward Pointer, PipeStorage, NamedBarrier
   types.emplace_back(new Pipe(SpvAccessQualifierReadWrite));
   types.emplace_back(new Pipe(SpvAccessQualifierReadOnly));
   types.emplace_back(new ForwardPointer(1, SpvStorageClassInput));
   types.emplace_back(new ForwardPointer(2, SpvStorageClassInput));
   types.emplace_back(new ForwardPointer(2, SpvStorageClassUniform));
   types.emplace_back(new PipeStorage());
   types.emplace_back(new NamedBarrier());

   return types;
 }

 TEST(Types, AllTypes) {
   // Types in this test case are only equal to themselves, nothing else.
   std::vector<std::unique_ptr<Type>> types = GenerateAllTypes();

   for (size_t i = 0; i < types.size(); ++i) {
     for (size_t j = 0; j < types.size(); ++j) {
       if (i == j) {
         EXPECT_TRUE(types[i]->IsSame(types[j].get()))
             << "expected '" << types[i]->str() << "' is the same as '"
             << types[j]->str() << "'";
       } else {
         EXPECT_FALSE(types[i]->IsSame(types[j].get()))
             << "entry (" << i << "," << j << ")  expected '" << types[i]->str()
             << "' is different to '" << types[j]->str() << "'";
       }
     }
   }
 }

 TEST(Types, IntSignedness) {
   std::vector<bool> signednesses = {true, false, false, true};
   std::vector<std::unique_ptr<Integer>> types;
   for (bool s : signednesses) {
     types.emplace_back(new Integer(32, s));
   }
   for (size_t i = 0; i < signednesses.size(); i++) {
     EXPECT_EQ(signednesses[i], types[i]->IsSigned());
   }
 }

 TEST(Types, IntWidth) {
   std::vector<uint32_t> widths = {1, 2, 4, 8, 16, 32, 48, 64, 128};
   std::vector<std::unique_ptr<Integer>> types;
   for (uint32_t w : widths) {
     types.emplace_back(new Integer(w, true));
   }
   for (size_t i = 0; i < widths.size(); i++) {
     EXPECT_EQ(widths[i], types[i]->width());
   }
 }

 TEST(Types, FloatWidth) {
   std::vector<uint32_t> widths = {1, 2, 4, 8, 16, 32, 48, 64, 128};
   std::vector<std::unique_ptr<Float>> types;
   for (uint32_t w : widths) {
     types.emplace_back(new Float(w));
   }
   for (size_t i = 0; i < widths.size(); i++) {
     EXPECT_EQ(widths[i], types[i]->width());
   }
 }

 TEST(Types, VectorElementCount) {
   auto s32 = MakeUnique<Integer>(32, true);
   for (uint32_t c : {2, 3, 4}) {
     auto s32v = MakeUnique<Vector>(s32.get(), c);
     EXPECT_EQ(c, s32v->element_count());
   }
 }

 TEST(Types, MatrixElementCount) {
   auto s32 = MakeUnique<Integer>(32, true);
   auto s32v4 = MakeUnique<Vector>(s32.get(), 4);
   for (uint32_t c : {1, 2, 3, 4, 10, 100}) {
     auto s32m = MakeUnique<Matrix>(s32v4.get(), c);
     EXPECT_EQ(c, s32m->element_count());
   }
 }

 TEST(Types, IsUniqueType) {
   std::vector<std::unique_ptr<Type>> types = GenerateAllTypes();

   for (auto& t : types) {
     bool expectation = true;
     // Disallowing variable pointers.
     switch (t->kind()) {
       case Type::kArray:
       case Type::kRuntimeArray:
       case Type::kStruct:
         expectation = false;
         break;
       default:
         break;
     }
     EXPECT_EQ(t->IsUniqueType(false), expectation)
         << "expected '" << t->str() << "' to be a "
         << (expectation ? "" : "non-") << "unique type";

     // Allowing variables pointers.
     if (t->AsPointer()) expectation = false;
     EXPECT_EQ(t->IsUniqueType(true), expectation)
         << "expected '" << t->str() << "' to be a "
         << (expectation ? "" : "non-") << "unique type";
   }
 }

 std::vector<std::unique_ptr<Type>> GenerateAllTypesWithDecorations() {
   std::vector<std::unique_ptr<Type>> types = GenerateAllTypes();
   uint32_t elems = 1;
   uint32_t decs = 1;
   for (auto& t : types) {
     for (uint32_t i = 0; i < (decs % 10); ++i) {
       std::vector<uint32_t> decoration;
       for (uint32_t j = 0; j < (elems % 4) + 1; ++j) {
         decoration.push_back(j);
       }
       t->AddDecoration(std::move(decoration));
       ++elems;
       ++decs;
     }
   }

   return types;
 }

 TEST(Types, Clone) {
   std::vector<std::unique_ptr<Type>> types = GenerateAllTypesWithDecorations();
   for (auto& t : types) {
     auto clone = t->Clone();
     EXPECT_TRUE(*t == *clone);
     EXPECT_TRUE(t->HasSameDecorations(clone.get()));
     EXPECT_NE(clone.get(), t.get());
   }
 }

 TEST(Types, RemoveDecorations) {
   std::vector<std::unique_ptr<Type>> types = GenerateAllTypesWithDecorations();
   for (auto& t : types) {
     auto decorationless = t->RemoveDecorations();
     EXPECT_EQ(*t == *decorationless, t->decoration_empty());
     EXPECT_EQ(t->HasSameDecorations(decorationless.get()),
               t->decoration_empty());
     EXPECT_NE(t.get(), decorationless.get());
   }
 }

 }  // namespace
 }  // namespace analysis
 }  // namespace opt
 }  // namespace spvtools
	// Copyright (c) 2016 Google Inc.
	//
	// 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 "source/opt/types.h"

	#include <memory>
	#include <utility>
	#include <vector>

	#include "gtest/gtest.h"
	#include "source/util/make_unique.h"

	namespace spvtools {
	namespace opt {
	namespace analysis {
	namespace {

	// Fixture class providing some element types.
	class SameTypeTest : public ::testing::Test {
	protected:
	void SetUp() override {
	void_t_ = MakeUnique<Void>();
	u32_t_ = MakeUnique<Integer>(32, false);
	f64_t_ = MakeUnique<Float>(64);
	v3u32_t_ = MakeUnique<Vector>(u32_t_.get(), 3);
	image_t_ =
	MakeUnique<Image>(f64_t_.get(), SpvDim2D, 1, 1, 0, 0, SpvImageFormatR16,
	SpvAccessQualifierReadWrite);
	}

	// Element types to be used for constructing other types for testing.
	std::unique_ptr<Type> void_t_;
	std::unique_ptr<Type> u32_t_;
	std::unique_ptr<Type> f64_t_;
	std::unique_ptr<Type> v3u32_t_;
	std::unique_ptr<Type> image_t_;
	};

	#define TestMultipleInstancesOfTheSameTypeQualified(ty, name, ...) \
	TEST_F(SameTypeTest, MultiSame##ty##name) { \
	std::vector<std::unique_ptr<Type>> types; \
	for (int i = 0; i < 10; ++i) types.emplace_back(new ty(__VA_ARGS__)); \
	for (size_t i = 0; i < types.size(); ++i) { \
	for (size_t j = 0; j < types.size(); ++j) { \
	EXPECT_TRUE(types[i]->IsSame(types[j].get())) \
	<< "expected '" << types[i]->str() << "' is the same as '" \
	<< types[j]->str() << "'"; \
	EXPECT_TRUE(types[i] == types[j]) \
	<< "expected '" << types[i]->str() << "' is the same as '" \
	<< types[j]->str() << "'"; \
	} \
	} \
	}
	#define TestMultipleInstancesOfTheSameType(ty, ...) \
	TestMultipleInstancesOfTheSameTypeQualified(ty, Simple, __VA_ARGS__)

	TestMultipleInstancesOfTheSameType(Void);
	TestMultipleInstancesOfTheSameType(Bool);
	TestMultipleInstancesOfTheSameType(Integer, 32, true);
	TestMultipleInstancesOfTheSameType(Float, 64);
	TestMultipleInstancesOfTheSameType(Vector, u32_t_.get(), 3);
	TestMultipleInstancesOfTheSameType(Matrix, v3u32_t_.get(), 4);
	TestMultipleInstancesOfTheSameType(Image, f64_t_.get(), SpvDimCube, 0, 0, 1, 1,
	SpvImageFormatRgb10A2,
	SpvAccessQualifierWriteOnly);
	TestMultipleInstancesOfTheSameType(Sampler);
	TestMultipleInstancesOfTheSameType(SampledImage, image_t_.get());
	// There are three classes of arrays, based on the kinds of length information
	// they have.
	// 1. Array length is a constant or spec constant without spec ID, with literals
	// for the constant value.
	TestMultipleInstancesOfTheSameTypeQualified(Array, LenConstant, u32_t_.get(),
	Array::LengthInfo{42,
	{
	0,
	9999,
	}});
	// 2. Array length is a spec constant with a given spec id.
	TestMultipleInstancesOfTheSameTypeQualified(Array, LenSpecId, u32_t_.get(),
	Array::LengthInfo{42, {1, 99}});
	// 3. Array length is an OpSpecConstantOp expression
	TestMultipleInstancesOfTheSameTypeQualified(Array, LenDefiningId, u32_t_.get(),
	Array::LengthInfo{42, {2, 42}});

	TestMultipleInstancesOfTheSameType(RuntimeArray, u32_t_.get());
	TestMultipleInstancesOfTheSameType(Struct, std::vector<const Type*>{
	u32_t_.get(), f64_t_.get()});
	TestMultipleInstancesOfTheSameType(Opaque, "testing rocks");
	TestMultipleInstancesOfTheSameType(Pointer, u32_t_.get(), SpvStorageClassInput);
	TestMultipleInstancesOfTheSameType(Function, u32_t_.get(),
	{f64_t_.get(), f64_t_.get()});
	TestMultipleInstancesOfTheSameType(Event);
	TestMultipleInstancesOfTheSameType(DeviceEvent);
	TestMultipleInstancesOfTheSameType(ReserveId);
	TestMultipleInstancesOfTheSameType(Queue);
	TestMultipleInstancesOfTheSameType(Pipe, SpvAccessQualifierReadWrite);
	TestMultipleInstancesOfTheSameType(ForwardPointer, 10, SpvStorageClassUniform);
	TestMultipleInstancesOfTheSameType(PipeStorage);
	TestMultipleInstancesOfTheSameType(NamedBarrier);
	TestMultipleInstancesOfTheSameType(AccelerationStructureNV);
	#undef TestMultipleInstanceOfTheSameType
	#undef TestMultipleInstanceOfTheSameTypeQual

	std::vector<std::unique_ptr<Type>> GenerateAllTypes() {
	// Types in this test case are only equal to themselves, nothing else.
	std::vector<std::unique_ptr<Type>> types;

	// Forward Pointer
	types.emplace_back(new ForwardPointer(10000, SpvStorageClassInput));
	types.emplace_back(new ForwardPointer(20000, SpvStorageClassInput));

	// Void, Bool
	types.emplace_back(new Void());
	auto* voidt = types.back().get();
	types.emplace_back(new Bool());
	auto* boolt = types.back().get();

	// Integer
	types.emplace_back(new Integer(32, true));
	auto* s32 = types.back().get();
	types.emplace_back(new Integer(32, false));
	types.emplace_back(new Integer(64, true));
	types.emplace_back(new Integer(64, false));
	auto* u64 = types.back().get();

	// Float
	types.emplace_back(new Float(32));
	auto* f32 = types.back().get();
	types.emplace_back(new Float(64));

	// Vector
	types.emplace_back(new Vector(s32, 2));
	types.emplace_back(new Vector(s32, 3));
	auto* v3s32 = types.back().get();
	types.emplace_back(new Vector(u64, 4));
	types.emplace_back(new Vector(f32, 3));
	auto* v3f32 = types.back().get();

	// Matrix
	types.emplace_back(new Matrix(v3s32, 3));
	types.emplace_back(new Matrix(v3s32, 4));
	types.emplace_back(new Matrix(v3f32, 4));

	// Images
	types.emplace_back(new Image(s32, SpvDim2D, 0, 0, 0, 0, SpvImageFormatRg8,
	SpvAccessQualifierReadOnly));
	auto* image1 = types.back().get();
	types.emplace_back(new Image(s32, SpvDim2D, 0, 1, 0, 0, SpvImageFormatRg8,
	SpvAccessQualifierReadOnly));
	types.emplace_back(new Image(s32, SpvDim3D, 0, 1, 0, 0, SpvImageFormatRg8,
	SpvAccessQualifierReadOnly));
	types.emplace_back(new Image(voidt, SpvDim3D, 0, 1, 0, 1, SpvImageFormatRg8,
	SpvAccessQualifierReadWrite));
	auto* image2 = types.back().get();

	// Sampler
	types.emplace_back(new Sampler());

	// Sampled Image
	types.emplace_back(new SampledImage(image1));
	types.emplace_back(new SampledImage(image2));

	// Array
	// Length is constant with integer bit representation of 42.
	types.emplace_back(new Array(f32, Array::LengthInfo{99u, {0, 42u}}));
	auto* a42f32 = types.back().get();
	// Differs from previous in length value only.
	types.emplace_back(new Array(f32, Array::LengthInfo{99u, {0, 44u}}));
	// Length is 64-bit constant integer value 42.
	types.emplace_back(new Array(u64, Array::LengthInfo{100u, {0, 42u, 0u}}));
	// Differs from previous in length value only.
	types.emplace_back(new Array(u64, Array::LengthInfo{100u, {0, 44u, 0u}}));

	// Length is spec constant with spec id 18 and default value 44.
	types.emplace_back(new Array(f32, Array::LengthInfo{99u,
	{
	1,
	18u,
	44u,
	}}));
	// Differs from previous in spec id only.
	types.emplace_back(new Array(f32, Array::LengthInfo{99u, {1, 19u, 44u}}));
	// Differs from previous in literal value only.
	types.emplace_back(new Array(f32, Array::LengthInfo{99u, {1, 19u, 48u}}));
	// Length is spec constant op with id 42.
	types.emplace_back(new Array(f32, Array::LengthInfo{42u, {2, 42}}));
	// Differs from previous in result id only.
	types.emplace_back(new Array(f32, Array::LengthInfo{43u, {2, 43}}));

	// RuntimeArray
	types.emplace_back(new RuntimeArray(v3f32));
	types.emplace_back(new RuntimeArray(v3s32));
	auto* rav3s32 = types.back().get();

	// Struct
	types.emplace_back(new Struct(std::vector<const Type*>{s32}));
	types.emplace_back(new Struct(std::vector<const Type*>{s32, f32}));
	auto* sts32f32 = types.back().get();
	types.emplace_back(
	new Struct(std::vector<const Type*>{u64, a42f32, rav3s32}));

	// Opaque
	types.emplace_back(new Opaque(""));
	types.emplace_back(new Opaque("hello"));
	types.emplace_back(new Opaque("world"));

	// Pointer
	types.emplace_back(new Pointer(f32, SpvStorageClassInput));
	types.emplace_back(new Pointer(sts32f32, SpvStorageClassFunction));
	types.emplace_back(new Pointer(a42f32, SpvStorageClassFunction));
	types.emplace_back(new Pointer(voidt, SpvStorageClassFunction));

	// Function
	types.emplace_back(new Function(voidt, {}));
	types.emplace_back(new Function(voidt, {boolt}));
	types.emplace_back(new Function(voidt, {boolt, s32}));
	types.emplace_back(new Function(s32, {boolt, s32}));

	// Event, Device Event, Reserve Id, Queue,
	types.emplace_back(new Event());
	types.emplace_back(new DeviceEvent());
	types.emplace_back(new ReserveId());
	types.emplace_back(new Queue());

	// Pipe, Forward Pointer, PipeStorage, NamedBarrier
	types.emplace_back(new Pipe(SpvAccessQualifierReadWrite));
	types.emplace_back(new Pipe(SpvAccessQualifierReadOnly));
	types.emplace_back(new ForwardPointer(1, SpvStorageClassInput));
	types.emplace_back(new ForwardPointer(2, SpvStorageClassInput));
	types.emplace_back(new ForwardPointer(2, SpvStorageClassUniform));
	types.emplace_back(new PipeStorage());
	types.emplace_back(new NamedBarrier());

	return types;
	}

	TEST(Types, AllTypes) {
	// Types in this test case are only equal to themselves, nothing else.
	std::vector<std::unique_ptr<Type>> types = GenerateAllTypes();

	for (size_t i = 0; i < types.size(); ++i) {
	for (size_t j = 0; j < types.size(); ++j) {
	if (i == j) {
	EXPECT_TRUE(types[i]->IsSame(types[j].get()))
	<< "expected '" << types[i]->str() << "' is the same as '"
	<< types[j]->str() << "'";
	} else {
	EXPECT_FALSE(types[i]->IsSame(types[j].get()))
	<< "entry (" << i << "," << j << ") expected '" << types[i]->str()
	<< "' is different to '" << types[j]->str() << "'";
	}
	}
	}
	}

	TEST(Types, IntSignedness) {
	std::vector<bool> signednesses = {true, false, false, true};
	std::vector<std::unique_ptr<Integer>> types;
	for (bool s : signednesses) {
	types.emplace_back(new Integer(32, s));
	}
	for (size_t i = 0; i < signednesses.size(); i++) {
	EXPECT_EQ(signednesses[i], types[i]->IsSigned());
	}
	}

	TEST(Types, IntWidth) {
	std::vector<uint32_t> widths = {1, 2, 4, 8, 16, 32, 48, 64, 128};
	std::vector<std::unique_ptr<Integer>> types;
	for (uint32_t w : widths) {
	types.emplace_back(new Integer(w, true));
	}
	for (size_t i = 0; i < widths.size(); i++) {
	EXPECT_EQ(widths[i], types[i]->width());
	}
	}

	TEST(Types, FloatWidth) {
	std::vector<uint32_t> widths = {1, 2, 4, 8, 16, 32, 48, 64, 128};
	std::vector<std::unique_ptr<Float>> types;
	for (uint32_t w : widths) {
	types.emplace_back(new Float(w));
	}
	for (size_t i = 0; i < widths.size(); i++) {
	EXPECT_EQ(widths[i], types[i]->width());
	}
	}

	TEST(Types, VectorElementCount) {
	auto s32 = MakeUnique<Integer>(32, true);
	for (uint32_t c : {2, 3, 4}) {
	auto s32v = MakeUnique<Vector>(s32.get(), c);
	EXPECT_EQ(c, s32v->element_count());
	}
	}

	TEST(Types, MatrixElementCount) {
	auto s32 = MakeUnique<Integer>(32, true);
	auto s32v4 = MakeUnique<Vector>(s32.get(), 4);
	for (uint32_t c : {1, 2, 3, 4, 10, 100}) {
	auto s32m = MakeUnique<Matrix>(s32v4.get(), c);
	EXPECT_EQ(c, s32m->element_count());
	}
	}

	TEST(Types, IsUniqueType) {
	std::vector<std::unique_ptr<Type>> types = GenerateAllTypes();

	for (auto& t : types) {
	bool expectation = true;
	// Disallowing variable pointers.
	switch (t->kind()) {
	case Type::kArray:
	case Type::kRuntimeArray:
	case Type::kStruct:
	expectation = false;
	break;
	default:
	break;
	}
	EXPECT_EQ(t->IsUniqueType(false), expectation)
	<< "expected '" << t->str() << "' to be a "
	<< (expectation ? "" : "non-") << "unique type";

	// Allowing variables pointers.
	if (t->AsPointer()) expectation = false;
	EXPECT_EQ(t->IsUniqueType(true), expectation)
	<< "expected '" << t->str() << "' to be a "
	<< (expectation ? "" : "non-") << "unique type";
	}
	}

	std::vector<std::unique_ptr<Type>> GenerateAllTypesWithDecorations() {
	std::vector<std::unique_ptr<Type>> types = GenerateAllTypes();
	uint32_t elems = 1;
	uint32_t decs = 1;
	for (auto& t : types) {
	for (uint32_t i = 0; i < (decs % 10); ++i) {
	std::vector<uint32_t> decoration;
	for (uint32_t j = 0; j < (elems % 4) + 1; ++j) {
	decoration.push_back(j);
	}
	t->AddDecoration(std::move(decoration));
	++elems;
	++decs;
	}
	}

	return types;
	}

	TEST(Types, Clone) {
	std::vector<std::unique_ptr<Type>> types = GenerateAllTypesWithDecorations();
	for (auto& t : types) {
	auto clone = t->Clone();
	EXPECT_TRUE(t == clone);
	EXPECT_TRUE(t->HasSameDecorations(clone.get()));
	EXPECT_NE(clone.get(), t.get());
	}
	}

	TEST(Types, RemoveDecorations) {
	std::vector<std::unique_ptr<Type>> types = GenerateAllTypesWithDecorations();
	for (auto& t : types) {
	auto decorationless = t->RemoveDecorations();
	EXPECT_EQ(t == decorationless, t->decoration_empty());
	EXPECT_EQ(t->HasSameDecorations(decorationless.get()),
	t->decoration_empty());
	EXPECT_NE(t.get(), decorationless.get());
	}
	}

	} // namespace
	} // namespace analysis
	} // namespace opt
	} // namespace spvtools