🏡 index : cold-air-networks/mirror-webgpu-cts.git

export const description = `
Execution Tests for the bitwise binary expression operations
`;

import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { assert } from '../../../../../common/util/util.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import {
  abstractIntBits,
  i32Bits,
  ScalarValue,
  scalarType,
  u32Bits,
} from '../../../../util/conversion.js';
import { allInputSources, onlyConstInputSource, run } from '../expression.js';

import { abstractIntBinary, binary, compoundBinary } from './binary.js';

export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);

/**
 * Collection of functions and values required to implement bitwise tests for a
 * specific scalar type
 */
interface ScalarImpl {
  // builder is a mostly a wrapper around type builders like 'i32Bits' that
  // handles the (number|bigint) type check.
  builder: (bits: bigint | number) => ScalarValue;
  size: 32 | 64;
}

const kScalarImpls = {
  i32: {
    builder: (bits: bigint | number): ScalarValue => {
      assert(typeof bits === 'number');
      return i32Bits(bits);
    },
    size: 32,
  } as ScalarImpl,
  u32: {
    builder: (bits: bigint | number): ScalarValue => {
      assert(typeof bits === 'number');
      return u32Bits(bits);
    },
    size: 32,
  } as ScalarImpl,
  'abstract-int': {
    builder: (bits: bigint | number): ScalarValue => {
      assert(typeof bits === 'bigint');
      return abstractIntBits(bits);
    },
    size: 64,
  } as ScalarImpl,
};

/** Wrapper for converting from input type strings to the appropriate implementation */
function scalarImplForInputType(inputType: string): ScalarImpl {
  assert(inputType === 'i32' || inputType === 'u32' || inputType === 'abstract-int');
  return kScalarImpls[inputType];
}

/** Manually calculated bitwise-or cases used a check that the CTS test is correct */
const kBitwiseOrStaticPatterns = {
  32: [
    {
      input: [0b00000000000000000000000000000000, 0b00000000000000000000000000000000],
      expected: 0b00000000000000000000000000000000,
    },
    {
      input: [0b11111111111111111111111111111111, 0b00000000000000000000000000000000],
      expected: 0b11111111111111111111111111111111,
    },
    {
      input: [0b00000000000000000000000000000000, 0b11111111111111111111111111111111],
      expected: 0b11111111111111111111111111111111,
    },
    {
      input: [0b11111111111111111111111111111111, 0b11111111111111111111111111111111],
      expected: 0b11111111111111111111111111111111,
    },
    {
      input: [0b10100100010010100100010010100100, 0b00000000000000000000000000000000],
      expected: 0b10100100010010100100010010100100,
    },
    {
      input: [0b00000000000000000000000000000000, 0b10100100010010100100010010100100],
      expected: 0b10100100010010100100010010100100,
    },
    {
      input: [0b01010010001001010010001001010010, 0b10100100010010100100010010100100],
      expected: 0b11110110011011110110011011110110,
    },
  ],
  64: [
    {
      input: [
        0b0000000000000000000000000000000000000000000000000000000000000000n,
        0b0000000000000000000000000000000000000000000000000000000000000000n,
      ],
      expected: 0b0000000000000000000000000000000000000000000000000000000000000000n,
    },
    {
      input: [
        0b1111111111111111111111111111111111111111111111111111111111111111n,
        0b0000000000000000000000000000000000000000000000000000000000000000n,
      ],
      expected: 0b1111111111111111111111111111111111111111111111111111111111111111n,
    },
    {
      input: [
        0b0000000000000000000000000000000000000000000000000000000000000000n,
        0b1111111111111111111111111111111111111111111111111111111111111111n,
      ],
      expected: 0b1111111111111111111111111111111111111111111111111111111111111111n,
    },
    {
      input: [
        0b1111111111111111111111111111111111111111111111111111111111111111n,
        0b1111111111111111111111111111111111111111111111111111111111111111n,
      ],
      expected: 0b1111111111111111111111111111111111111111111111111111111111111111n,
    },
    {
      input: [
        0b1010010001001010010001001010010010100100010010100100010010100100n,
        0b0000000000000000000000000000000000000000000000000000000000000000n,
      ],
      expected: 0b1010010001001010010001001010010010100100010010100100010010100100n,
    },
    {
      input: [
        0b0000000000000000000000000000000000000000000000000000000000000000n,
        0b1010010001001010010001001010010010100100010010100100010010100100n,
      ],
      expected: 0b1010010001001010010001001010010010100100010010100100010010100100n,
    },
    {
      input: [
        0b0101001000100101001000100101001010100100010010100100010010100100n,
        0b1010010001001010010001001010010010100100010010100100010010100100n,
      ],
      expected: 0b1111011001101111011001101111011010100100010010100100010010100100n,
    },
  ],
};

