diff --git a/src/common/runtime/cmdline.ts b/src/common/runtime/cmdline.ts
index c071cd54aa88..30c68623bf52 100644
--- a/src/common/runtime/cmdline.ts
+++ b/src/common/runtime/cmdline.ts
@@ -27,12 +27,16 @@ Options:
   --coverage                Emit coverage data.
   --verbose                 Print result/log of every test as it runs.
   --list                    Print all testcase names that match the given query and exit.
+  --list-unimplemented      Print all unimplemented tests
   --debug                   Include debug messages in logging.
   --print-json              Print the complete result JSON in the output.
   --expectations            Path to expectations file.
   --gpu-provider            Path to node module that provides the GPU implementation.
   --gpu-provider-flag       Flag to set on the gpu-provider as <flag>=<value>
   --unroll-const-eval-loops Unrolls loops in constant-evaluation shader execution tests
+  --enforce-default-limits  Enforce the default limits (note: powerPreference tests may fail)
+  --force-fallback-adapter  Force a fallback adapter
+  --log-to-websocket        Log to a websocket
   --quiet                   Suppress summary information in output
 `);
   return sys.exit(rc);
diff --git a/src/common/runtime/server.ts b/src/common/runtime/server.ts
index 783d7244d4f6..030921181299 100644
--- a/src/common/runtime/server.ts
+++ b/src/common/runtime/server.ts
@@ -31,6 +31,9 @@ Options:
   --gpu-provider            Path to node module that provides the GPU implementation.
   --gpu-provider-flag       Flag to set on the gpu-provider as <flag>=<value>
   --unroll-const-eval-loops Unrolls loops in constant-evaluation shader execution tests
+  --enforce-default-limits  Enforce the default limits (note: powerPreference tests may fail)
+  --force-fallback-adapter  Force a fallback adapter
+  --log-to-websocket        Log to a websocket
   --u                       Flag to set on the gpu-provider as <flag>=<value>
 
 Provides an HTTP server used for running tests via an HTTP RPC interface
diff --git a/src/common/runtime/standalone.ts b/src/common/runtime/standalone.ts
index 3f7333c1eb35..aefcc2946cc4 100644
--- a/src/common/runtime/standalone.ts
+++ b/src/common/runtime/standalone.ts
@@ -633,17 +633,21 @@ void (async () => {
       return select;
     };
 
-    for (const [optionName, info] of Object.entries(optionsInfos)) {
+    Object.entries(optionsInfos).forEach(([optionName, info], i) => {
+      const id = `option${i}`;
       const input =
         typeof optionValues[optionName] === 'boolean'
           ? createCheckbox(optionName)
           : createSelect(optionName, info);
+      input.attr('id', id);
       $('<tr>')
         .append($('<td>').append(input))
-        .append($('<td>').text(camelCaseToSnakeCase(optionName)))
+        .append(
+          $('<td>').append($('<label>').attr('for', id).text(camelCaseToSnakeCase(optionName)))
+        )
         .append($('<td>').text(info.description))
         .appendTo(optionsElem);
-    }
+    });
   };
   addOptionsToPage(options, kStandaloneOptionsInfos);
 
diff --git a/src/webgpu/api/operation/texture_view/read.spec.ts b/src/webgpu/api/operation/texture_view/read.spec.ts
deleted file mode 100644
index ce2e5055a8f2..000000000000
--- a/src/webgpu/api/operation/texture_view/read.spec.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-export const description = `
-Test the result of reading textures through texture views with various options.
-
-All x= every possible view read method: {
-  - {unfiltered, filtered (if valid), comparison (if valid)} sampling
-  - storage read {vertex, fragment, compute}
-  - no-op render pass that loads and then stores
-  - depth comparison
-  - stencil comparison
-}
-
-Format reinterpretation is not tested here. It is in format_reinterpretation.spec.ts.
-
-TODO: Write helper for this if not already available (see resource_init, buffer_sync_test for related code).
-`;
-
-import { makeTestGroup } from '../../../../common/framework/test_group.js';
-import { GPUTest } from '../../../gpu_test.js';
-
-export const g = makeTestGroup(GPUTest);
-
-g.test('format')
-  .desc(
-    `Views of every allowed format.
-
-- x= every texture format
-- x= sampleCount {1, 4} if valid
-- x= every possible view read method (see above)
-`
-  )
-  .unimplemented();
-
-g.test('dimension')
-  .desc(
-    `Views of every allowed dimension.
-
-- x= a representative subset of formats
-- x= {every texture dimension} x {every valid view dimension}
-  (per gpuweb#79 no dimension-count reinterpretations, like 2d-array <-> 3d, are possible)
-- x= sampleCount {1, 4} if valid
-- x= every possible view read method (see above)
-`
-  )
-  .unimplemented();
-
-g.test('aspect')
-  .desc(
-    `Views of every allowed aspect of depth/stencil textures.
-
-- x= every depth/stencil format
-- x= {"all", "stencil-only", "depth-only"} where valid for the format
-- x= sampleCount {1, 4} if valid
-- x= every possible view read method (see above)
-`
-  )
-  .unimplemented();
diff --git a/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts b/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
index 3f72b90901e3..a075e9fff220 100644
--- a/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/limit_utils.ts
@@ -7,9 +7,10 @@ import {
   getDefaultLimitsForAdapter,
   kLimits,
 } from '../../../../capability_info.js';
+import { GPUConst } from '../../../../constants.js';
 import { GPUTestBase } from '../../../../gpu_test.js';
 
-type GPUSupportedLimit = keyof GPUSupportedLimits;
+type GPUSupportedLimit = keyof Omit<GPUSupportedLimits, '__brand'>;
 
 export const kCreatePipelineTypes = [
   'createRenderPipeline',
@@ -52,14 +53,14 @@ export function getPipelineTypeForBindingCombination(bindingCombination: Binding
 export function getStageVisibilityForBinidngCombination(bindingCombination: BindingCombination) {
   switch (bindingCombination) {
     case 'vertex':
-      return GPUShaderStage.VERTEX;
+      return GPUConst.ShaderStage.VERTEX;
     case 'fragment':
-      return GPUShaderStage.FRAGMENT;
+      return GPUConst.ShaderStage.FRAGMENT;
     case 'vertexAndFragmentWithPossibleVertexStageOverflow':
     case 'vertexAndFragmentWithPossibleFragmentStageOverflow':
-      return GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX;
+      return GPUConst.ShaderStage.FRAGMENT | GPUConst.ShaderStage.VERTEX;
     case 'compute':
-      return GPUShaderStage.COMPUTE;
+      return GPUConst.ShaderStage.COMPUTE;
   }
 }
 
@@ -245,7 +246,7 @@ export function getPerStageWGSLForBindingCombinationStorageTextures(
 
 export const kLimitModes = ['defaultLimit', 'adapterLimit'] as const;
 export type LimitMode = (typeof kLimitModes)[number];
-export type LimitsRequest = Record<string, LimitMode>;
+export type LimitsRequest = Record<string, LimitMode | number>;
 
 export const kMaximumTestValues = ['atLimit', 'overLimit'] as const;
 export type MaximumTestValue = (typeof kMaximumTestValues)[number];
@@ -338,10 +339,66 @@ export const kMinimumLimitBaseParams = kUnitCaseParamsBuilder
   .combine('limitTest', kMinimumLimitValueTests)
   .combine('testValueName', kMinimumTestValues);
 
+/**
+ * Adds a maximum limit upto a dependent limit.
+ *
+ * Example:
+ *   You want to test `maxStorageBuffersPerShaderStage` in fragment stage
+ *   so you need `maxStorageBuffersInFragmentStage` set as well. But, you
+ *   don't know exactly what value will be used for `maxStorageBuffersPerShaderStage`
+ *   since that is defined by an enum like `underDefault`.
+ *
+ *   So, you want `maxStorageBuffersInFragmentStage` to be set as high as possible.
+ *   You can't just set it to it's maximum value (adapter.limits.maxStorageBuffersInFragmentStage)
+ *   because if it's greater than `maxStorageBuffersPerShaderStage` you'll get an error.
+ *
+ *   So, use this function
+ *
+ *   const limits: LimitsRequest = {};
+ *   addMaximumLimitUpToDependentLimit(
+ *     adapter,
+ *     limits,
+ *     limit: 'maxStorageBuffersInFragmentStage', // the limit we want to add
+ *     dependentLimitName: 'maxStorageBuffersPerShaderStage', // what the previous limit is dependent on
+ *     dependentLimitTest: 'underDefault', // the enum used to decide the dependent limit
+ *   )
+ */
+export function addMaximumLimitUpToDependentLimit(
+  adapter: GPUAdapter,
+  limits: LimitsRequest,
+  limit: GPUSupportedLimit,
+  dependentLimitName: GPUSupportedLimit,
+  dependentLimitTest: MaximumLimitValueTest
+) {
+  if (!(limit in adapter.limits)) {
+    return;
+  }
+
+  const limitMaximum: number = adapter.limits[limit]!;
+  const dependentLimitMaximum: number = adapter.limits[dependentLimitName]!;
+  const testValue = getLimitValue(
+    getDefaultLimitForAdapter(adapter, dependentLimitName),
+    dependentLimitMaximum,
+    dependentLimitTest
+  );
+
+  const value = Math.min(testValue, dependentLimitMaximum, limitMaximum);
+  limits[limit] = value;
+}
+
+type LimitCheckParams = {
+  limit: GPUSupportedLimit;
+  actualLimit: number;
+  defaultLimit: number;
+};
+
+type LimitCheckFn = (t: LimitTestsImpl, device: GPUDevice, params: LimitCheckParams) => boolean;
+
 export class LimitTestsImpl extends GPUTestBase {
   _adapter: GPUAdapter | null = null;
   _device: GPUDevice | undefined = undefined;
   limit: GPUSupportedLimit = '' as GPUSupportedLimit;
+  limitTestParams: LimitTestParams = {};
   defaultLimit = 0;
   adapterLimit = 0;
 
@@ -350,6 +407,11 @@ export class LimitTestsImpl extends GPUTestBase {
     const gpu = getGPU(this.rec);
     this._adapter = await gpu.requestAdapter();
     const limit = this.limit;
+    // MAINTENANCE_TODO: consider removing this skip if the spec has no optional limits.
+    this.skipIf(
+      this._adapter?.limits[limit] === undefined && !!this.limitTestParams.limitOptional,
+      `${limit} is missing but optional for now`
+    );
     this.defaultLimit = getDefaultLimitForAdapter(this.adapter, limit);
     this.adapterLimit = this.adapter.limits[limit] as number;
     assert(!Number.isNaN(this.defaultLimit));
@@ -415,11 +477,13 @@ export class LimitTestsImpl extends GPUTestBase {
     requiredLimits[limit] = requestedLimit;
 
     if (extraLimits) {
-      for (const [extraLimitStr, limitMode] of Object.entries(extraLimits)) {
+      for (const [extraLimitStr, limitModeOrNumber] of Object.entries(extraLimits)) {
         const extraLimit = extraLimitStr as GPUSupportedLimit;
         if (adapter.limits[extraLimit] !== undefined) {
           requiredLimits[extraLimit] =
-            limitMode === 'defaultLimit'
+            typeof limitModeOrNumber === 'number'
+              ? limitModeOrNumber
+              : limitModeOrNumber === 'defaultLimit'
               ? getDefaultLimitForAdapter(adapter, extraLimit)
               : (adapter.limits[extraLimit] as number);
         }
@@ -454,16 +518,21 @@ export class LimitTestsImpl extends GPUTestBase {
           );
         }
       } else {
-        if (requestedLimit <= defaultLimit) {
-          this.expect(
-            actualLimit === defaultLimit,
-            `expected actual actualLimit: ${actualLimit} to equal defaultLimit: ${defaultLimit}`
-          );
-        } else {
-          this.expect(
-            actualLimit === requestedLimit,
-            `expected actual actualLimit: ${actualLimit} to equal requestedLimit: ${requestedLimit}`
-          );
+        const checked = this.limitTestParams.limitCheckFn
+          ? this.limitTestParams.limitCheckFn(this, device!, { limit, actualLimit, defaultLimit })
+          : false;
+        if (!checked) {
+          if (requestedLimit <= defaultLimit) {
+            this.expect(
+              actualLimit === defaultLimit,
+              `expected actual actualLimit: ${actualLimit} to equal defaultLimit: ${defaultLimit}`
+            );
+          } else {
+            this.expect(
+              actualLimit === requestedLimit,
+              `expected actual actualLimit: ${actualLimit} to equal requestedLimit: ${requestedLimit}`
+            );
+          }
         }
       }
     }
@@ -484,6 +553,10 @@ export class LimitTestsImpl extends GPUTestBase {
     const { defaultLimit, adapterLimit: maximumLimit } = this;
 
     const requestedLimit = getLimitValue(defaultLimit, maximumLimit, limitValueTest);
+    this.skipIf(
+      requestedLimit < 0 && limitValueTest === 'underDefault',
+      `requestedLimit(${requestedLimit}) for ${this.limit} is < 0`
+    );
     return this._getDeviceWithSpecificLimit(requestedLimit, extraLimits, features);
   }
 
@@ -1159,12 +1232,21 @@ export class LimitTestsImpl extends GPUTestBase {
   }
 }
 
+type LimitTestParams = {
+  limitCheckFn?: LimitCheckFn;
+  limitOptional?: boolean;
+};
+
 /**
  * Makes a new LimitTest class so that the tests have access to `limit`
  */
-function makeLimitTestFixture(limit: GPUSupportedLimit): typeof LimitTestsImpl {
+function makeLimitTestFixture(
+  limit: GPUSupportedLimit,
+  params?: LimitTestParams
+): typeof LimitTestsImpl {
   class LimitTests extends LimitTestsImpl {
     override limit = limit;
+    override limitTestParams = params ?? {};
   }
 
   return LimitTests;
@@ -1175,8 +1257,79 @@ function makeLimitTestFixture(limit: GPUSupportedLimit): typeof LimitTestsImpl {
  * writing these tests where I'd copy a test, need to rename a limit in 3-4 places,
  * forget one place, and then spend 20-30 minutes wondering why the test was failing.
  */
-export function makeLimitTestGroup(limit: GPUSupportedLimit) {
+export function makeLimitTestGroup(limit: GPUSupportedLimit, params?: LimitTestParams) {
   const description = `API Validation Tests for ${limit}.`;
-  const g = makeTestGroup(makeLimitTestFixture(limit));
+  const g = makeTestGroup(makeLimitTestFixture(limit, params));
   return { g, description, limit };
 }
+
+/**
+ * Test that limit must be less than dependentLimitName when requesting a device.
+ */
+export function testMaxStorageXXXInYYYStageDeviceCreationWithDependentLimit(
+  g: ReturnType<typeof makeLimitTestGroup>['g'],
+  limit:
+    | 'maxStorageBuffersInFragmentStage'
+    | 'maxStorageBuffersInVertexStage'
+    | 'maxStorageTexturesInFragmentStage'
+    | 'maxStorageTexturesInVertexStage',
+  dependentLimitName: 'maxStorageBuffersPerShaderStage' | 'maxStorageTexturesPerShaderStage'
+) {
+  g.test(`validate,${dependentLimitName}`)
+    .desc(
+      `Test that adapter.limit.${limit} and requiredLimits.${limit} must be <= ${dependentLimitName}`
+    )
+    .params(u => u.combine('useMax', [true, false] as const)) // true case should not reject.
+    .fn(async t => {
+      const { useMax } = t.params;
+      const { adapterLimit: maximumLimit, adapter } = t;
+
+      const dependentLimit = adapter.limits[dependentLimitName]!;
+      t.expect(
+        maximumLimit <= dependentLimit,
+        `maximumLimit(${maximumLimit}) is <= adapter.limits.${dependentLimitName}(${dependentLimit})`
+      );
+
+      const dependentEffectiveLimits = useMax
+        ? dependentLimit
+        : t.getDefaultLimit(dependentLimitName);
+      const shouldReject = maximumLimit > dependentEffectiveLimits;
+      t.debug(
+        `${limit}(${maximumLimit}) > ${dependentLimitName}(${dependentEffectiveLimits}) shouldReject: ${shouldReject}`
+      );
+      const device = await t.requestDeviceWithLimits(
+        adapter,
+        {
+          [limit]: maximumLimit,
+          ...(useMax && {
+            [dependentLimitName]: dependentLimit,
+          }),
+        },
+        shouldReject
+      );
+      device?.destroy();
+    });
+
+  g.test(`auto_upgrade,${dependentLimitName}`)
+    .desc(
+      `Test that adapter.limit.${limit} is automatically upgraded to ${dependentLimitName} except in compat.`
+    )
+    .fn(async t => {
+      const { adapter, defaultLimit } = t;
+      const dependentAdapterLimit = adapter.limits[dependentLimitName];
+      const shouldReject = false;
+      const device = await t.requestDeviceWithLimits(
+        adapter,
+        {
+          [dependentLimitName]: dependentAdapterLimit,
+        },
+        shouldReject
+      );
+
+      const expectedLimit = t.isCompatibility ? defaultLimit : dependentAdapterLimit;
+      t.expect(
+        device!.limits[limit] === expectedLimit,
+        `${limit}(${device!.limits[limit]}) === ${expectedLimit}`
+      );
+    });
+}
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersInFragmentStage.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersInFragmentStage.spec.ts
new file mode 100644
index 000000000000..09216807796e
--- /dev/null
+++ b/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersInFragmentStage.spec.ts
@@ -0,0 +1,211 @@
+import {
+  range,
+  reorder,
+  kReorderOrderKeys,
+  ReorderOrder,
+  assert,
+} from '../../../../../common/util/util.js';
+
+import {
+  kMaximumLimitBaseParams,
+  makeLimitTestGroup,
+  kBindGroupTests,
+  getPipelineTypeForBindingCombination,
+  getPerStageWGSLForBindingCombination,
+  LimitsRequest,
+  getStageVisibilityForBinidngCombination,
+  testMaxStorageXXXInYYYStageDeviceCreationWithDependentLimit,
+} from './limit_utils.js';
+
+const limit = 'maxStorageBuffersInFragmentStage';
+const dependentLimitName = 'maxStorageBuffersPerShaderStage';
+
+const kExtraLimits: LimitsRequest = {
+  maxBindingsPerBindGroup: 'adapterLimit',
+  maxBindGroups: 'adapterLimit',
+  [dependentLimitName]: 'adapterLimit',
+};
+
+export const { g, description } = makeLimitTestGroup(limit, {
+  // MAINTAINANCE_TODO: remove once this limit is required.
+  limitOptional: true,
+  limitCheckFn(t, device, { actualLimit }) {
+    if (!t.isCompatibility) {
+      const expectedLimit = device.limits[dependentLimitName];
+      t.expect(
+        actualLimit === expectedLimit,
+        `expected actual actualLimit: ${actualLimit} to equal ${dependentLimitName}: ${expectedLimit}`
+      );
+      return true;
+    }
+    return false;
+  },
+});
+
+function createBindGroupLayout(
+  device: GPUDevice,
+  visibility: number,
+  type: GPUBufferBindingType,
+  order: ReorderOrder,
+  numBindings: number
+) {
+  const bindGroupLayoutDescription: GPUBindGroupLayoutDescriptor = {
+    entries: reorder(
+      order,
+      range(numBindings, i => ({
+        binding: i,
+        visibility,
+        buffer: { type },
+      }))
+    ),
+  };
+  return device.createBindGroupLayout(bindGroupLayoutDescription);
+}
+
+g.test('createBindGroupLayout,at_over')
+  .desc(
+    `
+  Test using at and over ${limit} limit in createBindGroupLayout
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(
+    kMaximumLimitBaseParams
+      .combine('type', ['storage', 'read-only-storage'] as GPUBufferBindingType[])
+      .combine('order', kReorderOrderKeys)
+  )
+  .fn(async t => {
+    const { limitTest, testValueName, order, type } = t.params;
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, shouldError }) => {
+        t.skipIf(
+          t.adapter.limits.maxBindingsPerBindGroup < testValue,
+          `maxBindingsPerBindGroup = ${t.adapter.limits.maxBindingsPerBindGroup} which is less than ${testValue}`
+        );
+
+        const visibility = GPUShaderStage.FRAGMENT;
+        await t.expectValidationError(() => {
+          createBindGroupLayout(device, visibility, type, order, testValue);
+        }, shouldError);
+      },
+      kExtraLimits
+    );
+  });
+
+g.test('createPipelineLayout,at_over')
+  .desc(
+    `
+  Test using at and over ${limit} limit in createPipelineLayout
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(
+    kMaximumLimitBaseParams
+      .combine('type', ['storage', 'read-only-storage'] as GPUBufferBindingType[])
+      .combine('order', kReorderOrderKeys)
+  )
+  .fn(async t => {
+    const { limitTest, testValueName, order, type } = t.params;
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, shouldError, actualLimit }) => {
+        const visibility = GPUShaderStage.FRAGMENT;
+
+        t.skipIf(
+          actualLimit === 0,
+          `can not make a bindGroupLayout to test createPipelineLaoyout if the actaul limit is 0`
+        );
+
+        const maxBindingsPerBindGroup = Math.min(
+          t.device.limits.maxBindingsPerBindGroup,
+          actualLimit
+        );
+
+        const kNumGroups = Math.ceil(testValue / maxBindingsPerBindGroup);
+
+        // Not sure what to do in this case but best we get notified if it happens.
+        assert(kNumGroups <= t.device.limits.maxBindGroups);
+
+        const bindGroupLayouts = range(kNumGroups, i => {
+          const numInGroup = Math.min(
+            testValue - i * maxBindingsPerBindGroup,
+            maxBindingsPerBindGroup
+          );
+          return createBindGroupLayout(device, visibility, type, order, numInGroup);
+        });
+
+        await t.expectValidationError(
+          () => device.createPipelineLayout({ bindGroupLayouts }),
+          shouldError
+        );
+      },
+      kExtraLimits
+    );
+  });
+
+g.test('createPipeline,at_over')
+  .desc(
+    `
+  Test using createRenderPipeline(Async) and createComputePipeline(Async) at and over ${limit} limit
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(
+    kMaximumLimitBaseParams
+      .combine('async', [false, true] as const)
+      .beginSubcases()
+      .combine('order', kReorderOrderKeys)
+      .combine('bindGroupTest', kBindGroupTests)
+  )
+  .fn(async t => {
+    const { limitTest, testValueName, async, order, bindGroupTest } = t.params;
+    const bindingCombination = 'fragment';
+    const pipelineType = getPipelineTypeForBindingCombination(bindingCombination);
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, actualLimit, shouldError }) => {
+        t.skipIf(
+          bindGroupTest === 'sameGroup' && testValue > device.limits.maxBindingsPerBindGroup,
+          `can not test ${testValue} bindings in same group because maxBindingsPerBindGroup = ${device.limits.maxBindingsPerBindGroup}`
+        );
+
+        const visibility = getStageVisibilityForBinidngCombination(bindingCombination);
+        t.skipIfNotEnoughStorageBuffersInStage(visibility, testValue);
+
+        const code = getPerStageWGSLForBindingCombination(
+          bindingCombination,
+          order,
+          bindGroupTest,
+          (i, j) => `var<storage> u${j}_${i}: f32`,
+          (i, j) => `_ = u${j}_${i};`,
+          device.limits.maxBindGroups,
+          testValue
+        );
+        const module = device.createShaderModule({ code });
+
+        await t.testCreatePipeline(
+          pipelineType,
+          async,
+          module,
+          shouldError,
+          `actualLimit: ${actualLimit}, testValue: ${testValue}\n:${code}`
+        );
+      },
+      kExtraLimits
+    );
+  });
+
+testMaxStorageXXXInYYYStageDeviceCreationWithDependentLimit(g, limit, dependentLimitName);
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersInVertexStage.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersInVertexStage.spec.ts
new file mode 100644
index 000000000000..e6feb14be41a
--- /dev/null
+++ b/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersInVertexStage.spec.ts
@@ -0,0 +1,202 @@
+import {
+  range,
+  reorder,
+  kReorderOrderKeys,
+  ReorderOrder,
+  assert,
+} from '../../../../../common/util/util.js';
+
+import {
+  kMaximumLimitBaseParams,
+  makeLimitTestGroup,
+  kBindGroupTests,
+  getPipelineTypeForBindingCombination,
+  getPerStageWGSLForBindingCombination,
+  LimitsRequest,
+  getStageVisibilityForBinidngCombination,
+  testMaxStorageXXXInYYYStageDeviceCreationWithDependentLimit,
+} from './limit_utils.js';
+
+const limit = 'maxStorageBuffersInVertexStage';
+const dependentLimitName = 'maxStorageBuffersPerShaderStage';
+
+const kExtraLimits: LimitsRequest = {
+  maxBindingsPerBindGroup: 'adapterLimit',
+  maxBindGroups: 'adapterLimit',
+  [dependentLimitName]: 'adapterLimit',
+};
+
+export const { g, description } = makeLimitTestGroup(limit, {
+  // MAINTAINANCE_TODO: remove once this limit is required.
+  limitOptional: true,
+  limitCheckFn(t, device, { actualLimit }) {
+    if (!t.isCompatibility) {
+      const expectedLimit = device.limits[dependentLimitName];
+      t.expect(
+        actualLimit === expectedLimit,
+        `expected actual actualLimit: ${actualLimit} to equal ${dependentLimitName}: ${expectedLimit}`
+      );
+      return true;
+    }
+    return false;
+  },
+});
+
+function createBindGroupLayout(
+  device: GPUDevice,
+  visibility: number,
+  order: ReorderOrder,
+  numBindings: number
+) {
+  const bindGroupLayoutDescription: GPUBindGroupLayoutDescriptor = {
+    entries: reorder(
+      order,
+      range(numBindings, i => ({
+        binding: i,
+        visibility,
+        buffer: { type: 'read-only-storage' },
+      }))
+    ),
+  };
+  return device.createBindGroupLayout(bindGroupLayoutDescription);
+}
+
+g.test('createBindGroupLayout,at_over')
+  .desc(
+    `
+  Test using at and over ${limit} limit in createBindGroupLayout
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(kMaximumLimitBaseParams.combine('order', kReorderOrderKeys))
+  .fn(async t => {
+    const { limitTest, testValueName, order } = t.params;
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, shouldError }) => {
+        t.skipIf(
+          t.adapter.limits.maxBindingsPerBindGroup < testValue,
+          `maxBindingsPerBindGroup = ${t.adapter.limits.maxBindingsPerBindGroup} which is less than ${testValue}`
+        );
+
+        const visibility = GPUShaderStage.VERTEX;
+        await t.expectValidationError(() => {
+          createBindGroupLayout(device, visibility, order, testValue);
+        }, shouldError);
+      },
+      kExtraLimits
+    );
+  });
+
+g.test('createPipelineLayout,at_over')
+  .desc(
+    `
+  Test using at and over ${limit} limit in createPipelineLayout
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(kMaximumLimitBaseParams.combine('order', kReorderOrderKeys))
+  .fn(async t => {
+    const { limitTest, testValueName, order } = t.params;
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, shouldError, actualLimit }) => {
+        const visibility = GPUShaderStage.VERTEX;
+
+        t.skipIf(
+          actualLimit === 0,
+          `can not make a bindGroupLayout to test createPipelineLaoyout if the actaul limit is 0`
+        );
+
+        const maxBindingsPerBindGroup = Math.min(
+          t.device.limits.maxBindingsPerBindGroup,
+          actualLimit
+        );
+
+        const kNumGroups = Math.ceil(testValue / maxBindingsPerBindGroup);
+
+        // Not sure what to do in this case but best we get notified if it happens.
+        assert(kNumGroups <= t.device.limits.maxBindGroups);
+
+        const bindGroupLayouts = range(kNumGroups, i => {
+          const numInGroup = Math.min(
+            testValue - i * maxBindingsPerBindGroup,
+            maxBindingsPerBindGroup
+          );
+          return createBindGroupLayout(device, visibility, order, numInGroup);
+        });
+
+        await t.expectValidationError(
+          () => device.createPipelineLayout({ bindGroupLayouts }),
+          shouldError
+        );
+      },
+      kExtraLimits
+    );
+  });
+
+g.test('createPipeline,at_over')
+  .desc(
+    `
+  Test using createRenderPipeline(Async) and createComputePipeline(Async) at and over ${limit} limit
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(
+    kMaximumLimitBaseParams
+      .combine('async', [false, true] as const)
+      .beginSubcases()
+      .combine('order', kReorderOrderKeys)
+      .combine('bindGroupTest', kBindGroupTests)
+  )
+  .fn(async t => {
+    const { limitTest, testValueName, async, order, bindGroupTest } = t.params;
+    const bindingCombination = 'vertex';
+    const pipelineType = getPipelineTypeForBindingCombination(bindingCombination);
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, actualLimit, shouldError }) => {
+        t.skipIf(
+          bindGroupTest === 'sameGroup' && testValue > device.limits.maxBindingsPerBindGroup,
+          `can not test ${testValue} bindings in same group because maxBindingsPerBindGroup = ${device.limits.maxBindingsPerBindGroup}`
+        );
+
+        const visibility = getStageVisibilityForBinidngCombination(bindingCombination);
+        t.skipIfNotEnoughStorageBuffersInStage(visibility, testValue);
+
+        const code = getPerStageWGSLForBindingCombination(
+          bindingCombination,
+          order,
+          bindGroupTest,
+          (i, j) => `var<storage> u${j}_${i}: f32`,
+          (i, j) => `_ = u${j}_${i};`,
+          device.limits.maxBindGroups,
+          testValue
+        );
+        const module = device.createShaderModule({ code });
+
+        await t.testCreatePipeline(
+          pipelineType,
+          async,
+          module,
+          shouldError,
+          `actualLimit: ${actualLimit}, testValue: ${testValue}\n:${code}`
+        );
+      },
+      kExtraLimits
+    );
+  });
+
+testMaxStorageXXXInYYYStageDeviceCreationWithDependentLimit(g, limit, dependentLimitName);
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersPerShaderStage.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersPerShaderStage.spec.ts
index 3891d323d1f6..582c62038644 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersPerShaderStage.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxStorageBuffersPerShaderStage.spec.ts
@@ -17,13 +17,13 @@ import {
   getPerStageWGSLForBindingCombination,
   LimitsRequest,
   getStageVisibilityForBinidngCombination,
+  addMaximumLimitUpToDependentLimit,
+  MaximumLimitValueTest,
 } from './limit_utils.js';
 
 const kExtraLimits: LimitsRequest = {
   maxBindingsPerBindGroup: 'adapterLimit',
   maxBindGroups: 'adapterLimit',
-  maxStorageBuffersInFragmentStage: 'adapterLimit',
-  maxStorageBuffersInVertexStage: 'adapterLimit',
 };
 
 const limit = 'maxStorageBuffersPerShaderStage';
@@ -49,6 +49,31 @@ function createBindGroupLayout(
   return device.createBindGroupLayout(bindGroupLayoutDescription);
 }
 
+function addExtraRequiredLimits(
+  adapter: GPUAdapter,
+  limits: LimitsRequest,
+  limitTest: MaximumLimitValueTest
+) {
+  const newLimits: LimitsRequest = { ...limits };
+
+  addMaximumLimitUpToDependentLimit(
+    adapter,
+    newLimits,
+    'maxStorageBuffersInFragmentStage',
+    limit,
+    limitTest
+  );
+  addMaximumLimitUpToDependentLimit(
+    adapter,
+    newLimits,
+    'maxStorageBuffersInVertexStage',
+    limit,
+    limitTest
+  );
+
+  return newLimits;
+}
+
 g.test('createBindGroupLayout,at_over')
   .desc(
     `
@@ -86,7 +111,7 @@ g.test('createBindGroupLayout,at_over')
           createBindGroupLayout(device, visibility, type, order, testValue);
         }, shouldError);
       },
