src/emdawnwebgpu/tests/SpotTests.cpp - dawn - Git at Google


            
            // Copyright 2025 The Dawn & Tint Authors

            
            //

            
            // Redistribution and use in source and binary forms, with or without

            
            // modification, are permitted provided that the following conditions are met:

            
            //

            
            // 1. Redistributions of source code must retain the above copyright notice, this

            
            //    list of conditions and the following disclaimer.

            
            //

            
            // 2. Redistributions in binary form must reproduce the above copyright notice,

            
            //    this list of conditions and the following disclaimer in the documentation

            
            //    and/or other materials provided with the distribution.

            
            //

            
            // 3. Neither the name of the copyright holder nor the names of its

            
            //    contributors may be used to endorse or promote products derived from

            
            //    this software without specific prior written permission.

            
            //

            
            // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

            
            // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

            
            // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

            
            // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

            
            // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

            
            // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

            
            // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

            
            // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

            
            // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

            
            // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


            // One-off "spot"/regression/smoke tests for Emdawnwebgpu.


            #include <dawn/webgpu_cpp_print.h>

            
            #include <emscripten.h>

            
            #include <gmock/gmock.h>

            
            #include <gtest/gtest.h>

            
            #include <webgpu/webgpu_cpp.h>


            #include <array>

            
            #include <string>

            
            #include <utility>


            #include "dawn/utils/WGPUHelpers.h"


            namespace {


            namespace utils = dawn::utils;

            
            using testing::_;

            
            using testing::HasSubstr;


            class SpotTests : public testing::Test {

            
              public:

            
                void SetUp() override {

            
                    static constexpr auto kInstanceFeatures =

            
                        std::array{wgpu::InstanceFeatureName::TimedWaitAny};

            
                    wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = kInstanceFeatures.size(),

            
                                                          .requiredFeatures = kInstanceFeatures.data()};

            
                    mInstance = wgpu::CreateInstance(&instanceDesc);


                    wgpu::Adapter adapter;

            
                    EXPECT_EQ(wgpu::WaitStatus::Success,

            
                              mInstance.WaitAny(mInstance.RequestAdapter(

            
                                                    nullptr, wgpu::CallbackMode::WaitAnyOnly,

            
                                                    [&adapter](wgpu::RequestAdapterStatus, wgpu::Adapter a,

            
                                                               wgpu::StringView) { adapter = std::move(a); }),

            
                                                UINT64_MAX));

            
                    EXPECT_TRUE(adapter);

            
                    wgpu::SupportedFeatures features;

            
                    adapter.GetFeatures(&features);


                    wgpu::DeviceDescriptor deviceDesc;

            
                    // Enable all available features

            
                    deviceDesc.requiredFeatureCount = features.featureCount;

            
                    deviceDesc.requiredFeatures = features.features;

            
                    wgpu::Device device;

            
                    EXPECT_EQ(wgpu::WaitStatus::Success,

            
                              mInstance.WaitAny(

            
                                  adapter.RequestDevice(&deviceDesc, wgpu::CallbackMode::WaitAnyOnly,

            
                                                        [&device](wgpu::RequestDeviceStatus, wgpu::Device d,

            
                                                                  wgpu::StringView) { device = std::move(d); }),

            
                                  UINT64_MAX));

            
                    EXPECT_TRUE(device);

            
                    this->mAdapter = adapter;

            
                    this->mDevice = device;

            
                }


              protected:

            
                wgpu::Instance mInstance;

            
                wgpu::Adapter mAdapter;

            
                wgpu::Device mDevice;

            
            };


            TEST_F(SpotTests, QuerySet) {

            
                // Spot test wgpuQuerySetGetType which uses indexOf on an int-to-string table.

            
                wgpu::QuerySetDescriptor querySetDesc{.type = wgpu::QueryType::Timestamp, .count = 1};

            
                wgpu::QuerySet querySet = mDevice.CreateQuerySet(&querySetDesc);

            
                EXPECT_TRUE(querySet);

            
                EXPECT_EQ(querySet.GetType(), querySetDesc.type);

            
            }


            TEST_F(SpotTests, BufferGetMapState) {

            
                // Spot test one of the string-to-int tables (Int_BufferMapState) to make sure

            
                // that Closure's minification didn't minify its keys.

            
                wgpu::BufferDescriptor bufferDesc{.usage = wgpu::BufferUsage::CopyDst, .size = 4};

            
                wgpu::Buffer buffer = mDevice.CreateBuffer(&bufferDesc);

            
                EXPECT_EQ(buffer.GetMapState(), wgpu::BufferMapState::Unmapped);

            
            }


            TEST_F(SpotTests, GetCompilationInfo) {

            
                for (bool valid : {true, false}) {

            
                    wgpu::ShaderSourceWGSL wgslDesc{};

            
                    wgslDesc.code = valid ? "" : "some invalid code";


                    wgpu::ShaderModuleDescriptor descriptor{};

            
                    descriptor.nextInChain = &wgslDesc;

            
                    auto sm = mDevice.CreateShaderModule(&descriptor);

            
                    auto future = sm.GetCompilationInfo(

            
                        wgpu::CallbackMode::WaitAnyOnly,

            
                        [](wgpu::CompilationInfoRequestStatus, const wgpu::CompilationInfo* compilationInfo) {

            
                            // We shouldn't have tried to allocate stuff if there were no messages.

            
                            EXPECT_EQ(compilationInfo->messageCount == 0, compilationInfo->messages == nullptr);


                            // After this, any compilation info will be freed. (There was a bug here which

            
                            // this test catches, but only in ASAN builds.)

            
                        });

            
                    EXPECT_EQ(wgpu::WaitStatus::Success, mInstance.WaitAny(future, UINT64_MAX));

            
                }

            
            }


            TEST_F(SpotTests, ExternalRefCount) {

            
                wgpu::BufferDescriptor bufferDesc{

            
                    .usage = wgpu::BufferUsage::MapRead, .size = 16, .mappedAtCreation = true};


                wgpu::Buffer buffer = mDevice.CreateBuffer(&bufferDesc);

            
                ASSERT_TRUE(buffer);

            
                EXPECT_EQ(buffer.GetMapState(), wgpu::BufferMapState::Mapped);

            
                {

            
                    // Add and then release an extra external ref.

            
                    wgpu::Buffer tmp = buffer;

            
                }


                // Make sure the device wasn't implicitly destroyed (because we thought

            
                // the last external ref was dropped).

            
                EXPECT_EQ(buffer.GetMapState(), wgpu::BufferMapState::Mapped);

            
            }


            TEST_F(SpotTests, InvalidComponentSwizzle) {

            
                wgpu::TextureDescriptor textureDesc = {};

            
                textureDesc.size = {1, 1, 0};

            
                textureDesc.usage = wgpu::TextureUsage::TextureBinding;

            
                textureDesc.format = wgpu::TextureFormat::RGBA8Unorm;

            
                wgpu::Texture texture = mDevice.CreateTexture(&textureDesc);


                wgpu::TextureViewDescriptor viewDesc = {};

            
                wgpu::TextureComponentSwizzleDescriptor swizzleDesc = {};

            
                // An invalid ComponentSwizzle value doesn't crash.

            
                swizzleDesc.swizzle.r = static_cast<wgpu::ComponentSwizzle>(-1);

            
                viewDesc.nextInChain = &swizzleDesc;

            
                wgpu::TextureView view = texture.CreateView(&viewDesc);

            
                ASSERT_TRUE(view);

            
            }


            template <typename T>

            
            void TestGetFeatures(T o) {  // o is either wgpu::Adapter or wgpu::Device.

            
                wgpu::SupportedFeatures f;

            
                o.GetFeatures(&f);

            
                auto features = std::span(f.features, f.featureCount);

            
                for (auto feature : features) {

            
                    // GetFeatures should filter out any unknown features.

            
                    EXPECT_NE(feature, wgpu::FeatureName{0});

            
                    EXPECT_TRUE(o.HasFeature(feature));

            
                }


                // Test some specific features to make sure minification worked.

            
                bool haveCompressedTexture = false;

            
                if (EM_ASM_INT(

            
                        { return WebGPU.getJsObject($0).features.has('texture-compression-bc'); }, o.Get())) {

            
                    auto feature = wgpu::FeatureName::TextureCompressionBC;

            
                    EXPECT_NE(std::find(features.begin(), features.end(), feature), features.end());

            
                    EXPECT_TRUE(o.HasFeature(feature));

            
                    haveCompressedTexture = true;

            
                }

            
                if (EM_ASM_INT(

            
                        { return WebGPU.getJsObject($0).features.has('texture-compression-etc2'); }, o.Get())) {

            
                    auto feature = wgpu::FeatureName::TextureCompressionETC2;

            
                    EXPECT_NE(std::find(features.begin(), features.end(), feature), features.end());

            
                    EXPECT_TRUE(o.HasFeature(feature));

            
                    haveCompressedTexture = true;

            
                }

            
                EXPECT_TRUE(haveCompressedTexture);


                // "subgroups" is a valid JS identifier (no hyphens), so it's

            
                // vulnerable to Closure minification.

            
                if (EM_ASM_INT({ return WebGPU.getJsObject($0).features.has('subgroups'); }, o.Get())) {

            
                    auto feature = wgpu::FeatureName::Subgroups;

            
                    EXPECT_NE(std::find(features.begin(), features.end(), feature), features.end());

            
                    EXPECT_TRUE(o.HasFeature(feature));

            
                }

            
            }


            // Test GetFeatures and HasFeature enum lookups.

            
            TEST_F(SpotTests, GetFeatures) {

            
                TestGetFeatures(mAdapter);

            
                TestGetFeatures(mDevice);

            
            }


            TEST_F(SpotTests, GetWGSLLanguageFeatures) {

            
                wgpu::SupportedWGSLLanguageFeatures f;

            
                mInstance.GetWGSLLanguageFeatures(&f);

            
                auto features = std::span(f.features, f.featureCount);

            
                for (auto feature : features) {

            
                    // GetWGSLLanguageFeatures should filter out any unknown features.

            
                    EXPECT_NE(feature, wgpu::WGSLLanguageFeatureName{0});

            
                    EXPECT_TRUE(mInstance.HasWGSLLanguageFeature(feature));

            
                }


                // Test a specific feature to make sure minification worked.

            
                // WGSL feature names are valid JS identifiers (they use underscores instead

            
                // of hyphens), so they're vulnerable to Closure minification.

            
                if (EM_ASM_INT({

            
                        return navigator.gpu.wgslLanguageFeatures.has('unrestricted_pointer_parameters');

            
                    })) {

            
                    auto feature = wgpu::WGSLLanguageFeatureName::UnrestrictedPointerParameters;

            
                    EXPECT_NE(std::find(features.begin(), features.end(), feature), features.end());

            
                    EXPECT_TRUE(mInstance.HasWGSLLanguageFeature(feature));

            
                }

            
            }


            TEST_F(SpotTests, ImportExternalTexture) {

            
                auto cExternalTexture = static_cast<WGPUExternalTexture>(EM_ASM_PTR(

            
                    {

            
                        const cDevice = $0;

            
                        const device = WebGPU.getJsObject(cDevice);


                        const cvs = document.createElement('canvas');

            
                        cvs.width = 1;

            
                        cvs.height = 1;

            
                        const ctx = cvs.getContext('2d');

            
                        ctx.fillStyle = '#0f0';

            
                        ctx.fillRect(0, 0, 1, 1);

            
                        window.myVideoFrame = new VideoFrame(cvs, {timestamp : 0});


                        const jsExternalTexture = device.importExternalTexture({source : window.myVideoFrame});

            
                        const cExternalTexture = WebGPU.importJsExternalTexture(jsExternalTexture);

            
                        return cExternalTexture;

            
                    },

            
                    mDevice.Get()));

            
                auto externalTexture = wgpu::ExternalTexture::Acquire(cExternalTexture);


                wgpu::BufferDescriptor bufferDesc{

            
                    .usage = wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc,

            
                    .size = sizeof(uint32_t),

            
                };

            
                auto buffer = mDevice.CreateBuffer(&bufferDesc);


                wgpu::BufferDescriptor readbackDesc{

            
                    .usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::MapRead,

            
                    .size = sizeof(uint32_t),

            
                };

            
                auto readback = mDevice.CreateBuffer(&readbackDesc);


                wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout(

            
                    mDevice, {{0, wgpu::ShaderStage::Compute, &utils::kExternalTextureBindingLayout},

            
                              {1, wgpu::ShaderStage::Compute, wgpu::BufferBindingType::Storage}});

            
                wgpu::BindGroup bg = utils::MakeBindGroup(mDevice, bgl, {{0, externalTexture}, {1, buffer}});


                auto module = utils::CreateShaderModule(mDevice, R"(

            
                    @group(0) @binding(0) var t: texture_external;

            
                    @group(0) @binding(1) var<storage, read_write> b: u32;


                    @compute @workgroup_size(1) fn main() {

            
                        b = pack4x8unorm(textureLoad(t, vec2u(0, 0)));

            
                    })");


                wgpu::ComputePipelineDescriptor pipelineDesc{

            
                    .layout = utils::MakeBasicPipelineLayout(mDevice, &bgl),

            
                    .compute = {.module = module},

            
                };

            
                auto pipeline = mDevice.CreateComputePipeline(&pipelineDesc);


                auto encoder = mDevice.CreateCommandEncoder();

            
                {

            
                    auto pass = encoder.BeginComputePass();

            
                    pass.SetBindGroup(0, bg);

            
                    pass.SetPipeline(pipeline);

            
                    pass.DispatchWorkgroups(1);

            
                    pass.End();

            
                }

            
                encoder.CopyBufferToBuffer(buffer, 0, readback, 0, sizeof(uint32_t));

            
                auto commandBuffer = encoder.Finish();

            
                mDevice.GetQueue().Submit(1, &commandBuffer);


                // Note we can't (yet) use EXPECT_BUFFER_U32_EQ here.

            
                uint32_t result = 0;

            
                mInstance.WaitAny(

            
                    readback.MapAsync(

            
                        wgpu::MapMode::Read, 0, wgpu::kWholeMapSize, wgpu::CallbackMode::WaitAnyOnly,

            
                        [&](wgpu::MapAsyncStatus, wgpu::StringView) {

            
                            result = static_cast<const uint32_t*>(readback.GetConstMappedRange())[0];

            
                            readback.Unmap();

            
                        }),

            
                    UINT64_MAX);

            
                EXPECT_EQ(result, uint32_t(0xff00ff00));  // ABGR


                EM_ASM({

            
                    // VideoFrames should always be closed manually.

            
                    window.myVideoFrame.close();

            
                    delete window.myVideoFrame;

            
                });

            
            }


            }  // namespace
	// Copyright 2025 The Dawn & Tint Authors
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice, this
	// list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation
	// and/or other materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	// One-off "spot"/regression/smoke tests for Emdawnwebgpu.

	#include <dawn/webgpu_cpp_print.h>
	#include <emscripten.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>
	#include <webgpu/webgpu_cpp.h>

	#include <array>
	#include <string>
	#include <utility>

	#include "dawn/utils/WGPUHelpers.h"

	namespace {

	namespace utils = dawn::utils;
	using testing::_;
	using testing::HasSubstr;

	class SpotTests : public testing::Test {
	public:
	void SetUp() override {
	static constexpr auto kInstanceFeatures =
	std::array{wgpu::InstanceFeatureName::TimedWaitAny};
	wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = kInstanceFeatures.size(),
	.requiredFeatures = kInstanceFeatures.data()};
	mInstance = wgpu::CreateInstance(&instanceDesc);

	wgpu::Adapter adapter;
	EXPECT_EQ(wgpu::WaitStatus::Success,
	mInstance.WaitAny(mInstance.RequestAdapter(
	nullptr, wgpu::CallbackMode::WaitAnyOnly,
	[&adapter](wgpu::RequestAdapterStatus, wgpu::Adapter a,
	wgpu::StringView) { adapter = std::move(a); }),
	UINT64_MAX));
	EXPECT_TRUE(adapter);
	wgpu::SupportedFeatures features;
	adapter.GetFeatures(&features);

	wgpu::DeviceDescriptor deviceDesc;
	// Enable all available features
	deviceDesc.requiredFeatureCount = features.featureCount;
	deviceDesc.requiredFeatures = features.features;
	wgpu::Device device;
	EXPECT_EQ(wgpu::WaitStatus::Success,
	mInstance.WaitAny(
	adapter.RequestDevice(&deviceDesc, wgpu::CallbackMode::WaitAnyOnly,
	[&device](wgpu::RequestDeviceStatus, wgpu::Device d,
	wgpu::StringView) { device = std::move(d); }),
	UINT64_MAX));
	EXPECT_TRUE(device);
	this->mAdapter = adapter;
	this->mDevice = device;
	}

	protected:
	wgpu::Instance mInstance;
	wgpu::Adapter mAdapter;
	wgpu::Device mDevice;
	};

	TEST_F(SpotTests, QuerySet) {
	// Spot test wgpuQuerySetGetType which uses indexOf on an int-to-string table.
	wgpu::QuerySetDescriptor querySetDesc{.type = wgpu::QueryType::Timestamp, .count = 1};
	wgpu::QuerySet querySet = mDevice.CreateQuerySet(&querySetDesc);
	EXPECT_TRUE(querySet);
	EXPECT_EQ(querySet.GetType(), querySetDesc.type);
	}

	TEST_F(SpotTests, BufferGetMapState) {
	// Spot test one of the string-to-int tables (Int_BufferMapState) to make sure
	// that Closure's minification didn't minify its keys.
	wgpu::BufferDescriptor bufferDesc{.usage = wgpu::BufferUsage::CopyDst, .size = 4};
	wgpu::Buffer buffer = mDevice.CreateBuffer(&bufferDesc);
	EXPECT_EQ(buffer.GetMapState(), wgpu::BufferMapState::Unmapped);
	}

	TEST_F(SpotTests, GetCompilationInfo) {
	for (bool valid : {true, false}) {
	wgpu::ShaderSourceWGSL wgslDesc{};
	wgslDesc.code = valid ? "" : "some invalid code";

	wgpu::ShaderModuleDescriptor descriptor{};
	descriptor.nextInChain = &wgslDesc;
	auto sm = mDevice.CreateShaderModule(&descriptor);
	auto future = sm.GetCompilationInfo(
	wgpu::CallbackMode::WaitAnyOnly,
	[](wgpu::CompilationInfoRequestStatus, const wgpu::CompilationInfo* compilationInfo) {
	// We shouldn't have tried to allocate stuff if there were no messages.
	EXPECT_EQ(compilationInfo->messageCount == 0, compilationInfo->messages == nullptr);

	// After this, any compilation info will be freed. (There was a bug here which
	// this test catches, but only in ASAN builds.)
	});
	EXPECT_EQ(wgpu::WaitStatus::Success, mInstance.WaitAny(future, UINT64_MAX));
	}
	}

	TEST_F(SpotTests, ExternalRefCount) {
	wgpu::BufferDescriptor bufferDesc{
	.usage = wgpu::BufferUsage::MapRead, .size = 16, .mappedAtCreation = true};

	wgpu::Buffer buffer = mDevice.CreateBuffer(&bufferDesc);
	ASSERT_TRUE(buffer);
	EXPECT_EQ(buffer.GetMapState(), wgpu::BufferMapState::Mapped);
	{
	// Add and then release an extra external ref.
	wgpu::Buffer tmp = buffer;
	}

	// Make sure the device wasn't implicitly destroyed (because we thought
	// the last external ref was dropped).
	EXPECT_EQ(buffer.GetMapState(), wgpu::BufferMapState::Mapped);
	}

	TEST_F(SpotTests, InvalidComponentSwizzle) {
	wgpu::TextureDescriptor textureDesc = {};
	textureDesc.size = {1, 1, 0};
	textureDesc.usage = wgpu::TextureUsage::TextureBinding;
	textureDesc.format = wgpu::TextureFormat::RGBA8Unorm;
	wgpu::Texture texture = mDevice.CreateTexture(&textureDesc);

	wgpu::TextureViewDescriptor viewDesc = {};
	wgpu::TextureComponentSwizzleDescriptor swizzleDesc = {};
	// An invalid ComponentSwizzle value doesn't crash.
	swizzleDesc.swizzle.r = static_cast<wgpu::ComponentSwizzle>(-1);
	viewDesc.nextInChain = &swizzleDesc;
	wgpu::TextureView view = texture.CreateView(&viewDesc);
	ASSERT_TRUE(view);
	}

	template <typename T>
	void TestGetFeatures(T o) { // o is either wgpu::Adapter or wgpu::Device.
	wgpu::SupportedFeatures f;
	o.GetFeatures(&f);
	auto features = std::span(f.features, f.featureCount);
	for (auto feature : features) {
	// GetFeatures should filter out any unknown features.
	EXPECT_NE(feature, wgpu::FeatureName{0});
	EXPECT_TRUE(o.HasFeature(feature));
	}

	// Test some specific features to make sure minification worked.
	bool haveCompressedTexture = false;
	if (EM_ASM_INT(
	{ return WebGPU.getJsObject($0).features.has('texture-compression-bc'); }, o.Get())) {
	auto feature = wgpu::FeatureName::TextureCompressionBC;
	EXPECT_NE(std::find(features.begin(), features.end(), feature), features.end());
	EXPECT_TRUE(o.HasFeature(feature));
	haveCompressedTexture = true;
	}
	if (EM_ASM_INT(
	{ return WebGPU.getJsObject($0).features.has('texture-compression-etc2'); }, o.Get())) {
	auto feature = wgpu::FeatureName::TextureCompressionETC2;
	EXPECT_NE(std::find(features.begin(), features.end(), feature), features.end());
	EXPECT_TRUE(o.HasFeature(feature));
	haveCompressedTexture = true;
	}
	EXPECT_TRUE(haveCompressedTexture);

	// "subgroups" is a valid JS identifier (no hyphens), so it's
	// vulnerable to Closure minification.
	if (EM_ASM_INT({ return WebGPU.getJsObject($0).features.has('subgroups'); }, o.Get())) {
	auto feature = wgpu::FeatureName::Subgroups;
	EXPECT_NE(std::find(features.begin(), features.end(), feature), features.end());
	EXPECT_TRUE(o.HasFeature(feature));
	}
	}

	// Test GetFeatures and HasFeature enum lookups.
	TEST_F(SpotTests, GetFeatures) {
	TestGetFeatures(mAdapter);
	TestGetFeatures(mDevice);
	}

	TEST_F(SpotTests, GetWGSLLanguageFeatures) {
	wgpu::SupportedWGSLLanguageFeatures f;
	mInstance.GetWGSLLanguageFeatures(&f);
	auto features = std::span(f.features, f.featureCount);
	for (auto feature : features) {
	// GetWGSLLanguageFeatures should filter out any unknown features.
	EXPECT_NE(feature, wgpu::WGSLLanguageFeatureName{0});
	EXPECT_TRUE(mInstance.HasWGSLLanguageFeature(feature));
	}

	// Test a specific feature to make sure minification worked.
	// WGSL feature names are valid JS identifiers (they use underscores instead
	// of hyphens), so they're vulnerable to Closure minification.
	if (EM_ASM_INT({
	return navigator.gpu.wgslLanguageFeatures.has('unrestricted_pointer_parameters');
	})) {
	auto feature = wgpu::WGSLLanguageFeatureName::UnrestrictedPointerParameters;
	EXPECT_NE(std::find(features.begin(), features.end(), feature), features.end());
	EXPECT_TRUE(mInstance.HasWGSLLanguageFeature(feature));
	}
	}

	TEST_F(SpotTests, ImportExternalTexture) {
	auto cExternalTexture = static_cast<WGPUExternalTexture>(EM_ASM_PTR(
	{
	const cDevice = $0;
	const device = WebGPU.getJsObject(cDevice);

	const cvs = document.createElement('canvas');
	cvs.width = 1;
	cvs.height = 1;
	const ctx = cvs.getContext('2d');
	ctx.fillStyle = '#0f0';
	ctx.fillRect(0, 0, 1, 1);
	window.myVideoFrame = new VideoFrame(cvs, {timestamp : 0});

	const jsExternalTexture = device.importExternalTexture({source : window.myVideoFrame});
	const cExternalTexture = WebGPU.importJsExternalTexture(jsExternalTexture);
	return cExternalTexture;
	},
	mDevice.Get()));
	auto externalTexture = wgpu::ExternalTexture::Acquire(cExternalTexture);

	wgpu::BufferDescriptor bufferDesc{
	.usage = wgpu::BufferUsage::Storage \| wgpu::BufferUsage::CopySrc,
	.size = sizeof(uint32_t),
	};
	auto buffer = mDevice.CreateBuffer(&bufferDesc);

	wgpu::BufferDescriptor readbackDesc{
	.usage = wgpu::BufferUsage::CopyDst \| wgpu::BufferUsage::MapRead,
	.size = sizeof(uint32_t),
	};
	auto readback = mDevice.CreateBuffer(&readbackDesc);

	wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout(
	mDevice, {{0, wgpu::ShaderStage::Compute, &utils::kExternalTextureBindingLayout},
	{1, wgpu::ShaderStage::Compute, wgpu::BufferBindingType::Storage}});
	wgpu::BindGroup bg = utils::MakeBindGroup(mDevice, bgl, {{0, externalTexture}, {1, buffer}});

	auto module = utils::CreateShaderModule(mDevice, R"(
	@group(0) @binding(0) var t: texture_external;
	@group(0) @binding(1) var<storage, read_write> b: u32;

	@compute @workgroup_size(1) fn main() {
	b = pack4x8unorm(textureLoad(t, vec2u(0, 0)));
	})");

	wgpu::ComputePipelineDescriptor pipelineDesc{
	.layout = utils::MakeBasicPipelineLayout(mDevice, &bgl),
	.compute = {.module = module},
	};
	auto pipeline = mDevice.CreateComputePipeline(&pipelineDesc);

	auto encoder = mDevice.CreateCommandEncoder();
	{
	auto pass = encoder.BeginComputePass();
	pass.SetBindGroup(0, bg);
	pass.SetPipeline(pipeline);
	pass.DispatchWorkgroups(1);
	pass.End();
	}
	encoder.CopyBufferToBuffer(buffer, 0, readback, 0, sizeof(uint32_t));
	auto commandBuffer = encoder.Finish();
	mDevice.GetQueue().Submit(1, &commandBuffer);

	// Note we can't (yet) use EXPECT_BUFFER_U32_EQ here.
	uint32_t result = 0;
	mInstance.WaitAny(
	readback.MapAsync(
	wgpu::MapMode::Read, 0, wgpu::kWholeMapSize, wgpu::CallbackMode::WaitAnyOnly,
	[&](wgpu::MapAsyncStatus, wgpu::StringView) {
	result = static_cast<const uint32_t*>(readback.GetConstMappedRange())[0];
	readback.Unmap();
	}),
	UINT64_MAX);
	EXPECT_EQ(result, uint32_t(0xff00ff00)); // ABGR

	EM_ASM({
	// VideoFrames should always be closed manually.
	window.myVideoFrame.close();
	delete window.myVideoFrame;
	});
	}

	} // namespace