diff --git a/src/dawn_native/CommandBufferStateTracker.cpp b/src/dawn_native/CommandBufferStateTracker.cpp
index 24d8342..9afd14b 100644
--- a/src/dawn_native/CommandBufferStateTracker.cpp
+++ b/src/dawn_native/CommandBufferStateTracker.cpp
@@ -76,6 +76,66 @@
         return ValidateOperation(kDrawIndexedAspects);
     }
 
+    MaybeError CommandBufferStateTracker::ValidateBufferInRangeForVertexBuffer(
+        uint32_t vertexCount,
+        uint32_t firstVertex) {
+        const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>&
+            vertexBufferSlotsUsedAsVertexBuffer =
+                mLastRenderPipeline->GetVertexBufferSlotsUsedAsVertexBuffer();
+
+        for (auto usedSlotVertex : IterateBitSet(vertexBufferSlotsUsedAsVertexBuffer)) {
+            const VertexBufferInfo& vertexBuffer =
+                mLastRenderPipeline->GetVertexBuffer(usedSlotVertex);
+            uint64_t arrayStride = vertexBuffer.arrayStride;
+            uint64_t bufferSize = mVertexBufferSizes[usedSlotVertex];
+            // firstVertex and vertexCount are in uint32_t, and arrayStride must not
+            // be larger than kMaxVertexBufferArrayStride, which is currently 2048. So by
+            // doing checks in uint64_t we avoid overflows.
+            if ((static_cast<uint64_t>(firstVertex) + vertexCount) * arrayStride > bufferSize) {
+                return DAWN_VALIDATION_ERROR("Vertex buffer out of bound");
+            }
+        }
+
+        return {};
+    }
+
+    MaybeError CommandBufferStateTracker::ValidateBufferInRangeForInstanceBuffer(
+        uint32_t instanceCount,
+        uint32_t firstInstance) {
+        const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>&
+            vertexBufferSlotsUsedAsInstanceBuffer =
+                mLastRenderPipeline->GetVertexBufferSlotsUsedAsInstanceBuffer();
+
+        for (auto usedSlotInstance : IterateBitSet(vertexBufferSlotsUsedAsInstanceBuffer)) {
+            const VertexBufferInfo& vertexBuffer =
+                mLastRenderPipeline->GetVertexBuffer(usedSlotInstance);
+            uint64_t arrayStride = vertexBuffer.arrayStride;
+            uint64_t bufferSize = mVertexBufferSizes[usedSlotInstance];
+            // firstInstance and instanceCount are in uint32_t, and arrayStride must
+            // not be larger than kMaxVertexBufferArrayStride, which is currently 2048.
+            // So by doing checks in uint64_t we avoid overflows.
+            if ((static_cast<uint64_t>(firstInstance) + instanceCount) * arrayStride > bufferSize) {
+                return DAWN_VALIDATION_ERROR("Vertex buffer out of bound");
+            }
+        }
+
+        return {};
+    }
+
+    MaybeError CommandBufferStateTracker::ValidateIndexBufferInRange(uint32_t indexCount,
+                                                                     uint32_t firstIndex) {
+        // Validate the range of index buffer
+        // firstIndex and indexCount are in uint32_t, while IndexFormatSize is 2 (for
+        // wgpu::IndexFormat::Uint16) or 4 (for wgpu::IndexFormat::Uint32), so by doing checks in
+        // uint64_t we avoid overflows.
+        if ((static_cast<uint64_t>(firstIndex) + indexCount) * IndexFormatSize(mIndexFormat) >
+            mIndexBufferSize) {
+            // Index range is out of bounds
+            return DAWN_VALIDATION_ERROR("Index buffer out of bound");
+        }
+        return {};
+    }
+
     MaybeError CommandBufferStateTracker::ValidateOperation(ValidationAspects requiredAspects) {
         // Fast return-true path if everything is good
         ValidationAspects missingAspects = requiredAspects & ~mAspects;
@@ -213,8 +273,9 @@
         mIndexBufferSize = size;
     }
 
-    void CommandBufferStateTracker::SetVertexBuffer(VertexBufferSlot slot) {
+    void CommandBufferStateTracker::SetVertexBuffer(VertexBufferSlot slot, uint64_t size) {
         mVertexBufferSlotsUsed.set(slot);
+        mVertexBufferSizes[slot] = size;
     }
 
     void CommandBufferStateTracker::SetPipelineCommon(PipelineBase* pipeline) {
@@ -234,5 +295,4 @@
     PipelineLayoutBase* CommandBufferStateTracker::GetPipelineLayout() const {
         return mLastPipelineLayout;
     }
-
 }  // namespace dawn_native
diff --git a/src/dawn_native/CommandBufferStateTracker.h b/src/dawn_native/CommandBufferStateTracker.h
index 8c223cf..805a4fb 100644
--- a/src/dawn_native/CommandBufferStateTracker.h
+++ b/src/dawn_native/CommandBufferStateTracker.h
@@ -22,9 +22,6 @@
 #include "dawn_native/Error.h"
 #include "dawn_native/Forward.h"
 
-#include <map>
-#include <set>
-
 namespace dawn_native {
 
     class CommandBufferStateTracker {
@@ -33,23 +30,21 @@
         MaybeError ValidateCanDispatch();
         MaybeError ValidateCanDraw();
         MaybeError ValidateCanDrawIndexed();
+        MaybeError ValidateBufferInRangeForVertexBuffer(uint32_t vertexCount, uint32_t firstVertex);
+        MaybeError ValidateBufferInRangeForInstanceBuffer(uint32_t instanceCount,
+                                                          uint32_t firstInstance);
+        MaybeError ValidateIndexBufferInRange(uint32_t indexCount, uint32_t firstIndex);
 
         // State-modifying methods
         void SetComputePipeline(ComputePipelineBase* pipeline);
         void SetRenderPipeline(RenderPipelineBase* pipeline);
         void SetBindGroup(BindGroupIndex index, BindGroupBase* bindgroup);
         void SetIndexBuffer(wgpu::IndexFormat format, uint64_t size);
-        void SetVertexBuffer(VertexBufferSlot slot);
+        void SetVertexBuffer(VertexBufferSlot slot, uint64_t size);
 
         static constexpr size_t kNumAspects = 4;
         using ValidationAspects = std::bitset<kNumAspects>;
 
-        uint64_t GetIndexBufferSize() {
-            return mIndexBufferSize;
-        }
-        wgpu::IndexFormat GetIndexFormat() {
-            return mIndexFormat;
-        }
         BindGroupBase* GetBindGroup(BindGroupIndex index) const;
         PipelineLayoutBase* GetPipelineLayout() const;
 
@@ -68,6 +63,8 @@
         wgpu::IndexFormat mIndexFormat;
         uint64_t mIndexBufferSize = 0;
 
+        ityp::array<VertexBufferSlot, uint64_t, kMaxVertexBuffers> mVertexBufferSizes = {};
+
         PipelineLayoutBase* mLastPipelineLayout = nullptr;
         RenderPipelineBase* mLastRenderPipeline = nullptr;
 
diff --git a/src/dawn_native/RenderEncoderBase.cpp b/src/dawn_native/RenderEncoderBase.cpp
index c586aaa..a22a2df 100644
--- a/src/dawn_native/RenderEncoderBase.cpp
+++ b/src/dawn_native/RenderEncoderBase.cpp
@@ -67,6 +67,11 @@
                 if (mDisableBaseInstance && firstInstance != 0) {
                     return DAWN_VALIDATION_ERROR("Non-zero first instance not supported");
                 }
+
+                DAWN_TRY(mCommandBufferState.ValidateBufferInRangeForVertexBuffer(vertexCount,
+                                                                                  firstVertex));
+                DAWN_TRY(mCommandBufferState.ValidateBufferInRangeForInstanceBuffer(instanceCount,
+                                                                                    firstInstance));
             }
 
             DrawCmd* draw = allocator->Allocate<DrawCmd>(Command::Draw);
@@ -94,16 +99,13 @@
                 if (mDisableBaseVertex && baseVertex != 0) {
                     return DAWN_VALIDATION_ERROR("Non-zero base vertex not supported");
                 }
+
+                DAWN_TRY(mCommandBufferState.ValidateIndexBufferInRange(indexCount, firstIndex));
+
+                DAWN_TRY(mCommandBufferState.ValidateBufferInRangeForInstanceBuffer(instanceCount,
+                                                                                    firstInstance));
             }
 
-            if (static_cast<uint64_t>(firstIndex) + indexCount >
-                mCommandBufferState.GetIndexBufferSize() /
-                    IndexFormatSize(mCommandBufferState.GetIndexFormat())) {
-                // Index range is out of bounds
-                // Treat as no-op and skip issuing draw call
-                dawn::WarningLog() << "Index range is out of bounds";
-                return {};
-            }
             DrawIndexedCmd* draw = allocator->Allocate<DrawIndexedCmd>(Command::DrawIndexed);
             draw->indexCount = indexCount;
             draw->instanceCount = instanceCount;
@@ -292,7 +294,7 @@
                 }
             }
 