-      kExtraLimits
+      addExtraRequiredLimits(t.adapter, kExtraLimits, limitTest)
     );
   });
 
@@ -141,7 +166,7 @@ g.test('createPipelineLayout,at_over')
           shouldError
         );
       },
-      kExtraLimits
+      addExtraRequiredLimits(t.adapter, kExtraLimits, limitTest)
     );
   });
 
@@ -197,6 +222,6 @@ g.test('createPipeline,at_over')
           `actualLimit: ${actualLimit}, testValue: ${testValue}\n:${code}`
         );
       },
-      kExtraLimits
+      addExtraRequiredLimits(t.adapter, kExtraLimits, limitTest)
     );
   });
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesInFragmentStage.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesInFragmentStage.spec.ts
new file mode 100644
index 000000000000..2fae97f596cf
--- /dev/null
+++ b/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesInFragmentStage.spec.ts
@@ -0,0 +1,212 @@
+import {
+  range,
+  reorder,
+  kReorderOrderKeys,
+  ReorderOrder,
+  assert,
+} from '../../../../../common/util/util.js';
+import { kStorageTextureAccessValues } from '../../../../capability_info.js';
+
+import {
+  kMaximumLimitBaseParams,
+  makeLimitTestGroup,
+  kBindGroupTests,
+  getPipelineTypeForBindingCombination,
+  getPerStageWGSLForBindingCombination,
+  LimitsRequest,
+  getStageVisibilityForBinidngCombination,
+  testMaxStorageXXXInYYYStageDeviceCreationWithDependentLimit,
+} from './limit_utils.js';
+
+const limit = 'maxStorageTexturesInFragmentStage';
+const dependentLimitName = 'maxStorageTexturesPerShaderStage';
+
+const kExtraLimits: LimitsRequest = {
+  maxBindingsPerBindGroup: 'adapterLimit',
+  maxBindGroups: 'adapterLimit',
+  [dependentLimitName]: 'adapterLimit',
+};
+
+export const { g, description } = makeLimitTestGroup(limit, {
+  // MAINTAINANCE_TODO: remove once this limit is required.
+  limitOptional: true,
+  limitCheckFn(t, device, { actualLimit }) {
+    if (!t.isCompatibility) {
+      const expectedLimit = device.limits[dependentLimitName];
+      t.expect(
+        actualLimit === expectedLimit,
+        `expected actual actualLimit: ${actualLimit} to equal ${dependentLimitName}: ${expectedLimit}`
+      );
+      return true;
+    }
+    return false;
+  },
+});
+
+function createBindGroupLayout(
+  device: GPUDevice,
+  visibility: number,
+  access: GPUStorageTextureAccess,
+  order: ReorderOrder,
+  numBindings: number
+) {
+  const bindGroupLayoutDescription: GPUBindGroupLayoutDescriptor = {
+    entries: reorder(
+      order,
+      range(numBindings, i => ({
+        binding: i,
+        visibility,
+        storageTexture: { format: 'r32float', access },
+      }))
+    ),
+  };
+  return device.createBindGroupLayout(bindGroupLayoutDescription);
+}
+
+g.test('createBindGroupLayout,at_over')
+  .desc(
+    `
+  Test using at and over ${limit} limit in createBindGroupLayout
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(
+    kMaximumLimitBaseParams
+      .combine('access', kStorageTextureAccessValues)
+      .combine('order', kReorderOrderKeys)
+  )
+  .fn(async t => {
+    const { limitTest, testValueName, order, access } = t.params;
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, shouldError }) => {
+        t.skipIf(
+          t.adapter.limits.maxBindingsPerBindGroup < testValue,
+          `maxBindingsPerBindGroup = ${t.adapter.limits.maxBindingsPerBindGroup} which is less than ${testValue}`
+        );
+
+        const visibility = GPUShaderStage.FRAGMENT;
+        await t.expectValidationError(() => {
+          createBindGroupLayout(device, visibility, access, order, testValue);
+        }, shouldError);
+      },
+      kExtraLimits
+    );
+  });
+
+g.test('createPipelineLayout,at_over')
+  .desc(
+    `
+  Test using at and over ${limit} limit in createPipelineLayout
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(
+    kMaximumLimitBaseParams
+      .combine('access', kStorageTextureAccessValues)
+      .combine('order', kReorderOrderKeys)
+  )
+  .fn(async t => {
+    const { limitTest, testValueName, order, access } = t.params;
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, shouldError, actualLimit }) => {
+        const visibility = GPUShaderStage.FRAGMENT;
+
+        t.skipIf(
+          actualLimit === 0,
+          `can not make a bindGroupLayout to test createPipelineLaoyout if the actaul limit is 0`
+        );
+
+        const maxBindingsPerBindGroup = Math.min(
+          t.device.limits.maxBindingsPerBindGroup,
+          actualLimit
+        );
+
+        const kNumGroups = Math.ceil(testValue / maxBindingsPerBindGroup);
+
+        // Not sure what to do in this case but best we get notified if it happens.
+        assert(kNumGroups <= t.device.limits.maxBindGroups);
+
+        const bindGroupLayouts = range(kNumGroups, i => {
+          const numInGroup = Math.min(
+            testValue - i * maxBindingsPerBindGroup,
+            maxBindingsPerBindGroup
+          );
+          return createBindGroupLayout(device, visibility, access, order, numInGroup);
+        });
+
+        await t.expectValidationError(
+          () => device.createPipelineLayout({ bindGroupLayouts }),
+          shouldError
+        );
+      },
+      kExtraLimits
+    );
+  });
+
+g.test('createPipeline,at_over')
+  .desc(
+    `
+  Test using createRenderPipeline(Async) and createComputePipeline(Async) at and over ${limit} limit
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(
+    kMaximumLimitBaseParams
+      .combine('async', [false, true] as const)
+      .beginSubcases()
+      .combine('order', kReorderOrderKeys)
+      .combine('bindGroupTest', kBindGroupTests)
+  )
+  .fn(async t => {
+    const { limitTest, testValueName, async, order, bindGroupTest } = t.params;
+    const bindingCombination = 'fragment';
+    const pipelineType = getPipelineTypeForBindingCombination(bindingCombination);
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, actualLimit, shouldError }) => {
+        t.skipIf(
+          bindGroupTest === 'sameGroup' && testValue > device.limits.maxBindingsPerBindGroup,
+          `can not test ${testValue} bindings in same group because maxBindingsPerBindGroup = ${device.limits.maxBindingsPerBindGroup}`
+        );
+
+        const visibility = getStageVisibilityForBinidngCombination(bindingCombination);
+        t.skipIfNotEnoughStorageBuffersInStage(visibility, testValue);
+
+        const code = getPerStageWGSLForBindingCombination(
+          bindingCombination,
+          order,
+          bindGroupTest,
+          (i, j) => `var u${j}_${i}: texture_storage_2d<r32float,read>`,
+          (i, j) => `_ = u${j}_${i};`,
+          device.limits.maxBindGroups,
+          testValue
+        );
+        const module = device.createShaderModule({ code });
+
+        await t.testCreatePipeline(
+          pipelineType,
+          async,
+          module,
+          shouldError,
+          `actualLimit: ${actualLimit}, testValue: ${testValue}\n:${code}`
+        );
+      },
+      kExtraLimits
+    );
+  });
+
+testMaxStorageXXXInYYYStageDeviceCreationWithDependentLimit(g, limit, dependentLimitName);
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesInVertexStage.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesInVertexStage.spec.ts
new file mode 100644
index 000000000000..c51bb9392e6d
--- /dev/null
+++ b/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesInVertexStage.spec.ts
@@ -0,0 +1,202 @@
+import {
+  range,
+  reorder,
+  kReorderOrderKeys,
+  ReorderOrder,
+  assert,
+} from '../../../../../common/util/util.js';
+
+import {
+  kMaximumLimitBaseParams,
+  makeLimitTestGroup,
+  kBindGroupTests,
+  getPipelineTypeForBindingCombination,
+  getPerStageWGSLForBindingCombination,
+  LimitsRequest,
+  getStageVisibilityForBinidngCombination,
+  testMaxStorageXXXInYYYStageDeviceCreationWithDependentLimit,
+} from './limit_utils.js';
+
+const limit = 'maxStorageTexturesInVertexStage';
+const dependentLimitName = 'maxStorageTexturesPerShaderStage';
+
+const kExtraLimits: LimitsRequest = {
+  maxBindingsPerBindGroup: 'adapterLimit',
+  maxBindGroups: 'adapterLimit',
+  [dependentLimitName]: 'adapterLimit',
+};
+
+export const { g, description } = makeLimitTestGroup(limit, {
+  // MAINTAINANCE_TODO: remove once this limit is required.
+  limitOptional: true,
+  limitCheckFn(t, device, { actualLimit }) {
+    if (!t.isCompatibility) {
+      const expectedLimit = device.limits[dependentLimitName];
+      t.expect(
+        actualLimit === expectedLimit,
+        `expected actual actualLimit: ${actualLimit} to equal ${dependentLimitName}: ${expectedLimit}`
+      );
+      return true;
+    }
+    return false;
+  },
+});
+
+function createBindGroupLayout(
+  device: GPUDevice,
+  visibility: number,
+  order: ReorderOrder,
+  numBindings: number
+) {
+  const bindGroupLayoutDescription: GPUBindGroupLayoutDescriptor = {
+    entries: reorder(
+      order,
+      range(numBindings, i => ({
+        binding: i,
+        visibility,
+        storageTexture: { format: 'r32float', access: 'read-only' },
+      }))
+    ),
+  };
+  return device.createBindGroupLayout(bindGroupLayoutDescription);
+}
+
+g.test('createBindGroupLayout,at_over')
+  .desc(
+    `
+  Test using at and over ${limit} limit in createBindGroupLayout
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(kMaximumLimitBaseParams.combine('order', kReorderOrderKeys))
+  .fn(async t => {
+    const { limitTest, testValueName, order } = t.params;
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, shouldError }) => {
+        t.skipIf(
+          t.adapter.limits.maxBindingsPerBindGroup < testValue,
+          `maxBindingsPerBindGroup = ${t.adapter.limits.maxBindingsPerBindGroup} which is less than ${testValue}`
+        );
+
+        const visibility = GPUShaderStage.VERTEX;
+        await t.expectValidationError(() => {
+          createBindGroupLayout(device, visibility, order, testValue);
+        }, shouldError);
+      },
+      kExtraLimits
+    );
+  });
+
+g.test('createPipelineLayout,at_over')
+  .desc(
+    `
+  Test using at and over ${limit} limit in createPipelineLayout
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(kMaximumLimitBaseParams.combine('order', kReorderOrderKeys))
+  .fn(async t => {
+    const { limitTest, testValueName, order } = t.params;
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, shouldError, actualLimit }) => {
+        const visibility = GPUShaderStage.VERTEX;
+
+        t.skipIf(
+          actualLimit === 0,
+          `can not make a bindGroupLayout to test createPipelineLaoyout if the actaul limit is 0`
+        );
+
+        const maxBindingsPerBindGroup = Math.min(
+          t.device.limits.maxBindingsPerBindGroup,
+          actualLimit
+        );
+
+        const kNumGroups = Math.ceil(testValue / maxBindingsPerBindGroup);
+
+        // Not sure what to do in this case but best we get notified if it happens.
+        assert(kNumGroups <= t.device.limits.maxBindGroups);
+
+        const bindGroupLayouts = range(kNumGroups, i => {
+          const numInGroup = Math.min(
+            testValue - i * maxBindingsPerBindGroup,
+            maxBindingsPerBindGroup
+          );
+          return createBindGroupLayout(device, visibility, order, numInGroup);
+        });
+
+        await t.expectValidationError(
+          () => device.createPipelineLayout({ bindGroupLayouts }),
+          shouldError
+        );
+      },
+      kExtraLimits
+    );
+  });
+
+g.test('createPipeline,at_over')
+  .desc(
+    `
+  Test using createRenderPipeline(Async) and createComputePipeline(Async) at and over ${limit} limit
+
+  Note: We also test order to make sure the implementation isn't just looking
+  at just the last entry.
+  `
+  )
+  .params(
+    kMaximumLimitBaseParams
+      .combine('async', [false, true] as const)
+      .beginSubcases()
+      .combine('order', kReorderOrderKeys)
+      .combine('bindGroupTest', kBindGroupTests)
+  )
+  .fn(async t => {
+    const { limitTest, testValueName, async, order, bindGroupTest } = t.params;
+    const bindingCombination = 'vertex';
+    const pipelineType = getPipelineTypeForBindingCombination(bindingCombination);
+
+    await t.testDeviceWithRequestedMaximumLimits(
+      limitTest,
+      testValueName,
+      async ({ device, testValue, actualLimit, shouldError }) => {
+        t.skipIf(
+          bindGroupTest === 'sameGroup' && testValue > device.limits.maxBindingsPerBindGroup,
+          `can not test ${testValue} bindings in same group because maxBindingsPerBindGroup = ${device.limits.maxBindingsPerBindGroup}`
+        );
+
+        const visibility = getStageVisibilityForBinidngCombination(bindingCombination);
+        t.skipIfNotEnoughStorageBuffersInStage(visibility, testValue);
+
+        const code = getPerStageWGSLForBindingCombination(
+          bindingCombination,
+          order,
+          bindGroupTest,
+          (i, j) => `var u${j}_${i}: texture_storage_2d<r32float,read>`,
+          (i, j) => `_ = u${j}_${i};`,
+          device.limits.maxBindGroups,
+          testValue
+        );
+        const module = device.createShaderModule({ code });
+
+        await t.testCreatePipeline(
+          pipelineType,
+          async,
+          module,
+          shouldError,
+          `actualLimit: ${actualLimit}, testValue: ${testValue}\n:${code}`
+        );
+      },
+      kExtraLimits
+    );
+  });
+
+testMaxStorageXXXInYYYStageDeviceCreationWithDependentLimit(g, limit, dependentLimitName);
diff --git a/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesPerShaderStage.spec.ts b/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesPerShaderStage.spec.ts
index e32afb6e8c3e..56304cc9b26f 100644
--- a/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesPerShaderStage.spec.ts
+++ b/src/webgpu/api/validation/capability_checks/limits/maxStorageTexturesPerShaderStage.spec.ts
@@ -22,12 +22,13 @@ import {
   LimitTestsImpl,
   kBindingCombinations,
   getStageVisibilityForBinidngCombination,
+  MaximumLimitValueTest,
+  addMaximumLimitUpToDependentLimit,
 } from './limit_utils.js';
 
 const kExtraLimits: LimitsRequest = {
   maxBindingsPerBindGroup: 'adapterLimit',
   maxBindGroups: 'adapterLimit',
-  maxStorageTexturesInFragmentStage: 'adapterLimit',
 };
 
 const limit = 'maxStorageTexturesPerShaderStage';
@@ -92,6 +93,37 @@ function skipIfAccessNotSupported(t: LimitTestsImpl, access: GPUStorageTextureAc
   );
 }
 
+function filterWriteAccessInVertexStage(
+  visibility: GPUShaderStageFlags,
+  access: GPUStorageTextureAccess
+) {
+  return access === 'read-only' || (visibility & GPUConst.ShaderStage.VERTEX) === 0;
+}
+
+function addExtraRequiredLimits(
+  adapter: GPUAdapter,
+  limits: LimitsRequest,
+  limitTest: MaximumLimitValueTest
+) {
+  const newLimits: LimitsRequest = { ...limits };
+
+  addMaximumLimitUpToDependentLimit(
+    adapter,
+    newLimits,
+    'maxStorageTexturesInFragmentStage',
+    limit,
+    limitTest
+  );
+  addMaximumLimitUpToDependentLimit(
+    adapter,
+    newLimits,
+    'maxStorageTexturesInVertexStage',
+    limit,
+    limitTest
+  );
+
+  return newLimits;
+}
 g.test('createBindGroupLayout,at_over')
   .desc(
     `
@@ -105,6 +137,7 @@ g.test('createBindGroupLayout,at_over')
     kMaximumLimitBaseParams
       .combine('visibility', kShaderStageCombinationsWithStage)
       .combine('access', kStorageTextureAccessValues)
+      .filter(t => filterWriteAccessInVertexStage(t.visibility, t.access))
       .combine('order', kReorderOrderKeys)
   )
   .fn(async t => {
@@ -126,7 +159,7 @@ g.test('createBindGroupLayout,at_over')
           shouldError
         );
       },