/** @returns a set of bitwise-or cases for the specific input type */
function makeBitwiseOrCases(inputType: string) {
  const impl = scalarImplForInputType(inputType);
  const indices =
    impl.size === 64 ? [...Array(impl.size).keys()].map(BigInt) : [...Array(impl.size).keys()];

  return [
    ...kBitwiseOrStaticPatterns[impl.size].map(c => {
      return {
        input: c.input.map(impl.builder),
        expected: impl.builder(c.expected),
      };
    }),
    // Permute all combinations of a single bit being set for the LHS and RHS
    ...indices.flatMap(i => {
      const lhs = typeof i === 'bigint' ? 1n << i : 1 << i;
      return indices.map(j => {
        const rhs = typeof j === 'bigint' ? 1n << j : 1 << j;
        assert(typeof lhs === typeof rhs);
        const result = typeof lhs === 'bigint' ? lhs | (rhs as bigint) : lhs | (rhs as number);
        return { input: [impl.builder(lhs), impl.builder(rhs)], expected: impl.builder(result) };
      });
    }),
  ];
}

g.test('bitwise_or')
  .specURL('https://www.w3.org/TR/WGSL/#bit-expr')
  .desc(
    `
e1 | e2: T
T is i32, u32, abstractInt, vecN<i32>, vecN<u32>, or vecN<abstractInt>

Bitwise-or. Component-wise when T is a vector.
`
  )
  .params(u =>
    u
      .combine('type', ['i32', 'u32', 'abstract-int'] as const)
      .combine('inputSource', allInputSources)
      .combine('vectorize', [undefined, 2, 3, 4] as const)
  )
  .fn(async t => {
    t.skipIf(
      t.params.type === 'abstract-int' && !onlyConstInputSource.includes(t.params.inputSource)
    );
    const type = scalarType(t.params.type);
    const cases = makeBitwiseOrCases(t.params.type);
    const builder = t.params.type === 'abstract-int' ? abstractIntBinary('|') : binary('|');
    await run(t, builder, [type, type], type, t.params, cases);
  });

g.test('bitwise_or_compound')
  .specURL('https://www.w3.org/TR/WGSL/#bit-expr')
  .desc(
    `
e1 |= e2: T
T is i32, u32, vecN<i32>, or vecN<u32>

Bitwise-or. Component-wise when T is a vector.
`
  )
  .params(u =>
    u
      .combine('type', ['i32', 'u32'] as const)
      .combine('inputSource', allInputSources)
      .combine('vectorize', [undefined, 2, 3, 4] as const)
  )
  .fn(async t => {
    const type = scalarType(t.params.type);
    const cases = makeBitwiseOrCases(t.params.type);

    await run(t, compoundBinary('|='), [type, type], type, t.params, cases);
  });

