src/decoder/test/physical_astc_block_test.cc - platform/external/astc-codec - Git at Google

 // Copyright 2018 Google LLC
 //
 // 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
 //
 //     https://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/decoder/physical_astc_block.h"
 #include "src/base/uint128.h"

 #include <gtest/gtest.h>

 #include <string>
 #include <vector>

 using astc_codec::PhysicalASTCBlock;
 using astc_codec::ColorEndpointMode;
 using astc_codec::base::UInt128;

 namespace {

 static const PhysicalASTCBlock kErrorBlock(UInt128(0));

 // Test to make sure that each of the constructors work and that
 // they produce the same block encodings, since the ASTC blocks
 // are little-endian
 TEST(PhysicalASTCBlockTest, TestConstructors) {
   // Little-endian reading of bytes
   PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
   PhysicalASTCBlock blk2(
       std::string("\x73\x01\x00\xFE\x01\x00\x00\x00\x00"
                   "\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16));
   EXPECT_EQ(blk1.GetBlockBits(), blk2.GetBlockBits());
 }

 // Test to see if we properly decode the maximum value that a weight
 // can take in an ASTC block based on the block mode encoding. We test
 // against a valid case and various error cases
 TEST(PhysicalASTCBlockTest, TestWeightRange) {
   PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
   auto weight_range = blk1.WeightRange();
   ASSERT_TRUE(weight_range);
   EXPECT_EQ(weight_range.value(), 7);

   // If we flip the high bit then we should have a range of 31,
   // although then we have too many bits and this should error.
   PhysicalASTCBlock blk2(0x0000000001FE000373ULL);
   EXPECT_FALSE(blk2.WeightRange());

   // One bit per weight -- range of 1
   PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL);
   weight_range = non_shared_cem.WeightRange();
   ASSERT_TRUE(weight_range);
   EXPECT_EQ(weight_range.value(), 1);

   // Error blocks have no weight range
   EXPECT_FALSE(kErrorBlock.WeightRange());
 }

 // Test to see if we properly decode the weight grid width and height
 // in an ASTC block based on the block mode encoding. We test against
 // a valid case and various error cases
 TEST(PhysicalASTCBlockTest, TestWeightDims) {
   PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
   auto weight_dims = blk1.WeightGridDims();
   EXPECT_TRUE(weight_dims);
   EXPECT_EQ(weight_dims.value()[0], 6);
   EXPECT_EQ(weight_dims.value()[1], 5);

   // If we flip the high bit then we should have a range of 31,
   // although then we have too many bits for the weight grid
   // and this should error.
   PhysicalASTCBlock blk2(0x0000000001FE000373ULL);
   EXPECT_FALSE(blk2.WeightGridDims());
   EXPECT_EQ(blk2.IsIllegalEncoding().value(),
             "Too many bits required for weight grid");

   // Dual plane block with 3x5 weight dims
   PhysicalASTCBlock blk3(0x0000000001FE0005FFULL);
   weight_dims = blk3.WeightGridDims();
   ASSERT_TRUE(weight_dims);
   EXPECT_EQ(weight_dims->at(0), 3);
   EXPECT_EQ(weight_dims->at(1), 5);

   // Error blocks shouldn't have any weight dims
   EXPECT_FALSE(kErrorBlock.WeightGridDims());

   PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL);
   weight_dims = non_shared_cem.WeightGridDims();
   ASSERT_TRUE(weight_dims);
   EXPECT_EQ(weight_dims->at(0), 8);
   EXPECT_EQ(weight_dims->at(1), 8);
 }

 // Test to see whether or not the presence of a dual-plane bit
 // is decoded properly. Error encodings are tested to *not* return
 // that they have dual planes.
 TEST(PhysicalASTCBlockTest, TestDualPlane) {
   PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
   EXPECT_FALSE(blk1.IsDualPlane());
   EXPECT_FALSE(kErrorBlock.IsDualPlane());

   // If we flip the dual plane bit, we will have too many bits
   // for the weight grid and this should error
   PhysicalASTCBlock blk2(0x0000000001FE000573ULL);
   EXPECT_FALSE(blk2.IsDualPlane());
   EXPECT_FALSE(blk2.WeightGridDims());
   EXPECT_EQ(blk2.IsIllegalEncoding().value(),
             "Too many bits required for weight grid");

   // A dual plane with 3x5 weight grid should be supported
   PhysicalASTCBlock blk3(0x0000000001FE0005FFULL);
   EXPECT_TRUE(blk3.IsDualPlane());

   // If we use the wrong block mode, then a valid block
   // shouldn't have any dual plane
   PhysicalASTCBlock blk4(0x0000000001FE000108ULL);
   EXPECT_FALSE(blk4.IsDualPlane());
   EXPECT_FALSE(blk4.IsIllegalEncoding());
 }

 // Make sure that we properly calculate the number of bits used to encode
 // the weight grid. Given error encodings or void extent blocks, this number
 // should be zero
 TEST(PhysicalASTCBlockTest, TestNumWeightBits) {
   // 6x5 single-plane weight grid with 3-bit weights
   // should have 90 bits for the weights.
   PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
   EXPECT_EQ(90, blk1.NumWeightBits());

   // Error block has no weight bits
   EXPECT_FALSE(kErrorBlock.NumWeightBits());

   // Void extent blocks have no weight bits
   EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).NumWeightBits());

   // If we flip the dual plane bit, we will have too many bits
   // for the weight grid and this should error and return no bits
   PhysicalASTCBlock blk2(0x0000000001FE000573ULL);
   EXPECT_FALSE(blk2.NumWeightBits());

   // 3x5 dual-plane weight grid with 3-bit weights
   // should have 90 bits for the weights.
   PhysicalASTCBlock blk3(0x0000000001FE0005FFULL);
   EXPECT_EQ(90, blk3.NumWeightBits());
 }

 // Test to make sure that our weight bits start where we expect them to.
 // In other words, make sure that the calculation based on the block mode for
 // where the weight bits start is accurate.
 TEST(PhysicalASTCBlockTest, TestStartWeightBit) {
   EXPECT_EQ(PhysicalASTCBlock(0x4000000000800D44ULL).WeightStartBit(), 64);

   // Error blocks have no weight start bit
   EXPECT_FALSE(kErrorBlock.WeightStartBit());

   // Void extent blocks have no weight start bit
   EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).WeightStartBit());
 }

 // Test to make sure that we catch various different reasons for error encoding
 // of ASTC blocks, but also that certain encodings aren't errors.
 TEST(PhysicalASTCBlockTest, TestErrorBlocks) {
   // Various valid block modes
   EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).IsIllegalEncoding());
   EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE0005FFULL).IsIllegalEncoding());
   EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000108ULL).IsIllegalEncoding());

   // This is an error because it uses an invalid block mode
   EXPECT_EQ(kErrorBlock.IsIllegalEncoding().value(), "Reserved block mode");

   // This is an error because we have too many weight bits
   PhysicalASTCBlock err_blk(0x0000000001FE000573ULL);
   EXPECT_EQ(err_blk.IsIllegalEncoding().value(),
             "Too many bits required for weight grid");

   // This is an error because we have too many weights
   PhysicalASTCBlock err_blk2 = PhysicalASTCBlock(0x0000000001FE0005A8ULL);
   EXPECT_EQ(err_blk2.IsIllegalEncoding().value(), "Too many weights specified");

   PhysicalASTCBlock err_blk3 = PhysicalASTCBlock(0x0000000001FE000588ULL);
   EXPECT_EQ(err_blk3.IsIllegalEncoding().value(), "Too many weights specified");

   // This is an error because we have too few weights
   PhysicalASTCBlock err_blk4 = PhysicalASTCBlock(0x0000000001FE00002ULL);
   EXPECT_EQ(err_blk4.IsIllegalEncoding().value(),
             "Too few bits required for weight grid");

   // Four partitions, dual plane -- should be error
   // 2x2 weight grid, 3 bits per weight
   PhysicalASTCBlock dual_plane_four_parts(0x000000000000001D1FULL);
   EXPECT_FALSE(dual_plane_four_parts.NumPartitions());
   EXPECT_EQ(dual_plane_four_parts.IsIllegalEncoding().value(),
             "Both four partitions and dual plane specified");
 }

 // Test to make sure that we properly identify and can manipulate void-extent
 // blocks. These are ASTC blocks that only define a single color for the entire
 // block.
 TEST(PhysicalASTCBlockTest, TestVoidExtentBlocks) {
   // Various valid block modes that aren't void extent blocks
   EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).IsVoidExtent());
   EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE0005FFULL).IsVoidExtent());
   EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000108ULL).IsVoidExtent());

   // Error block is not a void extent block
   EXPECT_FALSE(kErrorBlock.IsVoidExtent());

   // Void extent block is void extent block...
   UInt128 void_extent_encoding(0, 0xFFF8003FFE000DFCULL);
   EXPECT_FALSE(PhysicalASTCBlock(void_extent_encoding).IsIllegalEncoding());
   EXPECT_TRUE(PhysicalASTCBlock(void_extent_encoding).IsVoidExtent());

   // If we modify the high 64 bits it shouldn't change anything
   void_extent_encoding |= UInt128(0xdeadbeefdeadbeef, 0);
   EXPECT_FALSE(PhysicalASTCBlock(void_extent_encoding).IsIllegalEncoding());
   EXPECT_TRUE(PhysicalASTCBlock(void_extent_encoding).IsVoidExtent());
 }

 TEST(PhysicalASTCBlockTest, TestVoidExtentCoordinates) {
   // The void extent block should have texture coordinates from 0-8191
   auto coords = PhysicalASTCBlock(0xFFF8003FFE000DFCULL).VoidExtentCoords();
   EXPECT_EQ(coords->at(0), 0);
   EXPECT_EQ(coords->at(1), 8191);
   EXPECT_EQ(coords->at(2), 0);
   EXPECT_EQ(coords->at(3), 8191);

   // If we set the coords to all 1's then it's still a void extent
   // block, but there aren't any void extent coords.
   EXPECT_FALSE(PhysicalASTCBlock(0xFFFFFFFFFFFFFDFCULL).IsIllegalEncoding());
   EXPECT_TRUE(PhysicalASTCBlock(0xFFFFFFFFFFFFFDFCULL).IsVoidExtent());
   EXPECT_FALSE(PhysicalASTCBlock(0xFFFFFFFFFFFFFDFCULL).VoidExtentCoords());

   // If we set the void extent coords to something where the coords are
   // >= each other, then the encoding is illegal.
   EXPECT_TRUE(PhysicalASTCBlock(0x0008004002001DFCULL).IsIllegalEncoding());
   EXPECT_TRUE(PhysicalASTCBlock(0x0007FFC001FFFDFCULL).IsIllegalEncoding());
 }

 // Test to see if we can properly identify the number of partitions in a block
 // In particular -- we need to make sure we properly identify single and
 // multi-partition blocks, but also that void extent and error blocks don't
 // return valid numbers of partitions
 TEST(PhysicalASTCBlockTest, TestNumPartitions) {
   // Various valid block modes, but all single partition
   EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).NumPartitions(), 1);
   EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE0005FFULL).NumPartitions(), 1);
   EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000108ULL).NumPartitions(), 1);

   // Two to four partitions don't have enough bits for color.
   EXPECT_FALSE(PhysicalASTCBlock(0x000000000000000973ULL).NumPartitions());
   EXPECT_FALSE(PhysicalASTCBlock(0x000000000000001173ULL).NumPartitions());
   EXPECT_FALSE(PhysicalASTCBlock(0x000000000000001973ULL).NumPartitions());

   // Test against having more than one partition
   PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL);
   EXPECT_EQ(non_shared_cem.NumPartitions(), 2);
 }

 // Test the color endpoint modes specified for how the endpoints are encoded.
 // In particular, test that shared color endpoint modes work for multi-partition
 // blocks and that non-shared color endpoint modes also work.
 TEST(PhysicalASTCBlockTest, TestColorEndpointModes) {
   // Four partitions -- one shared CEM
   const auto blk1 = PhysicalASTCBlock(0x000000000000001961ULL);
   for (int i = 0; i < 4; ++i) {
     EXPECT_EQ(blk1.GetEndpointMode(i), ColorEndpointMode::kLDRLumaDirect);
   }

   // Void extent blocks have no endpoint modes
   EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).GetEndpointMode(0));

   // Test out of range partitions
   EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).GetEndpointMode(1));
   EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).GetEndpointMode(-1));
   EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).GetEndpointMode(100));

   // Error blocks have no endpoint modes
   EXPECT_FALSE(kErrorBlock.GetEndpointMode(0));

   // Test non-shared CEMs
   PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL);
   EXPECT_EQ(non_shared_cem.GetEndpointMode(0),
             ColorEndpointMode::kLDRLumaDirect);
   EXPECT_EQ(non_shared_cem.GetEndpointMode(1),
             ColorEndpointMode::kLDRLumaBaseOffset);
 }

 // Make sure that if we have more than one partition then we have proper
 // partition IDs (these determine which pixels correspond to which partition)
 TEST(PhysicalASTCBlockTest, TestPartitionID) {
   // Valid partitions
   EXPECT_EQ(PhysicalASTCBlock(0x4000000000FFED44ULL).PartitionID(), 0x3FF);
   EXPECT_EQ(PhysicalASTCBlock(0x4000000000AAAD44ULL).PartitionID(), 0x155);

   // Error blocks have no partition IDs
   EXPECT_FALSE(kErrorBlock.PartitionID());

   // Void extent blocks have no endpoint modes
   EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).PartitionID());
 }

 // Make sure that we're properly attributing the number of bits associated with
 // the encoded color values.
 TEST(PhysicalASTCBlockTest, TestNumColorBits) {
   // If we're using a direct luma channel, then the number of color bits is 16
   EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).NumColorValues(), 2);
   EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).NumColorBits(), 16);

   // Error blocks have nothing
   EXPECT_FALSE(kErrorBlock.NumColorValues());
   EXPECT_FALSE(kErrorBlock.NumColorBits());

   // Void extent blocks have four color values and 64 bits of color
   EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).NumColorValues(), 4);
   EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).NumColorBits(), 64);
 }

 // Make sure that we're properly decoding the range of values that each of the
 // encoded color values can take
 TEST(PhysicalASTCBlockTest, TestColorValuesRange) {
   // If we're using a direct luma channel, then we use two color values up to
   // a full byte each.
   EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).ColorValuesRange(), 255);

   // Error blocks have nothing
   EXPECT_FALSE(kErrorBlock.ColorValuesRange());

   // Void extent blocks have four color values and 64 bits of color, so the
   // color range for each is sixteen bits.
   EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).ColorValuesRange(),
             (1 << 16) - 1);
 }

 // Test that we know where the color data starts. This is different mostly
 // depending on whether or not the block is single-partition or void extent.
 TEST(PhysicalASTCBlockTest, TestColorStartBits) {
   // Void extent blocks start at bit 64
   EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).ColorStartBit(), 64);

   // Error blocks don't start anywhere
   EXPECT_FALSE(kErrorBlock.ColorStartBit());

   // Single partition blocks start at bit 17
   EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).ColorStartBit(), 17);
   EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE0005FFULL).ColorStartBit(), 17);
   EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000108ULL).ColorStartBit(), 17);

   // Multi-partition blocks start at bit 29
   EXPECT_EQ(PhysicalASTCBlock(0x4000000000FFED44ULL).ColorStartBit(), 29);
   EXPECT_EQ(PhysicalASTCBlock(0x4000000000AAAD44ULL).ColorStartBit(), 29);
 }

 }  // namespace
	// Copyright 2018 Google LLC
	//
	// 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
	//
	// https://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/decoder/physical_astc_block.h"
	#include "src/base/uint128.h"

	#include <gtest/gtest.h>

	#include <string>
	#include <vector>

	using astc_codec::PhysicalASTCBlock;
	using astc_codec::ColorEndpointMode;
	using astc_codec::base::UInt128;

	namespace {

	static const PhysicalASTCBlock kErrorBlock(UInt128(0));

	// Test to make sure that each of the constructors work and that
	// they produce the same block encodings, since the ASTC blocks
	// are little-endian
	TEST(PhysicalASTCBlockTest, TestConstructors) {
	// Little-endian reading of bytes
	PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
	PhysicalASTCBlock blk2(
	std::string("\x73\x01\x00\xFE\x01\x00\x00\x00\x00"
	"\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16));
	EXPECT_EQ(blk1.GetBlockBits(), blk2.GetBlockBits());
	}

	// Test to see if we properly decode the maximum value that a weight
	// can take in an ASTC block based on the block mode encoding. We test
	// against a valid case and various error cases
	TEST(PhysicalASTCBlockTest, TestWeightRange) {
	PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
	auto weight_range = blk1.WeightRange();
	ASSERT_TRUE(weight_range);
	EXPECT_EQ(weight_range.value(), 7);

	// If we flip the high bit then we should have a range of 31,
	// although then we have too many bits and this should error.
	PhysicalASTCBlock blk2(0x0000000001FE000373ULL);
	EXPECT_FALSE(blk2.WeightRange());

	// One bit per weight -- range of 1
	PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL);
	weight_range = non_shared_cem.WeightRange();
	ASSERT_TRUE(weight_range);
	EXPECT_EQ(weight_range.value(), 1);

	// Error blocks have no weight range
	EXPECT_FALSE(kErrorBlock.WeightRange());
	}

	// Test to see if we properly decode the weight grid width and height
	// in an ASTC block based on the block mode encoding. We test against
	// a valid case and various error cases
	TEST(PhysicalASTCBlockTest, TestWeightDims) {
	PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
	auto weight_dims = blk1.WeightGridDims();
	EXPECT_TRUE(weight_dims);
	EXPECT_EQ(weight_dims.value()[0], 6);
	EXPECT_EQ(weight_dims.value()[1], 5);

	// If we flip the high bit then we should have a range of 31,
	// although then we have too many bits for the weight grid
	// and this should error.
	PhysicalASTCBlock blk2(0x0000000001FE000373ULL);
	EXPECT_FALSE(blk2.WeightGridDims());
	EXPECT_EQ(blk2.IsIllegalEncoding().value(),
	"Too many bits required for weight grid");

	// Dual plane block with 3x5 weight dims
	PhysicalASTCBlock blk3(0x0000000001FE0005FFULL);
	weight_dims = blk3.WeightGridDims();
	ASSERT_TRUE(weight_dims);
	EXPECT_EQ(weight_dims->at(0), 3);
	EXPECT_EQ(weight_dims->at(1), 5);

	// Error blocks shouldn't have any weight dims
	EXPECT_FALSE(kErrorBlock.WeightGridDims());

	PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL);
	weight_dims = non_shared_cem.WeightGridDims();
	ASSERT_TRUE(weight_dims);
	EXPECT_EQ(weight_dims->at(0), 8);
	EXPECT_EQ(weight_dims->at(1), 8);
	}

	// Test to see whether or not the presence of a dual-plane bit
	// is decoded properly. Error encodings are tested to not return
	// that they have dual planes.
	TEST(PhysicalASTCBlockTest, TestDualPlane) {
	PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
	EXPECT_FALSE(blk1.IsDualPlane());
	EXPECT_FALSE(kErrorBlock.IsDualPlane());

	// If we flip the dual plane bit, we will have too many bits
	// for the weight grid and this should error
	PhysicalASTCBlock blk2(0x0000000001FE000573ULL);
	EXPECT_FALSE(blk2.IsDualPlane());
	EXPECT_FALSE(blk2.WeightGridDims());
	EXPECT_EQ(blk2.IsIllegalEncoding().value(),
	"Too many bits required for weight grid");

	// A dual plane with 3x5 weight grid should be supported
	PhysicalASTCBlock blk3(0x0000000001FE0005FFULL);
	EXPECT_TRUE(blk3.IsDualPlane());

	// If we use the wrong block mode, then a valid block
	// shouldn't have any dual plane
	PhysicalASTCBlock blk4(0x0000000001FE000108ULL);
	EXPECT_FALSE(blk4.IsDualPlane());
	EXPECT_FALSE(blk4.IsIllegalEncoding());
	}

	// Make sure that we properly calculate the number of bits used to encode
	// the weight grid. Given error encodings or void extent blocks, this number
	// should be zero
	TEST(PhysicalASTCBlockTest, TestNumWeightBits) {
	// 6x5 single-plane weight grid with 3-bit weights
	// should have 90 bits for the weights.
	PhysicalASTCBlock blk1(0x0000000001FE000173ULL);
	EXPECT_EQ(90, blk1.NumWeightBits());

	// Error block has no weight bits
	EXPECT_FALSE(kErrorBlock.NumWeightBits());

	// Void extent blocks have no weight bits
	EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).NumWeightBits());

	// If we flip the dual plane bit, we will have too many bits
	// for the weight grid and this should error and return no bits
	PhysicalASTCBlock blk2(0x0000000001FE000573ULL);
	EXPECT_FALSE(blk2.NumWeightBits());

	// 3x5 dual-plane weight grid with 3-bit weights
	// should have 90 bits for the weights.
	PhysicalASTCBlock blk3(0x0000000001FE0005FFULL);
	EXPECT_EQ(90, blk3.NumWeightBits());
	}

	// Test to make sure that our weight bits start where we expect them to.
	// In other words, make sure that the calculation based on the block mode for
	// where the weight bits start is accurate.
	TEST(PhysicalASTCBlockTest, TestStartWeightBit) {
	EXPECT_EQ(PhysicalASTCBlock(0x4000000000800D44ULL).WeightStartBit(), 64);

	// Error blocks have no weight start bit
	EXPECT_FALSE(kErrorBlock.WeightStartBit());

	// Void extent blocks have no weight start bit
	EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).WeightStartBit());
	}

	// Test to make sure that we catch various different reasons for error encoding
	// of ASTC blocks, but also that certain encodings aren't errors.
	TEST(PhysicalASTCBlockTest, TestErrorBlocks) {
	// Various valid block modes
	EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).IsIllegalEncoding());
	EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE0005FFULL).IsIllegalEncoding());
	EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000108ULL).IsIllegalEncoding());

	// This is an error because it uses an invalid block mode
	EXPECT_EQ(kErrorBlock.IsIllegalEncoding().value(), "Reserved block mode");

	// This is an error because we have too many weight bits
	PhysicalASTCBlock err_blk(0x0000000001FE000573ULL);
	EXPECT_EQ(err_blk.IsIllegalEncoding().value(),
	"Too many bits required for weight grid");

	// This is an error because we have too many weights
	PhysicalASTCBlock err_blk2 = PhysicalASTCBlock(0x0000000001FE0005A8ULL);
	EXPECT_EQ(err_blk2.IsIllegalEncoding().value(), "Too many weights specified");

	PhysicalASTCBlock err_blk3 = PhysicalASTCBlock(0x0000000001FE000588ULL);
	EXPECT_EQ(err_blk3.IsIllegalEncoding().value(), "Too many weights specified");

	// This is an error because we have too few weights
	PhysicalASTCBlock err_blk4 = PhysicalASTCBlock(0x0000000001FE00002ULL);
	EXPECT_EQ(err_blk4.IsIllegalEncoding().value(),
	"Too few bits required for weight grid");

	// Four partitions, dual plane -- should be error
	// 2x2 weight grid, 3 bits per weight
	PhysicalASTCBlock dual_plane_four_parts(0x000000000000001D1FULL);
	EXPECT_FALSE(dual_plane_four_parts.NumPartitions());
	EXPECT_EQ(dual_plane_four_parts.IsIllegalEncoding().value(),
	"Both four partitions and dual plane specified");
	}

	// Test to make sure that we properly identify and can manipulate void-extent
	// blocks. These are ASTC blocks that only define a single color for the entire
	// block.
	TEST(PhysicalASTCBlockTest, TestVoidExtentBlocks) {
	// Various valid block modes that aren't void extent blocks
	EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).IsVoidExtent());
	EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE0005FFULL).IsVoidExtent());
	EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000108ULL).IsVoidExtent());

	// Error block is not a void extent block
	EXPECT_FALSE(kErrorBlock.IsVoidExtent());

	// Void extent block is void extent block...
	UInt128 void_extent_encoding(0, 0xFFF8003FFE000DFCULL);
	EXPECT_FALSE(PhysicalASTCBlock(void_extent_encoding).IsIllegalEncoding());
	EXPECT_TRUE(PhysicalASTCBlock(void_extent_encoding).IsVoidExtent());

	// If we modify the high 64 bits it shouldn't change anything
	void_extent_encoding \|= UInt128(0xdeadbeefdeadbeef, 0);
	EXPECT_FALSE(PhysicalASTCBlock(void_extent_encoding).IsIllegalEncoding());
	EXPECT_TRUE(PhysicalASTCBlock(void_extent_encoding).IsVoidExtent());
	}

	TEST(PhysicalASTCBlockTest, TestVoidExtentCoordinates) {
	// The void extent block should have texture coordinates from 0-8191
	auto coords = PhysicalASTCBlock(0xFFF8003FFE000DFCULL).VoidExtentCoords();
	EXPECT_EQ(coords->at(0), 0);
	EXPECT_EQ(coords->at(1), 8191);
	EXPECT_EQ(coords->at(2), 0);
	EXPECT_EQ(coords->at(3), 8191);

	// If we set the coords to all 1's then it's still a void extent
	// block, but there aren't any void extent coords.
	EXPECT_FALSE(PhysicalASTCBlock(0xFFFFFFFFFFFFFDFCULL).IsIllegalEncoding());
	EXPECT_TRUE(PhysicalASTCBlock(0xFFFFFFFFFFFFFDFCULL).IsVoidExtent());
	EXPECT_FALSE(PhysicalASTCBlock(0xFFFFFFFFFFFFFDFCULL).VoidExtentCoords());

	// If we set the void extent coords to something where the coords are
	// >= each other, then the encoding is illegal.
	EXPECT_TRUE(PhysicalASTCBlock(0x0008004002001DFCULL).IsIllegalEncoding());
	EXPECT_TRUE(PhysicalASTCBlock(0x0007FFC001FFFDFCULL).IsIllegalEncoding());
	}

	// Test to see if we can properly identify the number of partitions in a block
	// In particular -- we need to make sure we properly identify single and
	// multi-partition blocks, but also that void extent and error blocks don't
	// return valid numbers of partitions
	TEST(PhysicalASTCBlockTest, TestNumPartitions) {
	// Various valid block modes, but all single partition
	EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).NumPartitions(), 1);
	EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE0005FFULL).NumPartitions(), 1);
	EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000108ULL).NumPartitions(), 1);

	// Two to four partitions don't have enough bits for color.
	EXPECT_FALSE(PhysicalASTCBlock(0x000000000000000973ULL).NumPartitions());
	EXPECT_FALSE(PhysicalASTCBlock(0x000000000000001173ULL).NumPartitions());
	EXPECT_FALSE(PhysicalASTCBlock(0x000000000000001973ULL).NumPartitions());

	// Test against having more than one partition
	PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL);
	EXPECT_EQ(non_shared_cem.NumPartitions(), 2);
	}

	// Test the color endpoint modes specified for how the endpoints are encoded.
	// In particular, test that shared color endpoint modes work for multi-partition
	// blocks and that non-shared color endpoint modes also work.
	TEST(PhysicalASTCBlockTest, TestColorEndpointModes) {
	// Four partitions -- one shared CEM
	const auto blk1 = PhysicalASTCBlock(0x000000000000001961ULL);
	for (int i = 0; i < 4; ++i) {
	EXPECT_EQ(blk1.GetEndpointMode(i), ColorEndpointMode::kLDRLumaDirect);
	}

	// Void extent blocks have no endpoint modes
	EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).GetEndpointMode(0));

	// Test out of range partitions
	EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).GetEndpointMode(1));
	EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).GetEndpointMode(-1));
	EXPECT_FALSE(PhysicalASTCBlock(0x0000000001FE000173ULL).GetEndpointMode(100));

	// Error blocks have no endpoint modes
	EXPECT_FALSE(kErrorBlock.GetEndpointMode(0));

	// Test non-shared CEMs
	PhysicalASTCBlock non_shared_cem(0x4000000000800D44ULL);
	EXPECT_EQ(non_shared_cem.GetEndpointMode(0),
	ColorEndpointMode::kLDRLumaDirect);
	EXPECT_EQ(non_shared_cem.GetEndpointMode(1),
	ColorEndpointMode::kLDRLumaBaseOffset);
	}

	// Make sure that if we have more than one partition then we have proper
	// partition IDs (these determine which pixels correspond to which partition)
	TEST(PhysicalASTCBlockTest, TestPartitionID) {
	// Valid partitions
	EXPECT_EQ(PhysicalASTCBlock(0x4000000000FFED44ULL).PartitionID(), 0x3FF);
	EXPECT_EQ(PhysicalASTCBlock(0x4000000000AAAD44ULL).PartitionID(), 0x155);

	// Error blocks have no partition IDs
	EXPECT_FALSE(kErrorBlock.PartitionID());

	// Void extent blocks have no endpoint modes
	EXPECT_FALSE(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).PartitionID());
	}

	// Make sure that we're properly attributing the number of bits associated with
	// the encoded color values.
	TEST(PhysicalASTCBlockTest, TestNumColorBits) {
	// If we're using a direct luma channel, then the number of color bits is 16
	EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).NumColorValues(), 2);
	EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).NumColorBits(), 16);

	// Error blocks have nothing
	EXPECT_FALSE(kErrorBlock.NumColorValues());
	EXPECT_FALSE(kErrorBlock.NumColorBits());

	// Void extent blocks have four color values and 64 bits of color
	EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).NumColorValues(), 4);
	EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).NumColorBits(), 64);
	}

	// Make sure that we're properly decoding the range of values that each of the
	// encoded color values can take
	TEST(PhysicalASTCBlockTest, TestColorValuesRange) {
	// If we're using a direct luma channel, then we use two color values up to
	// a full byte each.
	EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).ColorValuesRange(), 255);

	// Error blocks have nothing
	EXPECT_FALSE(kErrorBlock.ColorValuesRange());

	// Void extent blocks have four color values and 64 bits of color, so the
	// color range for each is sixteen bits.
	EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).ColorValuesRange(),
	(1 << 16) - 1);
	}

	// Test that we know where the color data starts. This is different mostly
	// depending on whether or not the block is single-partition or void extent.
	TEST(PhysicalASTCBlockTest, TestColorStartBits) {
	// Void extent blocks start at bit 64
	EXPECT_EQ(PhysicalASTCBlock(0xFFF8003FFE000DFCULL).ColorStartBit(), 64);

	// Error blocks don't start anywhere
	EXPECT_FALSE(kErrorBlock.ColorStartBit());

	// Single partition blocks start at bit 17
	EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000173ULL).ColorStartBit(), 17);
	EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE0005FFULL).ColorStartBit(), 17);
	EXPECT_EQ(PhysicalASTCBlock(0x0000000001FE000108ULL).ColorStartBit(), 17);

	// Multi-partition blocks start at bit 29
	EXPECT_EQ(PhysicalASTCBlock(0x4000000000FFED44ULL).ColorStartBit(), 29);
	EXPECT_EQ(PhysicalASTCBlock(0x4000000000AAAD44ULL).ColorStartBit(), 29);
	}

	} // namespace