-      kExtraLimits
+      addExtraRequiredLimits(t.adapter, kExtraLimits, limitTest)
     );
   });
 
@@ -143,6 +176,7 @@ g.test('createPipelineLayout,at_over')
     kMaximumLimitBaseParams
       .combine('visibility', kShaderStageCombinationsWithStage)
       .combine('access', kStorageTextureAccessValues)
+      .filter(t => filterWriteAccessInVertexStage(t.visibility, t.access))
       .combine('order', kReorderOrderKeys)
   )
   .fn(async t => {
@@ -178,7 +212,7 @@ g.test('createPipelineLayout,at_over')
           shouldError
         );
       },
-      kExtraLimits
+      addExtraRequiredLimits(t.adapter, kExtraLimits, limitTest)
     );
   });
 
@@ -196,6 +230,12 @@ g.test('createPipeline,at_over')
       .combine('async', [false, true] as const)
       .combine('bindingCombination', kBindingCombinations)
       .combine('access', kStorageTextureAccessValues)
+      .filter(t =>
+        filterWriteAccessInVertexStage(
+          getStageVisibilityForBinidngCombination(t.bindingCombination),
+          t.access
+        )
+      )
       .beginSubcases()
       .combine('order', kReorderOrderKeys)
       .combine('bindGroupTest', kBindGroupTests)