/** Manually calculated bitwise-and cases used a check that the CTS test is correct */
const kBitwiseAndStaticPatterns = {
  32: [
    {
      input: [0b00000000000000000000000000000000, 0b00000000000000000000000000000000],
      expected: 0b00000000000000000000000000000000,
    },
    {
      input: [0b11111111111111111111111111111111, 0b00000000000000000000000000000000],
      expected: 0b00000000000000000000000000000000,
    },
    {
      input: [0b00000000000000000000000000000000, 0b11111111111111111111111111111111],
      expected: 0b00000000000000000000000000000000,
    },
    {
      input: [0b11111111111111111111111111111111, 0b11111111111111111111111111111111],
      expected: 0b11111111111111111111111111111111,
    },
    {
      input: [0b10100100010010100100010010100100, 0b00000000000000000000000000000000],
      expected: 0b00000000000000000000000000000000,
    },
    {
      input: [0b10100100010010100100010010100100, 0b11111111111111111111111111111111],
      expected: 0b10100100010010100100010010100100,
    },
    {
      input: [0b00000000000000000000000000000000, 0b10100100010010100100010010100100],
      expected: 0b00000000000000000000000000000000,
    },
    {
      input: [0b11111111111111111111111111111111, 0b10100100010010100100010010100100],
      expected: 0b10100100010010100100010010100100,
    },
    {
      input: [0b01010010001001010010001001010010, 0b01011011101101011011101101011011],
      expected: 0b01010010001001010010001001010010,
    },
  ],
  64: [
    {
      input: [
        0b0000000000000000000000000000000000000000000000000000000000000000n,
        0b0000000000000000000000000000000000000000000000000000000000000000n,
      ],
      expected: 0b0000000000000000000000000000000000000000000000000000000000000000n,
    },
    {
      input: [
        0b1111111111111111111111111111111111111111111111111111111111111111n,
        0b0000000000000000000000000000000000000000000000000000000000000000n,
      ],
      expected: 0b0000000000000000000000000000000000000000000000000000000000000000n,
    },
    {
      input: [
        0b0000000000000000000000000000000000000000000000000000000000000000n,
        0b1111111111111111111111111111111111111111111111111111111111111111n,
      ],
      expected: 0b0000000000000000000000000000000000000000000000000000000000000000n,
    },
    {
      input: [
        0b1111111111111111111111111111111111111111111111111111111111111111n,
        0b1111111111111111111111111111111111111111111111111111111111111111n,
      ],
      expected: 0b1111111111111111111111111111111111111111111111111111111111111111n,
    },
    {
      input: [
        0b1010010001001010010001001010010010100100010010100100010010100100n,
        0b0000000000000000000000000000000000000000000000000000000000000000n,
      ],
      expected: 0b0000000000000000000000000000000000000000000000000000000000000000n,
    },
    {
      input: [
        0b1010010001001010010001001010010010100100010010100100010010100100n,
        0b1111111111111111111111111111111111111111111111111111111111111111n,
      ],
      expected: 0b1010010001001010010001001010010010100100010010100100010010100100n,
    },
    {
      input: [
        0b0000000000000000000000000000000000000000000000000000000000000000n,
        0b1010010001001010010001001010010010100100010010100100010010100100n,
      ],
      expected: 0b0000000000000000000000000000000000000000000000000000000000000000n,
    },
    {
      input: [
        0b1111111111111111111111111111111111111111111111111111111111111111n,
        0b1010010001001010010001001010010010100100010010100100010010100100n,
      ],
      expected: 0b1010010001001010010001001010010010100100010010100100010010100100n,
    },
    {
      input: [
        0b0101001000100101001000100101001001010010001001010010001001010010n,
        0b0101101110110101101110110101101101011011101101011011101101011011n,
      ],
      expected: 0b0101001000100101001000100101001001010010001001010010001001010010n,
    },
  ],
};

/** @returns a set of bitwise-or cases for the specific input type */
function makeBitwiseAndCases(inputType: string) {
  const impl = scalarImplForInputType(inputType);
  const indices =
    impl.size === 64 ? [...Array(impl.size).keys()].map(BigInt) : [...Array(impl.size).keys()];

  return [
    ...kBitwiseAndStaticPatterns[impl.size].map(c => {
      return {
        input: c.input.map(impl.builder),
        expected: impl.builder(c.expected),
      };
    }),
    // Permute all combinations of a single bit being set for the LHS and all but one bit set for the RHS
    ...indices.flatMap(i => {
      const lhs = typeof i === 'bigint' ? 1n << i : 1 << i;
      return indices.map(j => {
        const rhs = typeof j === 'bigint' ? 0xffffffffffffffffn ^ (1n << j) : 0xffffffff ^ (1 << j);
        assert(typeof lhs === typeof rhs);
        const result = typeof lhs === 'bigint' ? lhs & (rhs as bigint) : lhs & (rhs as number);
        return { input: [impl.builder(lhs), impl.builder(rhs)], expected: impl.builder(result) };
      });
    }),
  ];
}

