summaryrefslogtreecommitdiffstats
path: root/dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts
diff options
context:
space:
mode:
Diffstat (limited to 'dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts')
-rw-r--r--dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts241
1 files changed, 241 insertions, 0 deletions
diff --git a/dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts b/dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts
new file mode 100644
index 0000000000..13cddf6403
--- /dev/null
+++ b/dom/webgpu/tests/cts/checkout/src/webgpu/shader/execution/expression/call/builtin/distance.spec.ts
@@ -0,0 +1,241 @@
+export const description = `
+Execution tests for the 'distance' builtin function
+
+S is AbstractFloat, f32, f16
+T is S or vecN<S>
+@const fn distance(e1: T ,e2: T ) -> f32
+Returns the distance between e1 and e2 (e.g. length(e1-e2)).
+
+`;
+
+import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
+import { GPUTest } from '../../../../../gpu_test.js';
+import { TypeF32, TypeF16, TypeVec } from '../../../../../util/conversion.js';
+import { FP } from '../../../../../util/floating_point.js';
+import {
+ fullF32Range,
+ fullF16Range,
+ sparseVectorF32Range,
+ sparseVectorF16Range,
+} from '../../../../../util/math.js';
+import { makeCaseCache } from '../../case_cache.js';
+import { allInputSources, run } from '../../expression.js';
+
+import { builtin } from './builtin.js';
+
+export const g = makeTestGroup(GPUTest);
+
+// Cases: f32_vecN_[non_]const
+const f32_vec_cases = ([2, 3, 4] as const)
+ .flatMap(n =>
+ ([true, false] as const).map(nonConst => ({
+ [`f32_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+ return FP.f32.generateVectorPairToIntervalCases(
+ sparseVectorF32Range(n),
+ sparseVectorF32Range(n),
+ nonConst ? 'unfiltered' : 'finite',
+ FP.f32.distanceInterval
+ );
+ },
+ }))
+ )
+ .reduce((a, b) => ({ ...a, ...b }), {});
+
+// Cases: f16_vecN_[non_]const
+const f16_vec_cases = ([2, 3, 4] as const)
+ .flatMap(n =>
+ ([true, false] as const).map(nonConst => ({
+ [`f16_vec${n}_${nonConst ? 'non_const' : 'const'}`]: () => {
+ return FP.f16.generateVectorPairToIntervalCases(
+ sparseVectorF16Range(n),
+ sparseVectorF16Range(n),
+ nonConst ? 'unfiltered' : 'finite',
+ FP.f16.distanceInterval
+ );
+ },
+ }))
+ )
+ .reduce((a, b) => ({ ...a, ...b }), {});
+
+export const d = makeCaseCache('distance', {
+ f32_const: () => {
+ return FP.f32.generateScalarPairToIntervalCases(
+ fullF32Range(),
+ fullF32Range(),
+ 'finite',
+ FP.f32.distanceInterval
+ );
+ },
+ f32_non_const: () => {
+ return FP.f32.generateScalarPairToIntervalCases(
+ fullF32Range(),
+ fullF32Range(),
+ 'unfiltered',
+ FP.f32.distanceInterval
+ );
+ },
+ ...f32_vec_cases,
+ f16_const: () => {
+ return FP.f16.generateScalarPairToIntervalCases(
+ fullF16Range(),
+ fullF16Range(),
+ 'finite',
+ FP.f16.distanceInterval
+ );
+ },
+ f16_non_const: () => {
+ return FP.f16.generateScalarPairToIntervalCases(
+ fullF16Range(),
+ fullF16Range(),
+ 'unfiltered',
+ FP.f16.distanceInterval
+ );
+ },
+ ...f16_vec_cases,
+});
+
+g.test('abstract_float')
+ .specURL('https://www.w3.org/TR/WGSL/#float-builtin-functions')
+ .desc(`abstract float tests`)
+ .params(u =>
+ u.combine('inputSource', allInputSources).combine('vectorize', [undefined, 2, 3, 4] as const)
+ )
+ .unimplemented();
+
+g.test('f32')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`f32 tests`)
+ .params(u => u.combine('inputSource', allInputSources))
+ .fn(async t => {
+ const cases = await d.get(t.params.inputSource === 'const' ? 'f32_const' : 'f32_non_const');
+ await run(t, builtin('distance'), [TypeF32, TypeF32], TypeF32, t.params, cases);
+ });
+
+g.test('f32_vec2')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`f32 tests using vec2s`)
+ .params(u => u.combine('inputSource', allInputSources))
+ .fn(async t => {
+ const cases = await d.get(
+ t.params.inputSource === 'const' ? 'f32_vec2_const' : 'f32_vec2_non_const'
+ );
+ await run(
+ t,
+ builtin('distance'),
+ [TypeVec(2, TypeF32), TypeVec(2, TypeF32)],
+ TypeF32,
+ t.params,
+ cases
+ );
+ });
+
+g.test('f32_vec3')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`f32 tests using vec3s`)
+ .params(u => u.combine('inputSource', allInputSources))
+ .fn(async t => {
+ const cases = await d.get(
+ t.params.inputSource === 'const' ? 'f32_vec3_const' : 'f32_vec3_non_const'
+ );
+ await run(
+ t,
+ builtin('distance'),
+ [TypeVec(3, TypeF32), TypeVec(3, TypeF32)],
+ TypeF32,
+ t.params,
+ cases
+ );
+ });
+
+g.test('f32_vec4')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`f32 tests using vec4s`)
+ .params(u => u.combine('inputSource', allInputSources))
+ .fn(async t => {
+ const cases = await d.get(
+ t.params.inputSource === 'const' ? 'f32_vec4_const' : 'f32_vec4_non_const'
+ );
+ await run(
+ t,
+ builtin('distance'),
+ [TypeVec(4, TypeF32), TypeVec(4, TypeF32)],
+ TypeF32,
+ t.params,
+ cases
+ );
+ });
+
+g.test('f16')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`f16 tests`)
+ .params(u => u.combine('inputSource', allInputSources))
+ .beforeAllSubcases(t => {
+ t.selectDeviceOrSkipTestCase('shader-f16');
+ })
+ .fn(async t => {
+ const cases = await d.get(t.params.inputSource === 'const' ? 'f16_const' : 'f16_non_const');
+ await run(t, builtin('distance'), [TypeF16, TypeF16], TypeF16, t.params, cases);
+ });
+
+g.test('f16_vec2')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`f16 tests using vec2s`)
+ .params(u => u.combine('inputSource', allInputSources))
+ .beforeAllSubcases(t => {
+ t.selectDeviceOrSkipTestCase('shader-f16');
+ })
+ .fn(async t => {
+ const cases = await d.get(
+ t.params.inputSource === 'const' ? 'f16_vec2_const' : 'f16_vec2_non_const'
+ );
+ await run(
+ t,
+ builtin('distance'),
+ [TypeVec(2, TypeF16), TypeVec(2, TypeF16)],
+ TypeF16,
+ t.params,
+ cases
+ );
+ });
+
+g.test('f16_vec3')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`f16 tests using vec3s`)
+ .params(u => u.combine('inputSource', allInputSources))
+ .beforeAllSubcases(t => {
+ t.selectDeviceOrSkipTestCase('shader-f16');
+ })
+ .fn(async t => {
+ const cases = await d.get(
+ t.params.inputSource === 'const' ? 'f16_vec3_const' : 'f16_vec3_non_const'
+ );
+ await run(
+ t,
+ builtin('distance'),
+ [TypeVec(3, TypeF16), TypeVec(3, TypeF16)],
+ TypeF16,
+ t.params,
+ cases
+ );
+ });
+
+g.test('f16_vec4')
+ .specURL('https://www.w3.org/TR/WGSL/#numeric-builtin-functions')
+ .desc(`f16 tests using vec4s`)
+ .params(u => u.combine('inputSource', allInputSources))
+ .beforeAllSubcases(t => {
+ t.selectDeviceOrSkipTestCase('shader-f16');
+ })
+ .fn(async t => {
+ const cases = await d.get(
+ t.params.inputSource === 'const' ? 'f16_vec4_const' : 'f16_vec4_non_const'
+ );
+ await run(
+ t,
+ builtin('distance'),
+ [TypeVec(4, TypeF16), TypeVec(4, TypeF16)],
+ TypeF16,
+ t.params,
+ cases
+ );
+ });
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-17 07:24:01 +0000