src/common/span_unittest.cpp - angle/angle.git - Git at Google

 //
 // Copyright 2019 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // span_unittests.cpp: Unit tests for the angle::Span class.
 //

 #ifdef UNSAFE_BUFFERS_BUILD
 #    pragma allow_unsafe_buffers
 #endif

 #include "common/span.h"

 #include <gtest/gtest.h>

 #include <array>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include <vector>

 namespace angle
 {
 namespace
 {

 constexpr size_t kSpanDataSize                  = 16;
 constexpr unsigned int kSpanData[kSpanDataSize]                  = {0, 1, 2,  3,  4,  5,  6,  7,
                                                                     8, 9, 10, 11, 12, 13, 14, 15};
 constexpr std::array<const unsigned int, kSpanDataSize> kSpanArr = {
     {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};

 class FakeRange
 {
   public:
     size_t size() const { return kSpanDataSize; }
     const unsigned int *data() { return kSpanData; }
 };

 // Test that comparing spans work
 TEST(SpanTest, Comparison)
 {
     // Duplicate data to make sure comparison is being done on values (and not addresses).
     static constexpr unsigned int kSpanDataDup[kSpanDataSize] = {0, 1, 2,  3,  4,  5,  6,  7,
                                                                  8, 9, 10, 11, 12, 13, 14, 15};

     // Don't use ASSERT_EQ at first because the == is more hidden
     ASSERT_TRUE(Span<const unsigned int>() == Span(kSpanData, 0));
     ASSERT_TRUE(Span(kSpanData + 3, 4) != Span(kSpanDataDup + 5, 4));

     // Check ASSERT_EQ and ASSERT_NE work correctly
     ASSERT_EQ(Span(kSpanData, kSpanDataSize), Span(kSpanDataDup, kSpanDataSize));
     ASSERT_NE(Span(kSpanData, kSpanDataSize - 1), Span(kSpanDataDup + 1, kSpanDataSize - 1));
     ASSERT_NE(Span(kSpanData, kSpanDataSize), Span(kSpanDataDup, kSpanDataSize - 1));
     ASSERT_NE(Span(kSpanData, kSpanDataSize - 1), Span(kSpanDataDup, kSpanDataSize));
     ASSERT_NE(Span(kSpanData, 0), Span(kSpanDataDup, 1));
     ASSERT_NE(Span(kSpanData, 1), Span(kSpanDataDup, 0));
 }

 // Test indexing
 TEST(SpanTest, Indexing)
 {
     constexpr Span sp(kSpanData, kSpanDataSize);

     for (size_t i = 0; i < kSpanDataSize; ++i)
     {
         ASSERT_EQ(sp[i], i);
     }

     unsigned int storage[kSpanDataSize] = {};
     angle::Span<unsigned int> writableSpan(storage, kSpanDataSize);

     for (size_t i = 0; i < kSpanDataSize; ++i)
     {
         writableSpan[i] = i;
     }
     for (size_t i = 0; i < kSpanDataSize; ++i)
     {
         ASSERT_EQ(writableSpan[i], i);
     }
     for (size_t i = 0; i < kSpanDataSize; ++i)
     {
         ASSERT_EQ(storage[i], i);
     }
 }

 // Test for the various constructors
 TEST(SpanTest, Constructors)
 {
     // Default constructor
     {
         Span<const unsigned int> sp;
         static_assert(std::is_same_v<decltype(sp), Span<const unsigned int, dynamic_extent>>);
         ASSERT_TRUE(sp.size() == 0);
         ASSERT_TRUE(sp.empty());
     }

     // Constexpr construct from pointer and size
     {
         constexpr Span sp(kSpanData, kSpanDataSize);
         static_assert(std::is_same_v<decltype(sp), const Span<const unsigned int, dynamic_extent>>);
         ASSERT_EQ(sp.data(), kSpanData);
         ASSERT_EQ(sp.size(), kSpanDataSize);
         ASSERT_FALSE(sp.empty());
     }

     // Constexpr construct from fixed C-style array
     {
         constexpr Span sp(kSpanData);
         static_assert(std::is_same_v<decltype(sp), const Span<const unsigned int, kSpanDataSize>>);
         ASSERT_EQ(sp.data(), kSpanData);
         ASSERT_EQ(sp.size(), kSpanDataSize);
         ASSERT_FALSE(sp.empty());
     }

     // Constexpr construct from constexpr std::array<const>
     {
         constexpr Span sp(kSpanArr);
         static_assert(std::is_same_v<decltype(sp), const Span<const unsigned int, kSpanDataSize>>);
         ASSERT_EQ(sp.data(), kSpanArr.data());
         ASSERT_EQ(sp.size(), kSpanArr.size());
         ASSERT_FALSE(sp.empty());
     }

     // Construct from const std::array<non-const>.
     {
         const std::array<int, 2> kArr = {1, 2};
         Span sp(kArr);
         static_assert(std::is_same_v<decltype(sp), Span<const int, 2u>>);
         ASSERT_EQ(sp.data(), kArr.data());
         ASSERT_EQ(sp.size(), kArr.size());
         ASSERT_FALSE(sp.empty());
     }

     // Construct from std::array<const>.
     {
         std::array<const int, 2> arr = {1, 2};
         Span sp(arr);
         static_assert(std::is_same_v<decltype(sp), Span<const int, 2u>>);
         ASSERT_EQ(sp.data(), arr.data());
         ASSERT_EQ(sp.size(), arr.size());
         ASSERT_FALSE(sp.empty());
     }

     // Construct from std::array<non-const>.
     {
         std::array<int, 2> arr = {1, 2};
         Span sp(arr);
         static_assert(std::is_same_v<decltype(sp), Span<int, 2u>>);
         ASSERT_EQ(sp.data(), arr.data());
         ASSERT_EQ(sp.size(), arr.size());
         ASSERT_FALSE(sp.empty());
     }

     // Construct from std::vector
     {
         std::vector<unsigned int> vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
         Span sp(vec);
         static_assert(std::is_same_v<decltype(sp), Span<unsigned int, dynamic_extent>>);
         ASSERT_EQ(sp.data(), vec.data());
         ASSERT_EQ(sp.size(), vec.size());
         ASSERT_FALSE(sp.empty());
     }

     // Construct from const std::vector
     {
         const std::vector<unsigned int> vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
         Span sp(vec);
         static_assert(std::is_same_v<decltype(sp), Span<const unsigned int, dynamic_extent>>);
         ASSERT_EQ(sp.data(), vec.data());
         ASSERT_EQ(sp.size(), vec.size());
         ASSERT_FALSE(sp.empty());
     }

     // Construct from std::string
     {
         std::string str = "hooray";
         Span sp(str);
         static_assert(std::is_same_v<decltype(sp), Span<char, dynamic_extent>>);
         ASSERT_EQ(sp.data(), str.data());
         ASSERT_EQ(sp.size(), str.size());
         ASSERT_FALSE(sp.empty());
     }

     // Construct from const std::string
     {
         const std::string str = "hooray";
         Span sp(str);
         static_assert(std::is_same_v<decltype(sp), Span<const char, dynamic_extent>>);
         ASSERT_EQ(sp.data(), str.data());
         ASSERT_EQ(sp.size(), str.size());
         ASSERT_FALSE(sp.empty());
     }

     // Construct from std::string_view
     {
         std::string_view view = "hooray";
         Span sp(view);
         static_assert(std::is_same_v<decltype(sp), Span<const char, dynamic_extent>>);
         ASSERT_EQ(sp.data(), view.data());
         ASSERT_EQ(sp.size(), view.size());
         ASSERT_FALSE(sp.empty());
     }

     // Construction from any class that provides data() and size().
     {
         FakeRange range;
         Span sp(range);
         ASSERT_EQ(sp.data(), kSpanData);
         ASSERT_EQ(sp.size(), kSpanDataSize);
     }

     // Copy constructor and copy assignment
     {
         Span sp(kSpanData);
         Span sp2(sp);
         Span<const unsigned int> sp3;

         ASSERT_EQ(sp, sp2);
         ASSERT_EQ(sp2.data(), kSpanData);
         ASSERT_EQ(sp2.size(), kSpanDataSize);
         ASSERT_FALSE(sp2.empty());

         sp3 = sp;

         ASSERT_EQ(sp3, sp);
         ASSERT_EQ(sp3.data(), kSpanData);
         ASSERT_EQ(sp3.size(), kSpanDataSize);
         ASSERT_FALSE(sp3.empty());
     }
 }

 // Test accessing the data directly
 TEST(SpanTest, DataAccess)
 {
     constexpr Span sp(kSpanData, kSpanDataSize);
     const unsigned int *data = sp.data();

     for (size_t i = 0; i < kSpanDataSize; ++i)
     {
         ASSERT_EQ(data[i], i);
     }
 }

 // Test front and back
 TEST(SpanTest, FrontAndBack)
 {
     constexpr Span sp(kSpanData, kSpanDataSize);
     ASSERT_TRUE(sp.front() == 0);
     ASSERT_EQ(sp.back(), kSpanDataSize - 1);
 }

 // Test begin and end
 TEST(SpanTest, BeginAndEnd)
 {
     constexpr Span sp(kSpanData, kSpanDataSize);

     size_t currentIndex = 0;
     for (unsigned int value : sp)
     {
         ASSERT_EQ(value, currentIndex);
         ++currentIndex;
     }
 }

 // Test reverse begin and end
 TEST(SpanTest, RbeginAndRend)
 {
     constexpr Span sp(kSpanData, kSpanDataSize);

     size_t currentIndex = 0;
     for (auto iter = sp.rbegin(); iter != sp.rend(); ++iter)
     {
         ASSERT_EQ(*iter, kSpanDataSize - 1 - currentIndex);
         ++currentIndex;
     }
 }

 // Test first and last
 TEST(SpanTest, FirstAndLast)
 {
     constexpr Span sp(kSpanData, kSpanDataSize);
     constexpr size_t kSplitSize = kSpanDataSize / 4;
     {
         constexpr Span first = sp.first(kSplitSize);
         constexpr Span last  = sp.last(kSplitSize);

         static_assert(
             std::is_same_v<decltype(first), const Span<const unsigned int, dynamic_extent>>);
         ASSERT_EQ(first, Span(kSpanData, kSplitSize));
         ASSERT_EQ(first.data(), kSpanData);
         ASSERT_EQ(first.size(), kSplitSize);

         static_assert(
             std::is_same_v<decltype(last), const Span<const unsigned int, dynamic_extent>>);
         ASSERT_EQ(last, Span(kSpanData + kSpanDataSize - kSplitSize, kSplitSize));
         ASSERT_EQ(last.data(), kSpanData + kSpanDataSize - kSplitSize);
         ASSERT_EQ(last.size(), kSplitSize);
     }

     {
         constexpr Span first = sp.first<kSplitSize>();
         constexpr Span last  = sp.last<kSplitSize>();

         static_assert(std::is_same_v<decltype(first), const Span<const unsigned int, kSplitSize>>);
         ASSERT_EQ(first, Span(kSpanData, kSplitSize));
         ASSERT_EQ(first.data(), kSpanData);
         ASSERT_EQ(first.size(), kSplitSize);

         static_assert(std::is_same_v<decltype(last), const Span<const unsigned int, kSplitSize>>);
         ASSERT_EQ(last, Span(kSpanData + kSpanDataSize - kSplitSize, kSplitSize));
         ASSERT_EQ(last.data(), kSpanData + kSpanDataSize - kSplitSize);
         ASSERT_EQ(last.size(), kSplitSize);
     }
 }

 // Test subspan
 TEST(SpanTest, Subspan)
 {
     constexpr Span sp(kSpanData, kSpanDataSize);
     constexpr size_t kSplitOffset = kSpanDataSize / 4;
     constexpr size_t kSplitSize   = kSpanDataSize / 2;

     // Test one-arg subspan
     {
         constexpr Span subspan = sp.subspan(kSplitOffset);
         static_assert(
             std::is_same_v<decltype(subspan), const Span<const unsigned int, dynamic_extent>>);
         ASSERT_EQ(subspan, Span(kSpanData + kSplitOffset, kSpanDataSize - kSplitOffset));
         ASSERT_EQ(subspan.data(), kSpanData + kSplitOffset);
         ASSERT_EQ(subspan.size(), kSpanDataSize - kSplitOffset);
     }

     // Test two-arg subspan
     {
         constexpr Span subspan = sp.subspan(kSplitOffset, kSplitSize);
         static_assert(
             std::is_same_v<decltype(subspan), const Span<const unsigned int, dynamic_extent>>);
         ASSERT_EQ(subspan, Span(kSpanData + kSplitOffset, kSplitSize));
         ASSERT_EQ(subspan.data(), kSpanData + kSplitOffset);
         ASSERT_EQ(subspan.size(), kSplitSize);
     }

     // Templated one-arg subspan just sugar until C++20 fixed spans.
     {
         constexpr Span subspan = sp.subspan<kSplitOffset>();
         static_assert(
             std::is_same_v<decltype(subspan), const Span<const unsigned int, dynamic_extent>>);
         ASSERT_EQ(subspan, Span(kSpanData + kSplitOffset, kSpanDataSize - kSplitOffset));
         ASSERT_EQ(subspan.data(), kSpanData + kSplitOffset);
         ASSERT_EQ(subspan.size(), kSpanDataSize - kSplitOffset);
     }

     // Templated two-arg subspan just sugar until C++20 fixed spans.
     {
         constexpr Span subspan = sp.subspan<kSplitOffset, kSplitSize>();
         static_assert(
             std::is_same_v<decltype(subspan), const Span<const unsigned int, dynamic_extent>>);
         ASSERT_EQ(subspan, Span(kSpanData + kSplitOffset, kSplitSize));
         ASSERT_EQ(subspan.data(), kSpanData + kSplitOffset);
         ASSERT_EQ(subspan.size(), kSplitSize);
     }
 }

 // Test conversions from non-const to const spans.
 TEST(SpanTest, ConstConversions)
 {
     const unsigned int kStorage[kSpanDataSize] = {0, 1, 2,  3,  4,  5,  6,  7,
                                                   8, 9, 10, 11, 12, 13, 14, 15};
     unsigned int storage[kSpanDataSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     angle::Span readable_span(kStorage, kSpanDataSize);
     angle::Span writable_span(storage, kSpanDataSize);

     static_assert(
         std::is_same_v<decltype(readable_span), Span<const unsigned int, dynamic_extent>>);

     static_assert(std::is_same_v<decltype(writable_span), Span<unsigned int, dynamic_extent>>);

     // Direct comparisons allowed.
     EXPECT_TRUE(readable_span == writable_span);
     EXPECT_FALSE(readable_span != writable_span);

     writable_span[0] = 1234;
     EXPECT_FALSE(readable_span == writable_span);

     // Assignment allowed from non-const to const.
     readable_span = writable_span;
     EXPECT_TRUE(readable_span == writable_span);
 }

 // Test conversions from fixed to dynamic spans.
 TEST(SpanTest, FixedConversions)
 {
     unsigned int storage[kSpanDataSize] = {};
     std::vector<unsigned int> vec(kSpanDataSize, 42);
     Span<unsigned int> dynamic_span(vec);
     Span<unsigned int, kSpanDataSize> static_span(storage);

     // Direct comparisons allowed.
     EXPECT_NE(static_span, dynamic_span);

     // Assignment allowed from fixed to dynamic.
     dynamic_span = static_span;
     EXPECT_EQ(static_span, dynamic_span);

     // Other way around prohibited without fixed conversion.
     dynamic_span[0] = 1234;
     static_span     = dynamic_span.first<kSpanDataSize>();
     EXPECT_EQ(static_span, dynamic_span);
 }

 // Test non-member functions.
 TEST(SpanTest, Helpers)
 {
     // Test as_bytes.
     {
         constexpr int kArray[] = {2, 3, 5, 7, 11, 13};
         auto bytes_span        = as_bytes(Span(kArray));
         EXPECT_EQ(reinterpret_cast<const uint8_t *>(kArray), bytes_span.data());
         EXPECT_EQ(sizeof(kArray), bytes_span.size());
         EXPECT_EQ(bytes_span.size(), bytes_span.size_bytes());
     }

     // Test as_writble_bytes.
     {
         std::vector<int> vec = {1, 1, 2, 3, 5, 8};
         Span<int> mutable_span(vec);
         auto writable_bytes_span = as_writable_bytes(mutable_span);
         static_assert(std::is_same_v<decltype(writable_bytes_span), Span<uint8_t>>);
         EXPECT_EQ(reinterpret_cast<uint8_t *>(vec.data()), writable_bytes_span.data());
         EXPECT_EQ(sizeof(int) * vec.size(), writable_bytes_span.size());
         EXPECT_EQ(writable_bytes_span.size(), writable_bytes_span.size_bytes());
     }

     // Test as_chars.
     {
         constexpr int kArray[] = {2, 3, 5, 7, 11, 13};
         auto chars_span        = as_chars(Span(kArray));
         EXPECT_EQ(reinterpret_cast<const char *>(kArray), chars_span.data());
         EXPECT_EQ(sizeof(kArray), chars_span.size());
         EXPECT_EQ(chars_span.size(), chars_span.size_bytes());
     }

     // Test as writable chars.
     {
         std::vector<int> vec = {1, 1, 2, 3, 5, 8};
         Span<int> mutable_span(vec);
         auto writable_chars_span = as_writable_chars(mutable_span);
         static_assert(std::is_same_v<decltype(writable_chars_span), Span<char>>);
         EXPECT_EQ(reinterpret_cast<char *>(vec.data()), writable_chars_span.data());
         EXPECT_EQ(sizeof(int) * vec.size(), writable_chars_span.size());
         EXPECT_EQ(writable_chars_span.size(), writable_chars_span.size_bytes());
     }

     // Test span_from_ref.
     {
         int x  = 123;
         auto s = span_from_ref(x);
         EXPECT_EQ(&x, s.data());
         EXPECT_EQ(1u, s.size());
         EXPECT_EQ(sizeof(int), s.size_bytes());
         EXPECT_EQ(123, s[0]);
     }

     // Test byte_span_from_ref.
     {
         int x  = 123;
         auto b = byte_span_from_ref(x);
         EXPECT_EQ(reinterpret_cast<uint8_t *>(&x), b.data());
         EXPECT_EQ(sizeof(int), b.size());
     }

     //  Test as_byte_span.
     {
         const std::vector<int> kVec({2, 3, 5, 7, 11, 13});
         auto byte_span = as_byte_span(kVec);
         static_assert(std::is_same_v<decltype(byte_span), Span<const uint8_t>>);
         EXPECT_EQ(byte_span.data(), reinterpret_cast<const uint8_t *>(kVec.data()));
         EXPECT_EQ(byte_span.size(), kVec.size() * sizeof(int));
     }

     // Test as_writable_byte_span
     {
         int kMutArray[] = {2, 3, 5, 7};
         auto byte_span  = as_writable_byte_span(kMutArray);
         EXPECT_EQ(byte_span.data(), reinterpret_cast<uint8_t *>(kMutArray));
         EXPECT_EQ(byte_span.size(), sizeof(kMutArray));
     }
 }

 }  // anonymous namespace
 }  // namespace angle
	//
	// Copyright 2019 The ANGLE Project Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.
	//
	// span_unittests.cpp: Unit tests for the angle::Span class.
	//

	#ifdef UNSAFE_BUFFERS_BUILD
	# pragma allow_unsafe_buffers
	#endif

	#include "common/span.h"

	#include <gtest/gtest.h>

	#include <array>
	#include <string>
	#include <string_view>
	#include <type_traits>
	#include <vector>

	namespace angle
	{
	namespace
	{

	constexpr size_t kSpanDataSize = 16;
	constexpr unsigned int kSpanData[kSpanDataSize] = {0, 1, 2, 3, 4, 5, 6, 7,
	8, 9, 10, 11, 12, 13, 14, 15};
	constexpr std::array<const unsigned int, kSpanDataSize> kSpanArr = {
	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};

	class FakeRange
	{
	public:
	size_t size() const { return kSpanDataSize; }
	const unsigned int *data() { return kSpanData; }
	};

	// Test that comparing spans work
	TEST(SpanTest, Comparison)
	{
	// Duplicate data to make sure comparison is being done on values (and not addresses).
	static constexpr unsigned int kSpanDataDup[kSpanDataSize] = {0, 1, 2, 3, 4, 5, 6, 7,
	8, 9, 10, 11, 12, 13, 14, 15};

	// Don't use ASSERT_EQ at first because the == is more hidden
	ASSERT_TRUE(Span<const unsigned int>() == Span(kSpanData, 0));
	ASSERT_TRUE(Span(kSpanData + 3, 4) != Span(kSpanDataDup + 5, 4));

	// Check ASSERT_EQ and ASSERT_NE work correctly
	ASSERT_EQ(Span(kSpanData, kSpanDataSize), Span(kSpanDataDup, kSpanDataSize));
	ASSERT_NE(Span(kSpanData, kSpanDataSize - 1), Span(kSpanDataDup + 1, kSpanDataSize - 1));
	ASSERT_NE(Span(kSpanData, kSpanDataSize), Span(kSpanDataDup, kSpanDataSize - 1));
	ASSERT_NE(Span(kSpanData, kSpanDataSize - 1), Span(kSpanDataDup, kSpanDataSize));
	ASSERT_NE(Span(kSpanData, 0), Span(kSpanDataDup, 1));
	ASSERT_NE(Span(kSpanData, 1), Span(kSpanDataDup, 0));
	}

	// Test indexing
	TEST(SpanTest, Indexing)
	{
	constexpr Span sp(kSpanData, kSpanDataSize);

	for (size_t i = 0; i < kSpanDataSize; ++i)
	{
	ASSERT_EQ(sp[i], i);
	}

	unsigned int storage[kSpanDataSize] = {};
	angle::Span<unsigned int> writableSpan(storage, kSpanDataSize);

	for (size_t i = 0; i < kSpanDataSize; ++i)
	{
	writableSpan[i] = i;
	}
	for (size_t i = 0; i < kSpanDataSize; ++i)
	{
	ASSERT_EQ(writableSpan[i], i);
	}
	for (size_t i = 0; i < kSpanDataSize; ++i)
	{
	ASSERT_EQ(storage[i], i);
	}
	}

	// Test for the various constructors
	TEST(SpanTest, Constructors)
	{
	// Default constructor
	{
	Span<const unsigned int> sp;
	static_assert(std::is_same_v<decltype(sp), Span<const unsigned int, dynamic_extent>>);
	ASSERT_TRUE(sp.size() == 0);
	ASSERT_TRUE(sp.empty());
	}

	// Constexpr construct from pointer and size
	{
	constexpr Span sp(kSpanData, kSpanDataSize);
	static_assert(std::is_same_v<decltype(sp), const Span<const unsigned int, dynamic_extent>>);
	ASSERT_EQ(sp.data(), kSpanData);
	ASSERT_EQ(sp.size(), kSpanDataSize);
	ASSERT_FALSE(sp.empty());
	}

	// Constexpr construct from fixed C-style array
	{
	constexpr Span sp(kSpanData);
	static_assert(std::is_same_v<decltype(sp), const Span<const unsigned int, kSpanDataSize>>);
	ASSERT_EQ(sp.data(), kSpanData);
	ASSERT_EQ(sp.size(), kSpanDataSize);
	ASSERT_FALSE(sp.empty());
	}

	// Constexpr construct from constexpr std::array<const>
	{
	constexpr Span sp(kSpanArr);
	static_assert(std::is_same_v<decltype(sp), const Span<const unsigned int, kSpanDataSize>>);
	ASSERT_EQ(sp.data(), kSpanArr.data());
	ASSERT_EQ(sp.size(), kSpanArr.size());
	ASSERT_FALSE(sp.empty());
	}

	// Construct from const std::array<non-const>.
	{
	const std::array<int, 2> kArr = {1, 2};
	Span sp(kArr);
	static_assert(std::is_same_v<decltype(sp), Span<const int, 2u>>);
	ASSERT_EQ(sp.data(), kArr.data());
	ASSERT_EQ(sp.size(), kArr.size());
	ASSERT_FALSE(sp.empty());
	}

	// Construct from std::array<const>.
	{
	std::array<const int, 2> arr = {1, 2};
	Span sp(arr);
	static_assert(std::is_same_v<decltype(sp), Span<const int, 2u>>);
	ASSERT_EQ(sp.data(), arr.data());
	ASSERT_EQ(sp.size(), arr.size());
	ASSERT_FALSE(sp.empty());
	}

	// Construct from std::array<non-const>.
	{
	std::array<int, 2> arr = {1, 2};
	Span sp(arr);
	static_assert(std::is_same_v<decltype(sp), Span<int, 2u>>);
	ASSERT_EQ(sp.data(), arr.data());
	ASSERT_EQ(sp.size(), arr.size());
	ASSERT_FALSE(sp.empty());
	}

	// Construct from std::vector
	{
	std::vector<unsigned int> vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
	Span sp(vec);
	static_assert(std::is_same_v<decltype(sp), Span<unsigned int, dynamic_extent>>);
	ASSERT_EQ(sp.data(), vec.data());
	ASSERT_EQ(sp.size(), vec.size());
	ASSERT_FALSE(sp.empty());
	}

	// Construct from const std::vector
	{
	const std::vector<unsigned int> vec({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
	Span sp(vec);
	static_assert(std::is_same_v<decltype(sp), Span<const unsigned int, dynamic_extent>>);
	ASSERT_EQ(sp.data(), vec.data());
	ASSERT_EQ(sp.size(), vec.size());
	ASSERT_FALSE(sp.empty());
	}

	// Construct from std::string
	{
	std::string str = "hooray";
	Span sp(str);
	static_assert(std::is_same_v<decltype(sp), Span<char, dynamic_extent>>);
	ASSERT_EQ(sp.data(), str.data());
	ASSERT_EQ(sp.size(), str.size());
	ASSERT_FALSE(sp.empty());
	}

	// Construct from const std::string
	{
	const std::string str = "hooray";
	Span sp(str);
	static_assert(std::is_same_v<decltype(sp), Span<const char, dynamic_extent>>);
	ASSERT_EQ(sp.data(), str.data());
	ASSERT_EQ(sp.size(), str.size());
	ASSERT_FALSE(sp.empty());
	}

	// Construct from std::string_view
	{
	std::string_view view = "hooray";
	Span sp(view);
	static_assert(std::is_same_v<decltype(sp), Span<const char, dynamic_extent>>);
	ASSERT_EQ(sp.data(), view.data());
	ASSERT_EQ(sp.size(), view.size());
	ASSERT_FALSE(sp.empty());
	}

	// Construction from any class that provides data() and size().
	{
	FakeRange range;
	Span sp(range);
	ASSERT_EQ(sp.data(), kSpanData);
	ASSERT_EQ(sp.size(), kSpanDataSize);
	}

	// Copy constructor and copy assignment
	{
	Span sp(kSpanData);
	Span sp2(sp);
	Span<const unsigned int> sp3;

	ASSERT_EQ(sp, sp2);
	ASSERT_EQ(sp2.data(), kSpanData);
	ASSERT_EQ(sp2.size(), kSpanDataSize);
	ASSERT_FALSE(sp2.empty());

	sp3 = sp;

	ASSERT_EQ(sp3, sp);
	ASSERT_EQ(sp3.data(), kSpanData);
	ASSERT_EQ(sp3.size(), kSpanDataSize);
	ASSERT_FALSE(sp3.empty());
	}
	}

	// Test accessing the data directly
	TEST(SpanTest, DataAccess)
	{
	constexpr Span sp(kSpanData, kSpanDataSize);
	const unsigned int *data = sp.data();

	for (size_t i = 0; i < kSpanDataSize; ++i)
	{
	ASSERT_EQ(data[i], i);
	}
	}

	// Test front and back
	TEST(SpanTest, FrontAndBack)
	{
	constexpr Span sp(kSpanData, kSpanDataSize);
	ASSERT_TRUE(sp.front() == 0);
	ASSERT_EQ(sp.back(), kSpanDataSize - 1);
	}

	// Test begin and end
	TEST(SpanTest, BeginAndEnd)
	{
	constexpr Span sp(kSpanData, kSpanDataSize);

	size_t currentIndex = 0;
	for (unsigned int value : sp)
	{
	ASSERT_EQ(value, currentIndex);
	++currentIndex;
	}
	}

	// Test reverse begin and end
	TEST(SpanTest, RbeginAndRend)
	{
	constexpr Span sp(kSpanData, kSpanDataSize);

	size_t currentIndex = 0;
	for (auto iter = sp.rbegin(); iter != sp.rend(); ++iter)
	{
	ASSERT_EQ(*iter, kSpanDataSize - 1 - currentIndex);
	++currentIndex;
	}
	}

	// Test first and last
	TEST(SpanTest, FirstAndLast)
	{
	constexpr Span sp(kSpanData, kSpanDataSize);
	constexpr size_t kSplitSize = kSpanDataSize / 4;
	{
	constexpr Span first = sp.first(kSplitSize);
	constexpr Span last = sp.last(kSplitSize);

	static_assert(
	std::is_same_v<decltype(first), const Span<const unsigned int, dynamic_extent>>);
	ASSERT_EQ(first, Span(kSpanData, kSplitSize));
	ASSERT_EQ(first.data(), kSpanData);
	ASSERT_EQ(first.size(), kSplitSize);

	static_assert(
	std::is_same_v<decltype(last), const Span<const unsigned int, dynamic_extent>>);
	ASSERT_EQ(last, Span(kSpanData + kSpanDataSize - kSplitSize, kSplitSize));
	ASSERT_EQ(last.data(), kSpanData + kSpanDataSize - kSplitSize);
	ASSERT_EQ(last.size(), kSplitSize);
	}

	{
	constexpr Span first = sp.first<kSplitSize>();
	constexpr Span last = sp.last<kSplitSize>();

	static_assert(std::is_same_v<decltype(first), const Span<const unsigned int, kSplitSize>>);
	ASSERT_EQ(first, Span(kSpanData, kSplitSize));
	ASSERT_EQ(first.data(), kSpanData);
	ASSERT_EQ(first.size(), kSplitSize);

	static_assert(std::is_same_v<decltype(last), const Span<const unsigned int, kSplitSize>>);
	ASSERT_EQ(last, Span(kSpanData + kSpanDataSize - kSplitSize, kSplitSize));
	ASSERT_EQ(last.data(), kSpanData + kSpanDataSize - kSplitSize);
	ASSERT_EQ(last.size(), kSplitSize);
	}
	}

	// Test subspan
	TEST(SpanTest, Subspan)
	{
	constexpr Span sp(kSpanData, kSpanDataSize);
	constexpr size_t kSplitOffset = kSpanDataSize / 4;
	constexpr size_t kSplitSize = kSpanDataSize / 2;

	// Test one-arg subspan
	{
	constexpr Span subspan = sp.subspan(kSplitOffset);
	static_assert(
	std::is_same_v<decltype(subspan), const Span<const unsigned int, dynamic_extent>>);
	ASSERT_EQ(subspan, Span(kSpanData + kSplitOffset, kSpanDataSize - kSplitOffset));
	ASSERT_EQ(subspan.data(), kSpanData + kSplitOffset);
	ASSERT_EQ(subspan.size(), kSpanDataSize - kSplitOffset);
	}

	// Test two-arg subspan
	{
	constexpr Span subspan = sp.subspan(kSplitOffset, kSplitSize);
	static_assert(
	std::is_same_v<decltype(subspan), const Span<const unsigned int, dynamic_extent>>);
	ASSERT_EQ(subspan, Span(kSpanData + kSplitOffset, kSplitSize));
	ASSERT_EQ(subspan.data(), kSpanData + kSplitOffset);
	ASSERT_EQ(subspan.size(), kSplitSize);
	}

	// Templated one-arg subspan just sugar until C++20 fixed spans.
	{
	constexpr Span subspan = sp.subspan<kSplitOffset>();
	static_assert(
	std::is_same_v<decltype(subspan), const Span<const unsigned int, dynamic_extent>>);
	ASSERT_EQ(subspan, Span(kSpanData + kSplitOffset, kSpanDataSize - kSplitOffset));
	ASSERT_EQ(subspan.data(), kSpanData + kSplitOffset);
	ASSERT_EQ(subspan.size(), kSpanDataSize - kSplitOffset);
	}

	// Templated two-arg subspan just sugar until C++20 fixed spans.
	{
	constexpr Span subspan = sp.subspan<kSplitOffset, kSplitSize>();
	static_assert(
	std::is_same_v<decltype(subspan), const Span<const unsigned int, dynamic_extent>>);
	ASSERT_EQ(subspan, Span(kSpanData + kSplitOffset, kSplitSize));
	ASSERT_EQ(subspan.data(), kSpanData + kSplitOffset);
	ASSERT_EQ(subspan.size(), kSplitSize);
	}
	}

	// Test conversions from non-const to const spans.
	TEST(SpanTest, ConstConversions)
	{
	const unsigned int kStorage[kSpanDataSize] = {0, 1, 2, 3, 4, 5, 6, 7,
	8, 9, 10, 11, 12, 13, 14, 15};
	unsigned int storage[kSpanDataSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
	angle::Span readable_span(kStorage, kSpanDataSize);
	angle::Span writable_span(storage, kSpanDataSize);

	static_assert(
	std::is_same_v<decltype(readable_span), Span<const unsigned int, dynamic_extent>>);

	static_assert(std::is_same_v<decltype(writable_span), Span<unsigned int, dynamic_extent>>);

	// Direct comparisons allowed.
	EXPECT_TRUE(readable_span == writable_span);
	EXPECT_FALSE(readable_span != writable_span);

	writable_span[0] = 1234;
	EXPECT_FALSE(readable_span == writable_span);

	// Assignment allowed from non-const to const.
	readable_span = writable_span;
	EXPECT_TRUE(readable_span == writable_span);
	}

	// Test conversions from fixed to dynamic spans.
	TEST(SpanTest, FixedConversions)
	{
	unsigned int storage[kSpanDataSize] = {};
	std::vector<unsigned int> vec(kSpanDataSize, 42);
	Span<unsigned int> dynamic_span(vec);
	Span<unsigned int, kSpanDataSize> static_span(storage);

	// Direct comparisons allowed.
	EXPECT_NE(static_span, dynamic_span);

	// Assignment allowed from fixed to dynamic.
	dynamic_span = static_span;
	EXPECT_EQ(static_span, dynamic_span);

	// Other way around prohibited without fixed conversion.
	dynamic_span[0] = 1234;
	static_span = dynamic_span.first<kSpanDataSize>();
	EXPECT_EQ(static_span, dynamic_span);
	}

	// Test non-member functions.
	TEST(SpanTest, Helpers)
	{
	// Test as_bytes.
	{
	constexpr int kArray[] = {2, 3, 5, 7, 11, 13};
	auto bytes_span = as_bytes(Span(kArray));
	EXPECT_EQ(reinterpret_cast<const uint8_t *>(kArray), bytes_span.data());
	EXPECT_EQ(sizeof(kArray), bytes_span.size());
	EXPECT_EQ(bytes_span.size(), bytes_span.size_bytes());
	}

	// Test as_writble_bytes.
	{
	std::vector<int> vec = {1, 1, 2, 3, 5, 8};
	Span<int> mutable_span(vec);
	auto writable_bytes_span = as_writable_bytes(mutable_span);
	static_assert(std::is_same_v<decltype(writable_bytes_span), Span<uint8_t>>);
	EXPECT_EQ(reinterpret_cast<uint8_t *>(vec.data()), writable_bytes_span.data());
	EXPECT_EQ(sizeof(int) * vec.size(), writable_bytes_span.size());
	EXPECT_EQ(writable_bytes_span.size(), writable_bytes_span.size_bytes());
	}

	// Test as_chars.
	{
	constexpr int kArray[] = {2, 3, 5, 7, 11, 13};
	auto chars_span = as_chars(Span(kArray));
	EXPECT_EQ(reinterpret_cast<const char *>(kArray), chars_span.data());
	EXPECT_EQ(sizeof(kArray), chars_span.size());
	EXPECT_EQ(chars_span.size(), chars_span.size_bytes());
	}

	// Test as writable chars.
	{
	std::vector<int> vec = {1, 1, 2, 3, 5, 8};
	Span<int> mutable_span(vec);
	auto writable_chars_span = as_writable_chars(mutable_span);
	static_assert(std::is_same_v<decltype(writable_chars_span), Span<char>>);
	EXPECT_EQ(reinterpret_cast<char *>(vec.data()), writable_chars_span.data());
	EXPECT_EQ(sizeof(int) * vec.size(), writable_chars_span.size());
	EXPECT_EQ(writable_chars_span.size(), writable_chars_span.size_bytes());
	}

	// Test span_from_ref.
	{
	int x = 123;
	auto s = span_from_ref(x);
	EXPECT_EQ(&x, s.data());
	EXPECT_EQ(1u, s.size());
	EXPECT_EQ(sizeof(int), s.size_bytes());
	EXPECT_EQ(123, s[0]);
	}

	// Test byte_span_from_ref.
	{
	int x = 123;
	auto b = byte_span_from_ref(x);
	EXPECT_EQ(reinterpret_cast<uint8_t *>(&x), b.data());
	EXPECT_EQ(sizeof(int), b.size());
	}

	// Test as_byte_span.
	{
	const std::vector<int> kVec({2, 3, 5, 7, 11, 13});
	auto byte_span = as_byte_span(kVec);
	static_assert(std::is_same_v<decltype(byte_span), Span<const uint8_t>>);
	EXPECT_EQ(byte_span.data(), reinterpret_cast<const uint8_t *>(kVec.data()));
	EXPECT_EQ(byte_span.size(), kVec.size() * sizeof(int));
	}

	// Test as_writable_byte_span
	{
	int kMutArray[] = {2, 3, 5, 7};
	auto byte_span = as_writable_byte_span(kMutArray);
	EXPECT_EQ(byte_span.data(), reinterpret_cast<uint8_t *>(kMutArray));
	EXPECT_EQ(byte_span.size(), sizeof(kMutArray));
	}
	}

	} // anonymous namespace
	} // namespace angle