g.test('bitwise_and')
  .specURL('https://www.w3.org/TR/WGSL/#bit-expr')
  .desc(
    `
e1 & e2: T
T is i32, u32, AbstractInt, vecN<i32>, vecN<u32>, or vecN<AbstractInt>

Bitwise-and. Component-wise when T is a vector.
`
  )
  .params(u =>
    u
      .combine('type', ['i32', 'u32', 'abstract-int'] as const)
      .combine('inputSource', allInputSources)
      .combine('vectorize', [undefined, 2, 3, 4] as const)
  )
  .fn(async t => {
    t.skipIf(
      t.params.type === 'abstract-int' && !onlyConstInputSource.includes(t.params.inputSource)
    );
    const type = scalarType(t.params.type);
    const cases = makeBitwiseAndCases(t.params.type);
    const builder = t.params.type === 'abstract-int' ? abstractIntBinary('&') : binary('&');
    await run(t, builder, [type, type], type, t.params, cases);
  });

g.test('bitwise_and_compound')
  .specURL('https://www.w3.org/TR/WGSL/#bit-expr')
  .desc(
    `
e1 &= e2: T
T is i32, u32, vecN<i32>, or vecN<u32>

Bitwise-and. Component-wise when T is a vector.
`
  )
  .params(u =>
    u
      .combine('type', ['i32', 'u32'] as const)
      .combine('inputSource', allInputSources)
      .combine('vectorize', [undefined, 2, 3, 4] as const)
  )
  .fn(async t => {
    const type = scalarType(t.params.type);
    const cases = makeBitwiseAndCases(t.params.type);
    await run(t, compoundBinary('&='), [type, type], type, t.params, cases);
  });

/** Manually calculated bitwise-or cases used a check that the CTS test is correct */
const kBitwiseExclusiveOrStaticPatterns = {
  32: [
    {
      input: [0b00000000000000000000000000000000, 0b00000000000000000000000000000000],
      expected: 0b00000000000000000000000000000000,
    },
    {
      input: [0b11111111111111111111111111111111, 0b00000000000000000000000000000000],
      expected: 0b11111111111111111111111111111111,
    },
    {
      input: [0b00000000000000000000000000000000, 0b11111111111111111111111111111111],
      expected: 0b11111111111111111111111111111111,
    },
    {
      input: [0b11111111111111111111111111111111, 0b11111111111111111111111111111111],
      expected: 0b00000000000000000000000000000000,
    },
    {
      input: [0b10100100010010100100010010100100, 0b00000000000000000000000000000000],
      expected: 0b10100100010010100100010010100100,
    },
    {
      input: [0b10100100010010100100010010100100, 0b11111111111111111111111111111111],
      expected: 0b01011011101101011011101101011011,
    },
    {
      input: [0b00000000000000000000000000000000, 0b10100100010010100100010010100100],
      expected: 0b10100100010010100100010010100100,
    },
    {
      input: [0b11111111111111111111111111111111, 0b10100100010010100100010010100100],
      expected: 0b01011011101101011011101101011011,
    },
    {
      input: [0b01010010001001010010001001010010, 0b01011011101101011011101101011011],
      expected: 0b00001001100100001001100100001001,
    },
  ],
  64: [
    {
      input: [
        0b0000000000000000000000000000000000000000000000000000000000000000n,
        0b0000000000000000000000000000000000000000000000000000000000000000n,
      ],
      expected: 0b0000000000000000000000000000000000000000000000000000000000000000n,
    },
    {
      input: [
        0b1111111111111111111111111111111111111111111111111111111111111111n,
        0b0000000000000000000000000000000000000000000000000000000000000000n,
      ],
      expected: 0b1111111111111111111111111111111111111111111111111111111111111111n,
    },
    {
      input: [
        0b0000000000000000000000000000000000000000000000000000000000000000n,
        0b1111111111111111111111111111111111111111111111111111111111111111n,
      ],
      expected: 0b1111111111111111111111111111111111111111111111111111111111111111n,
    },
    {
      input: [
        0b1111111111111111111111111111111111111111111111111111111111111111n,
        0b1111111111111111111111111111111111111111111111111111111111111111n,
      ],
      expected: 0b0000000000000000000000000000000000000000000000000000000000000000n,
    },
    {
      input: [
        0b1010010001001010010001001010010010100100010010100100010010100100n,
        0b0000000000000000000000000000000000000000000000000000000000000000n,
      ],
      expected: 0b1010010001001010010001001010010010100100010010100100010010100100n,
    },
    {
      input: [
        0b1010010001001010010001001010010010100100010010100100010010100100n,
        0b1111111111111111111111111111111111111111111111111111111111111111n,
      ],
      expected: 0b0101101110110101101110110101101101011011101101011011101101011011n,
    },
    {
      input: [
        0b0000000000000000000000000000000000000000000000000000000000000000n,
        0b1010010001001010010001001010010010100100010010100100010010100100n,
      ],
      expected: 0b1010010001001010010001001010010010100100010010100100010010100100n,
    },
    {
      input: [
        0b1111111111111111111111111111111111111111111111111111111111111111n,
        0b1010010001001010010001001010010010100100010010100100010010100100n,
      ],
      expected: 0b0101101110110101101110110101101101011011101101011011101101011011n,
    },
    {
      input: [
        0b0101001000100101001000100101001001010010001001010010001001010010n,
        0b0101101110110101101110110101101101011011101101011011101101011011n,
      ],
      expected: 0b0000100110010000100110010000100100001001100100001001100100001001n,
    },
  ],
};