-            mCommandBufferState.SetVertexBuffer(VertexBufferSlot(uint8_t(slot)));
+            mCommandBufferState.SetVertexBuffer(VertexBufferSlot(uint8_t(slot)), size);
 
             SetVertexBufferCmd* cmd =
                 allocator->Allocate<SetVertexBufferCmd>(Command::SetVertexBuffer);
diff --git a/src/dawn_native/RenderPipeline.cpp b/src/dawn_native/RenderPipeline.cpp
index 456acce..d77a4eb 100644
--- a/src/dawn_native/RenderPipeline.cpp
+++ b/src/dawn_native/RenderPipeline.cpp
@@ -395,6 +395,16 @@
             mVertexBufferSlotsUsed.set(typedSlot);
             mVertexBufferInfos[typedSlot].arrayStride = buffers[slot].arrayStride;
             mVertexBufferInfos[typedSlot].stepMode = buffers[slot].stepMode;
+            switch (buffers[slot].stepMode) {
+                case wgpu::InputStepMode::Vertex:
+                    mVertexBufferSlotsUsedAsVertexBuffer.set(typedSlot);
+                    break;
+                case wgpu::InputStepMode::Instance:
+                    mVertexBufferSlotsUsedAsInstanceBuffer.set(typedSlot);
+                    break;
+                default:
+                    DAWN_UNREACHABLE();
+            }
 
             for (uint32_t i = 0; i < buffers[slot].attributeCount; ++i) {
                 VertexAttributeLocation location = VertexAttributeLocation(
@@ -494,6 +504,18 @@
         return mVertexBufferSlotsUsed;
     }
 
+    const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>&
+    RenderPipelineBase::GetVertexBufferSlotsUsedAsVertexBuffer() const {
+        ASSERT(!IsError());
+        return mVertexBufferSlotsUsedAsVertexBuffer;
+    }
+
+    const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>&
+    RenderPipelineBase::GetVertexBufferSlotsUsedAsInstanceBuffer() const {
+        ASSERT(!IsError());
+        return mVertexBufferSlotsUsedAsInstanceBuffer;
+    }
+
     const VertexBufferInfo& RenderPipelineBase::GetVertexBuffer(VertexBufferSlot slot) const {
         ASSERT(!IsError());
         ASSERT(mVertexBufferSlotsUsed[slot]);
diff --git a/src/dawn_native/RenderPipeline.h b/src/dawn_native/RenderPipeline.h
index b5cc820..10a6433 100644
--- a/src/dawn_native/RenderPipeline.h
+++ b/src/dawn_native/RenderPipeline.h
@@ -63,6 +63,10 @@
         GetAttributeLocationsUsed() const;
         const VertexAttributeInfo& GetAttribute(VertexAttributeLocation location) const;
         const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>& GetVertexBufferSlotsUsed() const;
+        const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>&
+        GetVertexBufferSlotsUsedAsVertexBuffer() const;
+        const ityp::bitset<VertexBufferSlot, kMaxVertexBuffers>&
+        GetVertexBufferSlotsUsedAsInstanceBuffer() const;
         const VertexBufferInfo& GetVertexBuffer(VertexBufferSlot slot) const;
         uint32_t GetVertexBufferCount() const;
 
@@ -104,6 +108,8 @@
         ityp::array<VertexAttributeLocation, VertexAttributeInfo, kMaxVertexAttributes>
             mAttributeInfos;
         ityp::bitset<VertexBufferSlot, kMaxVertexBuffers> mVertexBufferSlotsUsed;
+        ityp::bitset<VertexBufferSlot, kMaxVertexBuffers> mVertexBufferSlotsUsedAsVertexBuffer;
+        ityp::bitset<VertexBufferSlot, kMaxVertexBuffers> mVertexBufferSlotsUsedAsInstanceBuffer;
         ityp::array<VertexBufferSlot, VertexBufferInfo, kMaxVertexBuffers> mVertexBufferInfos;
 
         // Attachments
diff --git a/src/tests/BUILD.gn b/src/tests/BUILD.gn
index 2310591..c97727a 100644
--- a/src/tests/BUILD.gn
+++ b/src/tests/BUILD.gn
@@ -196,6 +196,7 @@
     "unittests/validation/CopyTextureForBrowserTests.cpp",
     "unittests/validation/DebugMarkerValidationTests.cpp",
     "unittests/validation/DrawIndirectValidationTests.cpp",
+    "unittests/validation/DrawVertexAndIndexBufferOOBValidationTests.cpp",
     "unittests/validation/DynamicStateCommandValidationTests.cpp",
     "unittests/validation/ErrorScopeValidationTests.cpp",
     "unittests/validation/ExternalTextureTests.cpp",
@@ -353,7 +354,6 @@
     "end2end/TextureSubresourceTests.cpp",
     "end2end/TextureViewTests.cpp",
     "end2end/TextureZeroInitTests.cpp",
-    "end2end/VertexBufferRobustnessTests.cpp",
     "end2end/VertexFormatTests.cpp",
     "end2end/VertexStateTests.cpp",
     "end2end/ViewportOrientationTests.cpp",
diff --git a/src/tests/end2end/DrawIndexedTests.cpp b/src/tests/end2end/DrawIndexedTests.cpp
index d94c095..f7e9431 100644
--- a/src/tests/end2end/DrawIndexedTests.cpp
+++ b/src/tests/end2end/DrawIndexedTests.cpp
@@ -137,45 +137,6 @@
     Test(6, 1, 0, 0, 0, 0, filled, filled);
 }
 
-// Out of bounds drawIndexed are treated as no-ops instead of invalid operations
-// Some agreements: https://github.com/gpuweb/gpuweb/issues/955
-TEST_P(DrawIndexedTest, OutOfBounds) {
-    RGBA8 filled(0, 255, 0, 255);
-    RGBA8 notFilled(0, 0, 0, 0);
-
-    // a valid draw.
-    Test(6, 1, 0, 0, 0, 0, filled, filled);
-    // indexCount is 0 but firstIndex out of bound
-    Test(0, 1, 20, 0, 0, 0, notFilled, notFilled);
-    // indexCount + firstIndex out of bound
-    Test(6, 1, 7, 0, 0, 0, notFilled, notFilled);
-    // only firstIndex out of bound
-    Test(6, 1, 20, 0, 0, 0, notFilled, notFilled);
-    // firstIndex much larger than the bound
-    Test(6, 1, 10000, 0, 0, 0, notFilled, notFilled);
-    // only indexCount out of bound
-    Test(20, 1, 0, 0, 0, 0, notFilled, notFilled);
-    // indexCount much larger than the bound
-    Test(10000, 1, 0, 0, 0, 0, notFilled, notFilled);
-    // max uint32_t indexCount and firstIndex
-    Test(std::numeric_limits<uint32_t>::max(), 1, std::numeric_limits<uint32_t>::max(), 0, 0, 0,
-         notFilled, notFilled);
-    // max uint32_t indexCount and small firstIndex
-    Test(std::numeric_limits<uint32_t>::max(), 1, 2, 0, 0, 0, notFilled, notFilled);
-    // small indexCount and max uint32_t firstIndex
-    Test(2, 1, std::numeric_limits<uint32_t>::max(), 0, 0, 0, notFilled, notFilled);
-}
-
-TEST_P(DrawIndexedTest, ZeroSizedIndexBuffer) {
-    RGBA8 notFilled(0, 0, 0, 0);
-
-    // IndexBuffer size is zero, so index access is always out of bounds
-    TestZeroSizedIndexBufferDraw(3, 1, notFilled, notFilled);
-    TestZeroSizedIndexBufferDraw(0, 1, notFilled, notFilled);
-    TestZeroSizedIndexBufferDraw(3, 0, notFilled, notFilled);
-    TestZeroSizedIndexBufferDraw(0, 0, notFilled, notFilled);
-}
-
 // Test the parameter 'baseVertex' of DrawIndexed() works.
 TEST_P(DrawIndexedTest, BaseVertex) {
     DAWN_TEST_UNSUPPORTED_IF(HasToggleEnabled("disable_base_vertex"));
diff --git a/src/tests/end2end/VertexBufferRobustnessTests.cpp b/src/tests/end2end/VertexBufferRobustnessTests.cpp
deleted file mode 100644
index 7d49b05..0000000
--- a/src/tests/end2end/VertexBufferRobustnessTests.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-// Copyright 2020 The Dawn Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "common/Assert.h"
-#include "common/Constants.h"
-#include "common/Math.h"
-#include "tests/DawnTest.h"
-#include "utils/ComboRenderPipelineDescriptor.h"
-#include "utils/WGPUHelpers.h"
-
-// Vertex buffer robustness tests that clamping is applied on vertex attributes. This would happen
-// on backends where vertex pulling is enabled, such as Metal.
-class VertexBufferRobustnessTest : public DawnTest {
-  protected:
-    void SetUp() override {
-        DawnTest::SetUp();
-    }
-
-    // Creates a vertex module that tests an expression with given attributes. If successful, the
-    // point drawn would be moved out of the viewport. On failure, the point is kept inside the
-    // viewport.
-    wgpu::ShaderModule CreateVertexModule(const std::string& attribute,
-                                          const std::string& successExpression) {
-        return utils::CreateShaderModule(device, (R"(
-                [[stage(vertex)]] fn main(
-                    )" + attribute + R"(
-                ) -> [[builtin(position)]] vec4<f32> {
-                    if ()" + successExpression + R"() {
-                        // Success case, move the vertex out of the viewport
-                        return vec4<f32>(-10.0, 0.0, 0.0, 1.0);
-                    }
-                    // Failure case, move the vertex inside the viewport
-                    return vec4<f32>(0.0, 0.0, 0.0, 1.0);
-                }
-            )")
-                                                     .c_str());
-    }
-
-    // Runs the test, a true |expectation| meaning success
-    void DoTest(const std::string& attributes,
-                const std::string& successExpression,
-                const utils::ComboVertexStateDescriptor& vertexState,
-                wgpu::Buffer vertexBuffer,
-                uint64_t bufferOffset,
-                bool expectation) {
-        wgpu::ShaderModule vsModule = CreateVertexModule(attributes, successExpression);
-        wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
-                [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
-                    return vec4<f32>(1.0, 1.0, 1.0, 1.0);
-                }
-            )");
-
-        utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 1, 1);
-
-        utils::ComboRenderPipelineDescriptor descriptor;
-        descriptor.vertex.module = vsModule;
-        descriptor.cFragment.module = fsModule;
-        descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList;
-        descriptor.vertex.bufferCount = vertexState.vertexBufferCount;
-        descriptor.vertex.buffers = &vertexState.cVertexBuffers[0];
-        descriptor.cTargets[0].format = renderPass.colorFormat;
-        renderPass.renderPassInfo.cColorAttachments[0].clearColor = {0, 0, 0, 1};
-
-        wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);
-
-        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
-        pass.SetPipeline(pipeline);
-        pass.SetVertexBuffer(0, vertexBuffer, bufferOffset);
-        pass.Draw(1000);
-        pass.EndPass();
-
-        wgpu::CommandBuffer commands = encoder.Finish();
-        queue.Submit(1, &commands);
-
-        RGBA8 noOutput(0, 0, 0, 255);
-        RGBA8 someOutput(255, 255, 255, 255);
-        EXPECT_PIXEL_RGBA8_EQ(expectation ? noOutput : someOutput, renderPass.color, 0, 0);
-    }
-};
-
-TEST_P(VertexBufferRobustnessTest, DetectInvalidValues) {
-    utils::ComboVertexStateDescriptor vertexState;
-    vertexState.vertexBufferCount = 1;
-    vertexState.cVertexBuffers[0].arrayStride = sizeof(float);
-    vertexState.cVertexBuffers[0].attributeCount = 1;
-    vertexState.cAttributes[0].format = wgpu::VertexFormat::Float32;
-    vertexState.cAttributes[0].offset = 0;
-    vertexState.cAttributes[0].shaderLocation = 0;
-
-    // Bind at an offset of 0, so we see 111.0, leading to failure
-    float kVertices[] = {111.0, 473.0, 473.0};
-    wgpu::Buffer vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
-                                                            wgpu::BufferUsage::Vertex);
-
-    DoTest("[[location(0)]] a : f32", "a == 473.0", vertexState, vertexBuffer, 0, false);
-}
-
-TEST_P(VertexBufferRobustnessTest, FloatClamp) {
-    utils::ComboVertexStateDescriptor vertexState;
-    vertexState.vertexBufferCount = 1;
-    vertexState.cVertexBuffers[0].arrayStride = sizeof(float);
-    vertexState.cVertexBuffers[0].attributeCount = 1;
-    vertexState.cAttributes[0].format = wgpu::VertexFormat::Float32;
-    vertexState.cAttributes[0].offset = 0;
-    vertexState.cAttributes[0].shaderLocation = 0;
-
-    // Bind at an offset of 4, so we clamp to only values containing 473.0
-    float kVertices[] = {111.0, 473.0, 473.0};
-    wgpu::Buffer vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
-                                                            wgpu::BufferUsage::Vertex);
-
-    DoTest("[[location(0)]] a : f32", "a == 473.0", vertexState, vertexBuffer, 4, true);
-}
-
-TEST_P(VertexBufferRobustnessTest, IntClamp) {
-    utils::ComboVertexStateDescriptor vertexState;
-    vertexState.vertexBufferCount = 1;
-    vertexState.cVertexBuffers[0].arrayStride = sizeof(int32_t);
-    vertexState.cVertexBuffers[0].attributeCount = 1;
-    vertexState.cAttributes[0].format = wgpu::VertexFormat::Sint32;
-    vertexState.cAttributes[0].offset = 0;
-    vertexState.cAttributes[0].shaderLocation = 0;
-
-    // Bind at an offset of 4, so we clamp to only values containing 473
-    int32_t kVertices[] = {111, 473, 473};
-    wgpu::Buffer vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
-                                                            wgpu::BufferUsage::Vertex);
-
-    DoTest("[[location(0)]] a : i32", "a == 473", vertexState, vertexBuffer, 4, true);
-}
-
-TEST_P(VertexBufferRobustnessTest, UIntClamp) {
-    utils::ComboVertexStateDescriptor vertexState;
-    vertexState.vertexBufferCount = 1;
-    vertexState.cVertexBuffers[0].arrayStride = sizeof(uint32_t);
-    vertexState.cVertexBuffers[0].attributeCount = 1;
-    vertexState.cAttributes[0].format = wgpu::VertexFormat::Uint32;
-    vertexState.cAttributes[0].offset = 0;
-    vertexState.cAttributes[0].shaderLocation = 0;
-
-    // Bind at an offset of 4, so we clamp to only values containing 473
-    uint32_t kVertices[] = {111, 473, 473};
-    wgpu::Buffer vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
-                                                            wgpu::BufferUsage::Vertex);
-
-    DoTest("[[location(0)]] a : u32", "a == 473u", vertexState, vertexBuffer, 4, true);
-}
-
-TEST_P(VertexBufferRobustnessTest, Float2Clamp) {
-    utils::ComboVertexStateDescriptor vertexState;
-    vertexState.vertexBufferCount = 1;
-    vertexState.cVertexBuffers[0].arrayStride = sizeof(float) * 2;
-    vertexState.cVertexBuffers[0].attributeCount = 1;
-    vertexState.cAttributes[0].format = wgpu::VertexFormat::Float32x2;
-    vertexState.cAttributes[0].offset = 0;
-    vertexState.cAttributes[0].shaderLocation = 0;
-
-    // Bind at an offset of 8, so we clamp to only values containing 473.0
-    float kVertices[] = {111.0, 111.0, 473.0, 473.0};
-    wgpu::Buffer vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
-                                                            wgpu::BufferUsage::Vertex);
-
-    DoTest("[[location(0)]] a : vec2<f32>", "a[0] == 473.0 && a[1] == 473.0",
-           std::move(vertexState), vertexBuffer, 8, true);
-}
-
-TEST_P(VertexBufferRobustnessTest, Float3Clamp) {
-    utils::ComboVertexStateDescriptor vertexState;
-    vertexState.vertexBufferCount = 1;
-    vertexState.cVertexBuffers[0].arrayStride = sizeof(float) * 3;
-    vertexState.cVertexBuffers[0].attributeCount = 1;
-    vertexState.cAttributes[0].format = wgpu::VertexFormat::Float32x3;
-    vertexState.cAttributes[0].offset = 0;
-    vertexState.cAttributes[0].shaderLocation = 0;
-
-    // Bind at an offset of 12, so we clamp to only values containing 473.0
-    float kVertices[] = {111.0, 111.0, 111.0, 473.0, 473.0, 473.0};
-    wgpu::Buffer vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
-                                                            wgpu::BufferUsage::Vertex);
-
-    DoTest("[[location(0)]] a : vec3<f32>",
-           "a[0] == 473.0 && a[1] == 473.0 && a[2] == 473.0", vertexState, vertexBuffer, 12, true);
-}
-
-TEST_P(VertexBufferRobustnessTest, Float4Clamp) {
-    utils::ComboVertexStateDescriptor vertexState;
-    vertexState.vertexBufferCount = 1;
-    vertexState.cVertexBuffers[0].arrayStride = sizeof(float) * 4;
-    vertexState.cVertexBuffers[0].attributeCount = 1;
-    vertexState.cAttributes[0].format = wgpu::VertexFormat::Float32x4;
-    vertexState.cAttributes[0].offset = 0;
-    vertexState.cAttributes[0].shaderLocation = 0;
-
-    // Bind at an offset of 16, so we clamp to only values containing 473.0
-    float kVertices[] = {111.0, 111.0, 111.0, 111.0, 473.0, 473.0, 473.0, 473.0};
-    wgpu::Buffer vertexBuffer = utils::CreateBufferFromData(device, kVertices, sizeof(kVertices),
-                                                            wgpu::BufferUsage::Vertex);
-
-    DoTest("[[location(0)]] a : vec4<f32>",
-           "a[0] == 473.0 && a[1] == 473.0 && a[2] == 473.0 && a[3] == 473.0", vertexState,
-           vertexBuffer, 16, true);
-}
-
-DAWN_INSTANTIATE_TEST(VertexBufferRobustnessTest, MetalBackend({"metal_enable_vertex_pulling"}));
diff --git a/src/tests/unittests/validation/DrawVertexAndIndexBufferOOBValidationTests.cpp b/src/tests/unittests/validation/DrawVertexAndIndexBufferOOBValidationTests.cpp
new file mode 100644
index 0000000..8090a1c
--- /dev/null
+++ b/src/tests/unittests/validation/DrawVertexAndIndexBufferOOBValidationTests.cpp
@@ -0,0 +1,657 @@
+// Copyright 2021 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "tests/unittests/validation/ValidationTest.h"
+
+#include "common/Constants.h"
+
+#include "common/VertexFormatUtils.h"
+#include "utils/ComboRenderPipelineDescriptor.h"
+#include "utils/WGPUHelpers.h"
+
+namespace {
+    constexpr uint32_t kRTSize = 4;
+    constexpr uint32_t kFloat32x2Stride = 2 * sizeof(float);
+    constexpr uint32_t kFloat32x4Stride = 4 * sizeof(float);
+
+    class DrawVertexAndIndexBufferOOBValidationTests : public ValidationTest {
+      public:
+        // Parameters for testing index buffer
+        struct IndexBufferParams {
+            wgpu::IndexFormat indexFormat;
+            uint32_t indexBufferSize;              // Size for creating index buffer
+            uint32_t indexBufferOffsetForEncoder;  // Offset for SetIndexBuffer in encoder
+            uint32_t indexBufferSizeForEncoder;    // Size for SetIndexBuffer in encoder
+            uint32_t maxValidIndexNumber;  // max number of {indexCount + firstIndex} for this set
+                                           // of parameters
+        };
+
+        // Parameters for testing vertex-step-mode and instance-step-mode vertex buffer
+        struct VertexBufferParams {
+            uint32_t bufferStride;
+            uint32_t bufferSize;              // Size for creating vertex buffer
+            uint32_t bufferOffsetForEncoder;  // Offset for SetVertexBuffer in encoder
+            uint32_t bufferSizeForEncoder;    // Size for SetVertexBuffer in encoder
+            uint32_t maxValidAccessNumber;    // max number of valid access time for this set of
+                                              // parameters, i.e. {vertexCount + firstVertex} for
+            // vertex-step-mode, and {instanceCount + firstInstance}
+            // for instance-step-mode
+        };
+
+        // Parameters for setIndexBuffer
+        struct IndexBufferDesc {
+            const wgpu::Buffer buffer;
+            wgpu::IndexFormat indexFormat;
+            uint64_t offset = 0;
+            uint64_t size = 0;
+        };
+
+        // Parameters for setVertexBuffer
+        struct VertexBufferSpec {
+            uint32_t slot;
+            const wgpu::Buffer buffer;
+            uint64_t offset = 0;
+            uint64_t size = 0;
+        };
+        using VertexBufferList = std::vector<VertexBufferSpec>;
+
+        // Buffer layout parameters for creating pipeline
+        struct PipelineVertexBufferAttributeDesc {
+            uint32_t shaderLocation;
+            wgpu::VertexFormat format;
+            uint64_t offset = 0;
+        };
+        struct PipelineVertexBufferDesc {
+            uint64_t arrayStride;
+            wgpu::InputStepMode stepMode;
+            std::vector<PipelineVertexBufferAttributeDesc> attributes = {};
+        };
+
+        void SetUp() override {
+            ValidationTest::SetUp();
+
+            renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
+
+            fsModule = utils::CreateShaderModule(device, R"(
+            [[stage(fragment)]] fn main() -> [[location(0)]] vec4<f32> {
+                return vec4<f32>(0.0, 1.0, 0.0, 1.0);
+            })");
+        }
+
+        const wgpu::RenderPassDescriptor* GetBasicRenderPassDescriptor() const {
+            return &renderPass.renderPassInfo;
+        }
+
+        wgpu::Buffer CreateBuffer(uint64_t size,
+                                  wgpu::BufferUsage usage = wgpu::BufferUsage::Vertex) {
+            wgpu::BufferDescriptor descriptor;
+            descriptor.size = size;
+            descriptor.usage = usage;
+
+            return device.CreateBuffer(&descriptor);
+        }
+
+        wgpu::ShaderModule CreateVertexShaderModuleWithBuffer(
+            std::vector<PipelineVertexBufferDesc> bufferDescList) {
+            uint32_t attributeCount = 0;
+            std::stringstream inputStringStream;
+
+            for (auto buffer : bufferDescList) {
+                for (auto attr : buffer.attributes) {
+                    // [[location({shaderLocation})]] var_{id} : {typeString},
+                    inputStringStream << "[[location(" << attr.shaderLocation << ")]] var_"
+                                      << attributeCount << " : "
+                                      << dawn::GetWGSLVertexFormatType(attr.format) << ", ";
+                    attributeCount++;
+                }
+            }
+
+            std::stringstream shaderStringStream;
+
+            shaderStringStream << R"(
+            [[stage(vertex)]]
+            fn main()" << inputStringStream.str()
+                               << R"() -> [[builtin(position)]] vec4<f32> {
+                return vec4<f32>(0.0, 1.0, 0.0, 1.0);
+            })";
+
+            return utils::CreateShaderModule(device, shaderStringStream.str().c_str());
+        }
+
+        // Create a render pipeline with given buffer layout description, using a vertex shader
+        // module automatically generated from the buffer description.
+        wgpu::RenderPipeline CreateRenderPipelineWithBufferDesc(
+            std::vector<PipelineVertexBufferDesc> bufferDescList) {
+            utils::ComboRenderPipelineDescriptor descriptor;
+
+            descriptor.vertex.module = CreateVertexShaderModuleWithBuffer(bufferDescList);
+            descriptor.cFragment.module = fsModule;
+            descriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
+
+            descriptor.vertex.bufferCount = bufferDescList.size();
+
+            size_t attributeCount = 0;
+
+            for (size_t bufferCount = 0; bufferCount < bufferDescList.size(); bufferCount++) {
+                auto bufferDesc = bufferDescList[bufferCount];
+                descriptor.cBuffers[bufferCount].arrayStride = bufferDesc.arrayStride;
+                descriptor.cBuffers[bufferCount].stepMode = bufferDesc.stepMode;
+                if (bufferDesc.attributes.size() > 0) {
+                    descriptor.cBuffers[bufferCount].attributeCount = bufferDesc.attributes.size();
+                    descriptor.cBuffers[bufferCount].attributes =
+                        &descriptor.cAttributes[attributeCount];
+                    for (auto attribute : bufferDesc.attributes) {
+                        descriptor.cAttributes[attributeCount].shaderLocation =
+                            attribute.shaderLocation;
+                        descriptor.cAttributes[attributeCount].format = attribute.format;
+                        descriptor.cAttributes[attributeCount].offset = attribute.offset;
+                        attributeCount++;
+                    }
+                } else {
+                    descriptor.cBuffers[bufferCount].attributeCount = 0;
+                    descriptor.cBuffers[bufferCount].attributes = nullptr;
+                }
+            }
+
+            descriptor.cTargets[0].format = renderPass.colorFormat;
+
+            return device.CreateRenderPipeline(&descriptor);
+        }
+
+        // Create a render pipeline using only one vertex-step-mode Float32x4 buffer
+        wgpu::RenderPipeline CreateBasicRenderPipeline(uint32_t bufferStride = kFloat32x4Stride) {
+            DAWN_ASSERT(bufferStride >=
+                        dawn::VertexFormatNumComponents(wgpu::VertexFormat::Float32x4) *
+                            dawn::VertexFormatComponentSize(wgpu::VertexFormat::Float32x4));
+
+            std::vector<PipelineVertexBufferDesc> bufferDescList = {
+                {bufferStride, wgpu::InputStepMode::Vertex, {{0, wgpu::VertexFormat::Float32x4}}},
+            };
+
+            return CreateRenderPipelineWithBufferDesc(bufferDescList);
+        }
+
+        // Create a render pipeline using one vertex-step-mode Float32x4 buffer and one
+        // instance-step-mode Float32x2 buffer
+        wgpu::RenderPipeline CreateBasicRenderPipelineWithInstance(
+            uint32_t bufferStride1 = kFloat32x4Stride,
+            uint32_t bufferStride2 = kFloat32x2Stride) {
+            DAWN_ASSERT(bufferStride1 >= kFloat32x4Stride);
+            DAWN_ASSERT(bufferStride2 >= kFloat32x2Stride);
+
+            std::vector<PipelineVertexBufferDesc> bufferDescList = {
+                {bufferStride1, wgpu::InputStepMode::Vertex, {{0, wgpu::VertexFormat::Float32x4}}},
+                {bufferStride2,
+                 wgpu::InputStepMode::Instance,
+                 {{3, wgpu::VertexFormat::Float32x2}}},
+            };
+
+            return CreateRenderPipelineWithBufferDesc(bufferDescList);
+        }
+
+        void TestRenderPassDraw(const wgpu::RenderPipeline& pipeline,
+                                VertexBufferList vertexBufferList,
+                                uint32_t vertexCount,
+                                uint32_t instanceCount,
+                                uint32_t firstVertex,
+                                uint32_t firstInstance,
+                                bool isSuccess) {
+            wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+            wgpu::RenderPassEncoder renderPassEncoder =
+                encoder.BeginRenderPass(GetBasicRenderPassDescriptor());
+            renderPassEncoder.SetPipeline(pipeline);
+
+            for (auto vertexBufferParam : vertexBufferList) {
+                renderPassEncoder.SetVertexBuffer(vertexBufferParam.slot, vertexBufferParam.buffer,
+                                                  vertexBufferParam.offset, vertexBufferParam.size);
+            }
+            renderPassEncoder.Draw(vertexCount, instanceCount, firstVertex, firstInstance);
+            renderPassEncoder.EndPass();
+
+            if (isSuccess) {
+                encoder.Finish();
+            } else {
+                ASSERT_DEVICE_ERROR(encoder.Finish());
+            }
+        }
+
+        void TestRenderPassDrawIndexed(const wgpu::RenderPipeline& pipeline,
+                                       IndexBufferDesc indexBuffer,
+                                       VertexBufferList vertexBufferList,
+                                       uint32_t indexCount,
+                                       uint32_t instanceCount,
+                                       uint32_t firstIndex,
+                                       int32_t baseVertex,
+                                       uint32_t firstInstance,
+                                       bool isSuccess) {
+            wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+            wgpu::RenderPassEncoder renderPassEncoder =
+                encoder.BeginRenderPass(GetBasicRenderPassDescriptor());
+            renderPassEncoder.SetPipeline(pipeline);
+
+            renderPassEncoder.SetIndexBuffer(indexBuffer.buffer, indexBuffer.indexFormat,
+                                             indexBuffer.offset, indexBuffer.size);
+
+            for (auto vertexBufferParam : vertexBufferList) {
+                renderPassEncoder.SetVertexBuffer(vertexBufferParam.slot, vertexBufferParam.buffer,
+                                                  vertexBufferParam.offset, vertexBufferParam.size);
+            }
+            renderPassEncoder.DrawIndexed(indexCount, instanceCount, firstIndex, baseVertex,
+                                          firstInstance);
+            renderPassEncoder.EndPass();
+
+            if (isSuccess) {
+                encoder.Finish();
+            } else {
+                ASSERT_DEVICE_ERROR(encoder.Finish());
+            }
+        }
+
+        // Parameters list for index buffer. Should cover all IndexFormat, and the zero/non-zero
+        // offset and size case in SetIndexBuffer
+        const std::vector<IndexBufferParams> kIndexParamsList = {
+            {wgpu::IndexFormat::Uint32, 12 * sizeof(uint32_t), 0, 0, 12},
+            {wgpu::IndexFormat::Uint32, 13 * sizeof(uint32_t), sizeof(uint32_t), 0, 12},
+            {wgpu::IndexFormat::Uint32, 13 * sizeof(uint32_t), 0, 12 * sizeof(uint32_t), 12},
+            {wgpu::IndexFormat::Uint32, 14 * sizeof(uint32_t), sizeof(uint32_t),
+             12 * sizeof(uint32_t), 12},
+
+            {wgpu::IndexFormat::Uint16, 12 * sizeof(uint16_t), 0, 0, 12},
+            {wgpu::IndexFormat::Uint16, 13 * sizeof(uint16_t), sizeof(uint16_t), 0, 12},
+            {wgpu::IndexFormat::Uint16, 13 * sizeof(uint16_t), 0, 12 * sizeof(uint16_t), 12},
+            {wgpu::IndexFormat::Uint16, 14 * sizeof(uint16_t), sizeof(uint16_t),
+             12 * sizeof(uint16_t), 12},
+        };
+        // Parameters list for vertex-step-mode buffer. These parameters should cover different
+        // stride, buffer size, SetVertexBuffer size and offset.
+        const std::vector<VertexBufferParams> kVertexParamsList = {
+            // For stride = kFloat32x4Stride
+            {kFloat32x4Stride, 3 * kFloat32x4Stride, 0, 0, 3},
+            // Non-zero offset
+            {kFloat32x4Stride, 4 * kFloat32x4Stride, kFloat32x4Stride, 0, 3},
+            // Non-zero size
+            {kFloat32x4Stride, 4 * kFloat32x4Stride, 0, 3 * kFloat32x4Stride, 3},
+            // Non-zero offset and size
+            {kFloat32x4Stride, 5 * kFloat32x4Stride, kFloat32x4Stride, 3 * kFloat32x4Stride, 3},
+            // For stride = 2 * kFloat32x4Stride
+            {(2 * kFloat32x4Stride), 3 * (2 * kFloat32x4Stride), 0, 0, 3},
+            // Non-zero offset
+            {(2 * kFloat32x4Stride), 4 * (2 * kFloat32x4Stride), (2 * kFloat32x4Stride), 0, 3},
+            // Non-zero size
+            {(2 * kFloat32x4Stride), 4 * (2 * kFloat32x4Stride), 0, 3 * (2 * kFloat32x4Stride), 3},
+            // Non-zero offset and size
+            {(2 * kFloat32x4Stride), 5 * (2 * kFloat32x4Stride), (2 * kFloat32x4Stride),
+             3 * (2 * kFloat32x4Stride), 3},
+        };
+        // Parameters list for instance-step-mode buffer.
+        const std::vector<VertexBufferParams> kInstanceParamsList = {
+            // For stride = kFloat32x2Stride
+            {kFloat32x2Stride, 5 * kFloat32x2Stride, 0, 0, 5},
+            // Non-zero offset
+            {kFloat32x2Stride, 6 * kFloat32x2Stride, kFloat32x2Stride, 0, 5},
+            // Non-zero size
+            {kFloat32x2Stride, 6 * kFloat32x2Stride, 0, 5 * kFloat32x2Stride, 5},
+            // Non-zero offset and size
+            {kFloat32x2Stride, 7 * kFloat32x2Stride, kFloat32x2Stride, 5 * kFloat32x2Stride, 5},
+            // For stride = 3 * kFloat32x2Stride
+            {(3 * kFloat32x2Stride), 5 * (3 * kFloat32x2Stride), 0, 0, 5},
+            // Non-zero offset
+            {(3 * kFloat32x2Stride), 6 * (3 * kFloat32x2Stride), (3 * kFloat32x2Stride), 0, 5},
+            // Non-zero size
+            {(3 * kFloat32x2Stride), 6 * (3 * kFloat32x2Stride), 0, 5 * (3 * kFloat32x2Stride), 5},
+            // Non-zero offset and size
+            {(3 * kFloat32x2Stride), 7 * (3 * kFloat32x2Stride), (3 * kFloat32x2Stride),
+             5 * (3 * kFloat32x2Stride), 5},
+        };
+
+      private:
+        wgpu::ShaderModule fsModule;
+        utils::BasicRenderPass renderPass;
+    };
+
+    // Control case for Draw
+    TEST_F(DrawVertexAndIndexBufferOOBValidationTests, DrawBasic) {
+        wgpu::RenderPipeline pipeline = CreateBasicRenderPipeline();
+
+        wgpu::Buffer vertexBuffer = CreateBuffer(3 * kFloat32x4Stride);
+
+        VertexBufferList vertexBufferList = {{0, vertexBuffer, 0, 0}};
+        TestRenderPassDraw(pipeline, vertexBufferList, 3, 1, 0, 0, true);
+    }
+
+    // Verify vertex buffer OOB for non-instanced Draw are caught in command encoder
+    TEST_F(DrawVertexAndIndexBufferOOBValidationTests, DrawVertexBufferOutOfBoundWithoutInstance) {
+        for (VertexBufferParams params : kVertexParamsList) {
+            // Create a render pipeline without instance step mode buffer
+            wgpu::RenderPipeline pipeline = CreateBasicRenderPipeline(params.bufferStride);
+
+            // Build vertex buffer for 3 vertices
+            wgpu::Buffer vertexBuffer = CreateBuffer(params.bufferSize);
+            VertexBufferList vertexBufferList = {
+                {0, vertexBuffer, params.bufferOffsetForEncoder, params.bufferSizeForEncoder}};
+
+            uint32_t n = params.maxValidAccessNumber;
+            // It is ok to draw n vertices with vertex buffer
+            TestRenderPassDraw(pipeline, vertexBufferList, n, 1, 0, 0, true);
+            // It is ok to draw n-1 vertices with offset 1
+            TestRenderPassDraw(pipeline, vertexBufferList, n - 1, 1, 1, 0, true);
+            // Drawing more vertices will cause OOB, even if not enough for another primitive
+            TestRenderPassDraw(pipeline, vertexBufferList, n + 1, 1, 0, 0, false);
+            // Drawing n vertices will non-zero offset will cause OOB
+            TestRenderPassDraw(pipeline, vertexBufferList, n, 1, 1, 0, false);
+            // It is ok to draw any number of instances, as we have no instance-mode buffer
+            TestRenderPassDraw(pipeline, vertexBufferList, n, 5, 0, 0, true);
+            TestRenderPassDraw(pipeline, vertexBufferList, n, 5, 0, 5, true);
+        }
+    }
+
+    // Verify vertex buffer OOB for instanced Draw are caught in command encoder
+    TEST_F(DrawVertexAndIndexBufferOOBValidationTests, DrawVertexBufferOutOfBoundWithInstance) {
+        for (VertexBufferParams vertexParams : kVertexParamsList) {
+            for (VertexBufferParams instanceParams : kInstanceParamsList) {
+                // Create pipeline with given buffer stride
+                wgpu::RenderPipeline pipeline = CreateBasicRenderPipelineWithInstance(
+                    vertexParams.bufferStride, instanceParams.bufferStride);
+
+                // Build vertex buffer
+                wgpu::Buffer vertexBuffer = CreateBuffer(vertexParams.bufferSize);
+                wgpu::Buffer instanceBuffer = CreateBuffer(instanceParams.bufferSize);
+
+                VertexBufferList vertexBufferList = {
+                    {0, vertexBuffer, vertexParams.bufferOffsetForEncoder,
+                     vertexParams.bufferSizeForEncoder},
+                    {1, instanceBuffer, instanceParams.bufferOffsetForEncoder,
+                     instanceParams.bufferSizeForEncoder},
+                };
+
+                uint32_t vert = vertexParams.maxValidAccessNumber;
+                uint32_t inst = instanceParams.maxValidAccessNumber;
+                // It is ok to draw vert vertices
+                TestRenderPassDraw(pipeline, vertexBufferList, vert, 1, 0, 0, true);
+                TestRenderPassDraw(pipeline, vertexBufferList, vert - 1, 1, 1, 0, true);
+                // It is ok to draw vert vertices and inst instences
+                TestRenderPassDraw(pipeline, vertexBufferList, vert, inst, 0, 0, true);
+                TestRenderPassDraw(pipeline, vertexBufferList, vert, inst - 1, 0, 1, true);
+                // more vertices causing OOB
+                TestRenderPassDraw(pipeline, vertexBufferList, vert + 1, 1, 0, 0, false);
+                TestRenderPassDraw(pipeline, vertexBufferList, vert, 1, 1, 0, false);
+                TestRenderPassDraw(pipeline, vertexBufferList, vert + 1, inst, 0, 0, false);
+                TestRenderPassDraw(pipeline, vertexBufferList, vert, inst, 1, 0, false);
+                // more instances causing OOB
+                TestRenderPassDraw(pipeline, vertexBufferList, vert, inst + 1, 0, 0, false);
+                TestRenderPassDraw(pipeline, vertexBufferList, vert, inst, 0, 1, false);
+                // Both OOB
+                TestRenderPassDraw(pipeline, vertexBufferList, vert, inst + 1, 0, 0, false);
+                TestRenderPassDraw(pipeline, vertexBufferList, vert, inst, 1, 1, false);
+            }
+        }
+    }
+
+    // Control case for DrawIndexed
+    TEST_F(DrawVertexAndIndexBufferOOBValidationTests, DrawIndexedBasic) {
+        wgpu::RenderPipeline pipeline = CreateBasicRenderPipeline();
+
+        // Build index buffer for 12 indexes
+        wgpu::Buffer indexBuffer = CreateBuffer(12 * sizeof(uint32_t), wgpu::BufferUsage::Index);
+
+        // Build vertex buffer for 3 vertices
+        wgpu::Buffer vertexBuffer = CreateBuffer(3 * kFloat32x4Stride);
+        VertexBufferList vertexBufferList = {{0, vertexBuffer, 0, 0}};
+
+        IndexBufferDesc indexBufferDesc = {indexBuffer, wgpu::IndexFormat::Uint32};
+
+        TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, 12, 1, 0, 0, 0,
+                                  true);
+    }
+
+    // Verify index buffer OOB for DrawIndexed are caught in command encoder
+    TEST_F(DrawVertexAndIndexBufferOOBValidationTests, DrawIndexedIndexBufferOOB) {
+        wgpu::RenderPipeline pipeline = CreateBasicRenderPipelineWithInstance();
+
+        for (IndexBufferParams params : kIndexParamsList) {
+            // Build index buffer use given params
+            wgpu::Buffer indexBuffer =
+                CreateBuffer(params.indexBufferSize, wgpu::BufferUsage::Index);
+            // Build vertex buffer for 3 vertices
+            wgpu::Buffer vertexBuffer = CreateBuffer(3 * kFloat32x4Stride);
+            // Build vertex buffer for 5 instances
+            wgpu::Buffer instanceBuffer = CreateBuffer(5 * kFloat32x2Stride);
+
+            VertexBufferList vertexBufferList = {{0, vertexBuffer, 0, 0},
+                                                 {1, instanceBuffer, 0, 0}};
+
+            IndexBufferDesc indexBufferDesc = {indexBuffer, params.indexFormat,
+                                               params.indexBufferOffsetForEncoder,
+                                               params.indexBufferSizeForEncoder};
+
+            uint32_t n = params.maxValidIndexNumber;
+
+            // Control case
+            TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, n, 5, 0, 0, 0,
+                                      true);
+            TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, n - 1, 5, 1, 0,
+                                      0, true);
+            // Index buffer OOB, indexCount too large
+            TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, n + 1, 5, 0, 0,
+                                      0, false);
+            // Index buffer OOB, indexCount + firstIndex too large
+            TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, n, 5, 1, 0, 0,
+                                      false);
+
+            if (!HasToggleEnabled("disable_base_vertex")) {
+                // baseVertex is not considered in CPU validation and has no effect on validation
+                // Although baseVertex is too large, it will still pass
+                TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, n, 5, 0, 100,
+                                          0, true);
+                // Index buffer OOB, indexCount too large
+                TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, n + 1, 5, 0,
+                                          100, 0, false);
+            }
+        }
+    }
+
+    // Verify instance mode vertex buffer OOB for DrawIndexed are caught in command encoder
+    TEST_F(DrawVertexAndIndexBufferOOBValidationTests, DrawIndexedVertexBufferOOB) {
+        for (VertexBufferParams vertexParams : kVertexParamsList) {
+            for (VertexBufferParams instanceParams : kInstanceParamsList) {
+                // Create pipeline with given buffer stride
+                wgpu::RenderPipeline pipeline = CreateBasicRenderPipelineWithInstance(
+                    vertexParams.bufferStride, instanceParams.bufferStride);
+
+                auto indexFormat = wgpu::IndexFormat::Uint32;
+                auto indexStride = sizeof(uint32_t);
+
+                // Build index buffer for 12 indexes
+                wgpu::Buffer indexBuffer = CreateBuffer(12 * indexStride, wgpu::BufferUsage::Index);
+                // Build vertex buffer for vertices
+                wgpu::Buffer vertexBuffer = CreateBuffer(vertexParams.bufferSize);
+                // Build vertex buffer for instances
+                wgpu::Buffer instanceBuffer = CreateBuffer(instanceParams.bufferSize);
+
+                VertexBufferList vertexBufferList = {
+                    {0, vertexBuffer, vertexParams.bufferOffsetForEncoder,
+                     vertexParams.bufferSizeForEncoder},
+                    {1, instanceBuffer, instanceParams.bufferOffsetForEncoder,
+                     instanceParams.bufferSizeForEncoder}};
+
+                IndexBufferDesc indexBufferDesc = {indexBuffer, indexFormat};
+
+                uint32_t vert = vertexParams.maxValidAccessNumber;
+                uint32_t inst = instanceParams.maxValidAccessNumber;
+                // Control case
+                TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, vert, inst,
+                                          0, 0, 0, true);
+                // Vertex buffer (stepMode = instance) OOB, instanceCount too large
+                TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, vert,
+                                          inst + 1, 0, 0, 0, false);
+
+                if (!HasToggleEnabled("disable_base_instance")) {
+                    // firstInstance is considered in CPU validation
+                    // Vertex buffer (stepMode = instance) in bound
+                    TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, vert,
+                                              inst - 1, 0, 0, 1, true);
+                    // Vertex buffer (stepMode = instance) OOB, instanceCount + firstInstance too
+                    // large
+                    TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, vert,
+                                              inst, 0, 0, 1, false);
+                }
+
+                // OOB of vertex buffer that stepMode=vertex can not be validated in CPU.
+                TestRenderPassDrawIndexed(pipeline, indexBufferDesc, vertexBufferList, vert + 1,
+                                          inst, 0, 0, 0, true);
+            }
+        }
+    }
+
+    // Verify that if setVertexBuffer and/or setIndexBuffer for multiple times, only the last one is
+    // taken into account
+    TEST_F(DrawVertexAndIndexBufferOOBValidationTests, SetBufferMultipleTime) {
+        wgpu::IndexFormat indexFormat = wgpu::IndexFormat::Uint32;
+        uint32_t indexStride = sizeof(uint32_t);
+
+        // Build index buffer for 11 indexes
+        wgpu::Buffer indexBuffer11 = CreateBuffer(11 * indexStride, wgpu::BufferUsage::Index);
+        // Build index buffer for 12 indexes
+        wgpu::Buffer indexBuffer12 = CreateBuffer(12 * indexStride, wgpu::BufferUsage::Index);
+        // Build vertex buffer for 2 vertices
+        wgpu::Buffer vertexBuffer2 = CreateBuffer(2 * kFloat32x4Stride);
+        // Build vertex buffer for 3 vertices
+        wgpu::Buffer vertexBuffer3 = CreateBuffer(3 * kFloat32x4Stride);
+        // Build vertex buffer for 4 instances
+        wgpu::Buffer instanceBuffer4 = CreateBuffer(4 * kFloat32x2Stride);
+        // Build vertex buffer for 5 instances
+        wgpu::Buffer instanceBuffer5 = CreateBuffer(5 * kFloat32x2Stride);
+
+        // Test for setting vertex buffer for multiple times
+        {
+            wgpu::RenderPipeline pipeline = CreateBasicRenderPipelineWithInstance();
+
+            // Set to vertexBuffer3 and instanceBuffer5 at last
+            VertexBufferList vertexBufferList = {{0, vertexBuffer2, 0, 0},
+                                                 {1, instanceBuffer4, 0, 0},
+                                                 {1, instanceBuffer5, 0, 0},
+                                                 {0, vertexBuffer3, 0, 0}};
+
+            // For Draw, the max vertexCount is 3 and the max instanceCount is 5
+            TestRenderPassDraw(pipeline, vertexBufferList, 3, 5, 0, 0, true);
+            TestRenderPassDraw(pipeline, vertexBufferList, 4, 5, 0, 0, false);
+            TestRenderPassDraw(pipeline, vertexBufferList, 3, 6, 0, 0, false);
+            // For DrawIndex, the max instanceCount is 5
+            TestRenderPassDrawIndexed(pipeline, {indexBuffer12, indexFormat}, vertexBufferList, 12,
+                                      5, 0, 0, 0, true);
+            TestRenderPassDrawIndexed(pipeline, {indexBuffer12, indexFormat}, vertexBufferList, 12,
+                                      6, 0, 0, 0, false);
+
+            // Set to vertexBuffer2 and instanceBuffer4 at last
+            vertexBufferList = VertexBufferList{{0, vertexBuffer3, 0, 0},
+                                                {1, instanceBuffer5, 0, 0},
+                                                {0, vertexBuffer2, 0, 0},
+                                                {1, instanceBuffer4, 0, 0}};
+
+            // For Draw, the max vertexCount is 2 and the max instanceCount is 4
+            TestRenderPassDraw(pipeline, vertexBufferList, 2, 4, 0, 0, true);
+            TestRenderPassDraw(pipeline, vertexBufferList, 3, 4, 0, 0, false);
+            TestRenderPassDraw(pipeline, vertexBufferList, 2, 5, 0, 0, false);
+            // For DrawIndex, the max instanceCount is 4
+            TestRenderPassDrawIndexed(pipeline, {indexBuffer12, indexFormat}, vertexBufferList, 12,
+                                      4, 0, 0, 0, true);
+            TestRenderPassDrawIndexed(pipeline, {indexBuffer12, indexFormat}, vertexBufferList, 12,
+                                      5, 0, 0, 0, false);
+        }
+
+        // Test for setIndexBuffer multiple times
+        {
+            wgpu::RenderPipeline pipeline = CreateBasicRenderPipeline();
+
+            VertexBufferList vertexBufferList = {{0, vertexBuffer3, 0, 0}};
+
+            {
+                wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+                wgpu::RenderPassEncoder renderPassEncoder =
+                    encoder.BeginRenderPass(GetBasicRenderPassDescriptor());
+                renderPassEncoder.SetPipeline(pipeline);
+
+                // Index buffer is set to indexBuffer12 at last
+                renderPassEncoder.SetIndexBuffer(indexBuffer11, indexFormat);
+                renderPassEncoder.SetIndexBuffer(indexBuffer12, indexFormat);
+
+                renderPassEncoder.SetVertexBuffer(0, vertexBuffer3, 0, 0);
+                // It should be ok to draw 12 index
+                renderPassEncoder.DrawIndexed(12, 1, 0, 0, 0);
+                renderPassEncoder.EndPass();
+
+                // Expect success
+                encoder.Finish();
+            }
+
+            {
+                wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+                wgpu::RenderPassEncoder renderPassEncoder =
+                    encoder.BeginRenderPass(GetBasicRenderPassDescriptor());
+                renderPassEncoder.SetPipeline(pipeline);
+
+                // Index buffer is set to indexBuffer12 at last
+                renderPassEncoder.SetIndexBuffer(indexBuffer11, indexFormat);
+                renderPassEncoder.SetIndexBuffer(indexBuffer12, indexFormat);
+
+                renderPassEncoder.SetVertexBuffer(0, vertexBuffer3, 0, 0);
+                // It should be index buffer OOB to draw 13 index
+                renderPassEncoder.DrawIndexed(13, 1, 0, 0, 0);
+                renderPassEncoder.EndPass();
+
+                // Expect failure
+                ASSERT_DEVICE_ERROR(encoder.Finish());
+            }
+
+            {
+                wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+                wgpu::RenderPassEncoder renderPassEncoder =
+                    encoder.BeginRenderPass(GetBasicRenderPassDescriptor());
+                renderPassEncoder.SetPipeline(pipeline);
+
+                // Index buffer is set to indexBuffer11 at last
+                renderPassEncoder.SetIndexBuffer(indexBuffer12, indexFormat);
+                renderPassEncoder.SetIndexBuffer(indexBuffer11, indexFormat);
+
+                renderPassEncoder.SetVertexBuffer(0, vertexBuffer3, 0, 0);
+                // It should be ok to draw 11 index
+                renderPassEncoder.DrawIndexed(11, 1, 0, 0, 0);
+                renderPassEncoder.EndPass();
+
+                // Expect success
+                encoder.Finish();
+            }
+
+            {
+                wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+                wgpu::RenderPassEncoder renderPassEncoder =
+                    encoder.BeginRenderPass(GetBasicRenderPassDescriptor());
+                renderPassEncoder.SetPipeline(pipeline);
+
+                // Index buffer is set to indexBuffer11 at last
+                renderPassEncoder.SetIndexBuffer(indexBuffer12, indexFormat);
+                renderPassEncoder.SetIndexBuffer(indexBuffer11, indexFormat);
+
+                renderPassEncoder.SetVertexBuffer(0, vertexBuffer3, 0, 0);
+                // It should be index buffer OOB to draw 12 index
+                renderPassEncoder.DrawIndexed(12, 1, 0, 0, 0);
+                renderPassEncoder.EndPass();
+
+                // Expect failure
+                ASSERT_DEVICE_ERROR(encoder.Finish());
+            }
+        }
+    }
+
+}  // anonymous namespace