@@ -244,6 +284,6 @@ g.test('createPipeline,at_over')
           `actualLimit: ${actualLimit}, testValue: ${testValue}\n:${code}`
         );
       },
-      kExtraLimits
+      addExtraRequiredLimits(t.adapter, kExtraLimits, limitTest)
     );
   });
diff --git a/src/webgpu/listing_meta.json b/src/webgpu/listing_meta.json
index a3ef284e59de..e0390869579d 100644
--- a/src/webgpu/listing_meta.json
+++ b/src/webgpu/listing_meta.json
@@ -210,9 +210,6 @@
   "webgpu:api,operation,storage_texture,read_write:basic:*": { "subcaseMS": 5.000 },
   "webgpu:api,operation,texture_view,format_reinterpretation:render_and_resolve_attachment:*": { "subcaseMS": 14.488 },
   "webgpu:api,operation,texture_view,format_reinterpretation:texture_binding:*": { "subcaseMS": 17.225 },
-  "webgpu:api,operation,texture_view,read:aspect:*": { "subcaseMS": 0.601 },
-  "webgpu:api,operation,texture_view,read:dimension:*": { "subcaseMS": 0.701 },
-  "webgpu:api,operation,texture_view,read:format:*": { "subcaseMS": 1.100 },
   "webgpu:api,operation,texture_view,write:aspect:*": { "subcaseMS": 0.700 },
   "webgpu:api,operation,texture_view,write:dimension:*": { "subcaseMS": 0.601 },
   "webgpu:api,operation,texture_view,write:format:*": { "subcaseMS": 0.600 },
diff --git a/src/webgpu/print_environment.spec.ts b/src/webgpu/print_environment.spec.ts
index 9a47f8320cda..83c3e4a62be8 100644
--- a/src/webgpu/print_environment.spec.ts
+++ b/src/webgpu/print_environment.spec.ts
@@ -54,7 +54,7 @@ WPT disallows console.log and doesn't support logs on passing tests, so this doe
 
     const info = JSON.stringify(
       {
-        userAgent: navigator.userAgent,
+        userAgent: globalThis.navigator?.userAgent,
         globalScope: Object.getPrototypeOf(globalThis).constructor.name,
         globalTestConfig,
         baseResourcePath: getResourcePath(''),