/** @returns a set of bitwise-xor cases for the specific input type */
function makeBitwiseExclusiveOrCases(inputType: string) {
  const impl = scalarImplForInputType(inputType);
  const indices =
    impl.size === 64 ? [...Array(impl.size).keys()].map(BigInt) : [...Array(impl.size).keys()];

  return [
    ...kBitwiseExclusiveOrStaticPatterns[impl.size].map(c => {
      return {
        input: c.input.map(impl.builder),
        expected: impl.builder(c.expected),
      };
    }),
    // Permute all combinations of a single bit being set for the LHS and all but one bit set for the RHS
    ...indices.flatMap(i => {
      const lhs = typeof i === 'bigint' ? 1n << i : 1 << i;
      return indices.map(j => {
        const rhs = typeof j === 'bigint' ? 0xffffffffffffffffn ^ (1n << j) : 0xffffffff ^ (1 << j);
        assert(typeof lhs === typeof rhs);
        const result = typeof lhs === 'bigint' ? lhs ^ (rhs as bigint) : lhs ^ (rhs as number);
        return { input: [impl.builder(lhs), impl.builder(rhs)], expected: impl.builder(result) };
      });
    }),
  ];
}

g.test('bitwise_exclusive_or')
  .specURL('https://www.w3.org/TR/WGSL/#bit-expr')
  .desc(
    `
e1 ^ e2: T
T is i32, u32, abstractInt, vecN<i32>, vecN<u32>, or vecN<abstractInt>

Bitwise-exclusive-or. Component-wise when T is a vector.
`
  )
  .params(u =>
    u
      .combine('type', ['i32', 'u32', 'abstract-int'] as const)
      .combine('inputSource', allInputSources)
      .combine('vectorize', [undefined, 2, 3, 4] as const)
  )
  .fn(async t => {
    t.skipIf(
      t.params.type === 'abstract-int' && !onlyConstInputSource.includes(t.params.inputSource)
    );
    const type = scalarType(t.params.type);
    const cases = makeBitwiseExclusiveOrCases(t.params.type);
    const builder = t.params.type === 'abstract-int' ? abstractIntBinary('^') : binary('^');
    await run(t, builder, [type, type], type, t.params, cases);
  });

g.test('bitwise_exclusive_or_compound')
  .specURL('https://www.w3.org/TR/WGSL/#bit-expr')
  .desc(
    `
e1 ^= e2: T
T is i32, u32, vecN<i32>, or vecN<u32>

Bitwise-exclusive-or. Component-wise when T is a vector.
`
  )
  .params(u =>
    u
      .combine('type', ['i32', 'u32'] as const)
      .combine('inputSource', allInputSources)
      .combine('vectorize', [undefined, 2, 3, 4] as const)
  )
  .fn(async t => {
    const type = scalarType(t.params.type);
    const cases = makeBitwiseExclusiveOrCases(t.params.type);
    await run(t, compoundBinary('^='), [type, type], type, t.params, cases);
  });