//
// Copyright 2015 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// DrawElementsTest:
//   Tests for indexed draws.
//

#include "common/unsafe_buffers.h"
#include "test_utils/ANGLETest.h"
#include "test_utils/gl_raii.h"

using namespace angle;

namespace
{

class DrawElementsTest : public ANGLETest<>
{
  protected:
    DrawElementsTest() : mProgram(0u)
    {
        setWindowWidth(64);
        setWindowHeight(64);
        setConfigRedBits(8);
        setConfigGreenBits(8);
        setConfigBlueBits(8);
        setConfigAlphaBits(8);
    }

    ~DrawElementsTest()
    {
        for (GLuint indexBuffer : mIndexBuffers)
        {
            if (indexBuffer != 0)
            {
                glDeleteBuffers(1, &indexBuffer);
            }
        }

        for (GLuint vertexArray : mVertexArrays)
        {
            if (vertexArray != 0)
            {
                glDeleteVertexArrays(1, &vertexArray);
            }
        }

        for (GLuint vertexBuffer : mVertexBuffers)
        {
            if (vertexBuffer != 0)
            {
                glDeleteBuffers(1, &vertexBuffer);
            }
        }

        if (mProgram != 0u)
        {
            glDeleteProgram(mProgram);
        }
    }

    std::vector<GLuint> mIndexBuffers;
    std::vector<GLuint> mVertexArrays;
    std::vector<GLuint> mVertexBuffers;
    GLuint mProgram;
};

class WebGLDrawElementsTest : public DrawElementsTest
{
  public:
    WebGLDrawElementsTest() { setWebGLCompatibilityEnabled(true); }
};

template <typename T, typename U>
std::vector<T> convertIndexBufferWithRestarts(const std::vector<U> &input)
{
    constexpr U inputRestart  = std::numeric_limits<U>::max();
    constexpr T outputRestart = std::numeric_limits<T>::max();
    std::vector<T> output;
    output.reserve(input.size());
    for (auto byte : input)
    {
        output.push_back(byte == inputRestart ? outputRestart : static_cast<T>(byte));
    }
    return output;
}

enum class PrimitiveRestartMode
{
    Disabled,
    Enabled,
    EnabledSplitContent,
};

enum class IndicesMode
{
    Buffer,
    BufferAndOffset,
    ClientSideArray,
};

enum class RestartOption
{
    None,
    AtBegin,
    AtEnd,
    Degenerate,
};

using DrawElementsVariantsTestParams = std::tuple<angle::PlatformParameters,
                                                  GLenum,                // type
                                                  bool,                  // useFlat
                                                  PrimitiveRestartMode,  // primitiveRestartMode
                                                  bool,                  // drawStrip
                                                  IndicesMode,           // indicesMode
                                                  RestartOption,         // restartOption
                                                  bool>;                 // useProvokingVertexFirst

std::string DrawElementsVariantsTestPrint(
    const ::testing::TestParamInfo<DrawElementsVariantsTestParams> &paramsInfo)
{
    const auto &[platform, type, useFlat, primitiveRestartMode, drawStrip, indicesMode,
                 restartOption, useProvokingVertexFirst] = paramsInfo.param;
    std::ostringstream out;
    out << platform << "__"
        << (type == GL_UNSIGNED_BYTE ? "B" : (type == GL_UNSIGNED_SHORT ? "S" : "I"))
        << (useFlat ? "_Flat" : "");
    switch (primitiveRestartMode)
    {
        case PrimitiveRestartMode::Disabled:
            break;
        case PrimitiveRestartMode::Enabled:
            out << "_Restart";
            break;
        case PrimitiveRestartMode::EnabledSplitContent:
            out << "_Split";
            break;
    }
    out << (drawStrip ? "_Strip" : "_Tris");
    switch (indicesMode)
    {
        case IndicesMode::Buffer:
            break;
        case IndicesMode::BufferAndOffset:
            out << "_Offset";
            break;
        case IndicesMode::ClientSideArray:
            out << "_Client";
            break;
    }
    switch (restartOption)
    {
        case RestartOption::None:
            break;
        case RestartOption::AtBegin:
            out << "_AtBegin";
            break;
        case RestartOption::AtEnd:
            out << "_AtEnd";
            break;
        case RestartOption::Degenerate:
            out << "_Degen";
            break;
    }
    out << (useProvokingVertexFirst ? "_First" : "");
    return out.str();
}

class DrawElementsVariantsTest : public ANGLETest<DrawElementsVariantsTestParams>
{
  protected:
    DrawElementsVariantsTest()
    {
        setWindowWidth(64);
        setWindowHeight(64);
        setConfigRedBits(8);
        setConfigGreenBits(8);
        setConfigBlueBits(8);
        setConfigAlphaBits(8);
    }

    GLenum type() const { return std::get<1>(GetParam()); }
    bool useFlat() const { return std::get<2>(GetParam()); }
    PrimitiveRestartMode primitiveRestartMode() const { return std::get<3>(GetParam()); }
    bool drawStrip() const { return std::get<4>(GetParam()); }
    IndicesMode indicesMode() const { return std::get<5>(GetParam()); }
    RestartOption restartOption() const { return std::get<6>(GetParam()); }
    bool addRestartAtBegin() const { return restartOption() == RestartOption::AtBegin; }
    bool addRestartAtEnd() const { return restartOption() == RestartOption::AtEnd; }
    bool addRestartDegenerate() const { return restartOption() == RestartOption::Degenerate; }
    bool useProvokingVertexFirst() const { return std::get<7>(GetParam()); }

    bool usePrimitiveRestart() const
    {
        return primitiveRestartMode() != PrimitiveRestartMode::Disabled;
    }
    bool splitContent() const
    {
        return primitiveRestartMode() == PrimitiveRestartMode::EnabledSplitContent;
    }
    bool addOffset() const { return indicesMode() == IndicesMode::BufferAndOffset; }
    bool useClientSideArrays() const { return indicesMode() == IndicesMode::ClientSideArray; }
};

// Test no error is generated when using client-side arrays, indices = nullptr and count = 0
TEST_P(DrawElementsTest, ClientSideNullptrArrayZeroCount)
{
    constexpr char kVS[] =
        "attribute vec3 a_pos;\n"
        "void main()\n"
        "{\n"
        "    gl_Position = vec4(a_pos, 1.0);\n"
        "}\n";

    ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Blue());

    GLint posLocation = glGetAttribLocation(program, "a_pos");
    ASSERT_NE(-1, posLocation);
    glUseProgram(program);

    const auto &vertices = GetQuadVertices();

    GLBuffer vertexBuffer;
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);
    ASSERT_GL_NO_ERROR();

    // "If drawElements is called with a count greater than zero, and no WebGLBuffer is bound to the
    // ELEMENT_ARRAY_BUFFER binding point, an INVALID_OPERATION error is generated."
    glDrawElements(GL_TRIANGLES, 1, GL_UNSIGNED_BYTE, nullptr);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    // count == 0 so it's fine to have no element array buffer bound.
    glDrawElements(GL_TRIANGLES, 0, GL_UNSIGNED_BYTE, nullptr);
    ASSERT_GL_NO_ERROR();
}

// Test uploading part of an index buffer after deleting a vertex array
// previously used for DrawElements.
TEST_P(DrawElementsTest, DeleteVertexArrayAndUploadIndex)
{
    const auto &vertices = GetIndexedQuadVertices();
    const auto &indices  = GetQuadIndices();

    ANGLE_GL_PROGRAM(programDrawRed, essl3_shaders::vs::Simple(), essl3_shaders::fs::Red());
    glUseProgram(programDrawRed);

    GLint posLocation = glGetAttribLocation(programDrawRed, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);

    GLuint vertexArray;
    glGenVertexArrays(1, &vertexArray);
    glBindVertexArray(vertexArray);

    GLBuffer vertexBuffer;
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);

    GLBuffer indexBuffer;
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices[0]) * indices.size(), indices.data(),
                 GL_STATIC_DRAW);

    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr);

    glDeleteVertexArrays(1, &vertexArray);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);

    // Could crash here if the observer binding from the vertex array doesn't get
    // removed on vertex array destruction.
    glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(indices[0]) * 3, indices.data());

    ASSERT_GL_NO_ERROR();
}

// Test VAO switch is handling cached element array buffer properly along with line loop mode
// switch.
TEST_P(DrawElementsTest, LineLoopTriangles)
{
    const auto &vertices                    = GetIndexedQuadVertices();
    constexpr std::array<GLuint, 6> indices = {{0, 1, 2, 0, 2, 3}};

    ANGLE_GL_PROGRAM(programDrawRed, essl3_shaders::vs::Simple(), essl3_shaders::fs::Red());
    ANGLE_GL_PROGRAM(programDrawBlue, essl3_shaders::vs::Simple(), essl3_shaders::fs::Blue());

    glUseProgram(programDrawRed);
    GLint posLocation = glGetAttribLocation(programDrawRed, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);

    GLVertexArray vertexArray[2];
    GLBuffer vertexBuffer[2];

    glBindVertexArray(vertexArray[0]);

    GLBuffer indexBuffer;
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices[0]) * indices.size(), indices.data(),
                 GL_STATIC_DRAW);

    for (int i = 0; i < 2; i++)
    {
        glBindVertexArray(ANGLE_UNSAFE_TODO(vertexArray[i]));
        glBindBuffer(GL_ARRAY_BUFFER, ANGLE_UNSAFE_TODO(vertexBuffer[i]));
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                     GL_STATIC_DRAW);
        glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(posLocation);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    }

    // First draw with VAO0 and line loop mode
    glBindVertexArray(vertexArray[0]);
    glDrawArrays(GL_LINE_LOOP, 0, 4);

    // Switch to VAO1 and draw with triangle mode.
    glBindVertexArray(vertexArray[1]);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, 0, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(0, getWindowHeight() - 1, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 1, GLColor::red);

    // Switch back to VAO0 and draw with triangle mode.
    glUseProgram(programDrawBlue);
    glBindVertexArray(vertexArray[0]);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::blue);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, 0, GLColor::blue);
    EXPECT_PIXEL_COLOR_EQ(0, getWindowHeight() - 1, GLColor::blue);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 1, GLColor::blue);
    ASSERT_GL_NO_ERROR();
}

// Regression test for using two VAOs, one to draw only GL_LINE_LOOPs, and
// another to draw indexed triangles.
TEST_P(DrawElementsTest, LineLoopTriangles2)
{
    const auto &vertices                    = GetIndexedQuadVertices();
    constexpr std::array<GLuint, 6> indices = {{0, 1, 2, 0, 2, 3}};

    ANGLE_GL_PROGRAM(programDrawRed, essl3_shaders::vs::Simple(), essl3_shaders::fs::Red());

    glUseProgram(programDrawRed);
    GLint posLocation = glGetAttribLocation(programDrawRed, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);

    GLVertexArray vertexArray[2];
    GLBuffer vertexBuffer[2];

    GLBuffer indexBuffer;
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices[0]) * indices.size(), indices.data(),
                 GL_STATIC_DRAW);

    for (int i = 0; i < 2; i++)
    {
        glBindVertexArray(ANGLE_UNSAFE_TODO(vertexArray[i]));
        glBindBuffer(GL_ARRAY_BUFFER, ANGLE_UNSAFE_TODO(vertexBuffer[i]));
        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                     GL_STATIC_DRAW);
        glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(posLocation);
        if (i != 0)
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    }

    // First draw with VAO0 and line loop mode
    glBindVertexArray(vertexArray[0]);
    glDrawArrays(GL_LINE_LOOP, 0, 4);

    // Switch to VAO1 and draw some indexed triangles
    glBindVertexArray(vertexArray[1]);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);

    // Switch back to VAO0 and do another line loop
    glBindVertexArray(vertexArray[0]);

    // Would crash if the index buffer dirty bit got errantly set on VAO0.
    glDrawArrays(GL_LINE_LOOP, 0, 4);

    ASSERT_GL_NO_ERROR();
}

// Test a state desync that can occur when using a streaming index buffer in GL in concert with
// deleting the applied index buffer.
TEST_P(DrawElementsTest, DeletingAfterStreamingIndexes)
{
    // Init program
    constexpr char kVS[] =
        "attribute vec2 position;\n"
        "attribute vec2 testFlag;\n"
        "varying vec2 v_data;\n"
        "void main() {\n"
        "  gl_Position = vec4(position, 0, 1);\n"
        "  v_data = testFlag;\n"
        "}";

    constexpr char kFS[] =
        "varying highp vec2 v_data;\n"
        "void main() {\n"
        "  gl_FragColor = vec4(v_data, 0, 1);\n"
        "}";

    mProgram = CompileProgram(kVS, kFS);
    ASSERT_NE(0u, mProgram);
    glUseProgram(mProgram);

    GLint positionLocation = glGetAttribLocation(mProgram, "position");
    ASSERT_NE(-1, positionLocation);

    GLint testFlagLocation = glGetAttribLocation(mProgram, "testFlag");
    ASSERT_NE(-1, testFlagLocation);

    mIndexBuffers.resize(3u);
    glGenBuffers(3, &mIndexBuffers[0]);

    mVertexArrays.resize(2);
    glGenVertexArrays(2, &mVertexArrays[0]);

    mVertexBuffers.resize(2);
    glGenBuffers(2, &mVertexBuffers[0]);

    std::vector<GLuint> indexData[2];
    indexData[0].push_back(0);
    indexData[0].push_back(1);
    indexData[0].push_back(2);
    indexData[0].push_back(2);
    indexData[0].push_back(3);
    indexData[0].push_back(0);

    indexData[1] = indexData[0];
    for (GLuint &item : indexData[1])
    {
        item += 4u;
    }

    std::vector<GLfloat> positionData = {// quad verts
                                         -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f,
                                         // Repeat position data
                                         -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f};

    std::vector<GLfloat> testFlagData = {// red
                                         1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
                                         // green
                                         0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f};

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffers[0]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indexData[0].size(), &indexData[0][0],
                 GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffers[2]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indexData[0].size(), &indexData[0][0],
                 GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffers[1]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indexData[1].size(), &indexData[1][0],
                 GL_STATIC_DRAW);

    // Initialize first vertex array with second index buffer
    glBindVertexArray(mVertexArrays[0]);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffers[1]);
    glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffers[0]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * positionData.size(), &positionData[0],
                 GL_STATIC_DRAW);
    glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 2, nullptr);
    glEnableVertexAttribArray(positionLocation);

    glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffers[1]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * testFlagData.size(), &testFlagData[0],
                 GL_STATIC_DRAW);
    glVertexAttribPointer(testFlagLocation, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 2, nullptr);
    glEnableVertexAttribArray(testFlagLocation);

    // Initialize second vertex array with first index buffer
    glBindVertexArray(mVertexArrays[1]);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffers[0]);

    glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffers[0]);
    glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 2, nullptr);
    glEnableVertexAttribArray(positionLocation);

    glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffers[1]);
    glVertexAttribPointer(testFlagLocation, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 2, nullptr);
    glEnableVertexAttribArray(testFlagLocation);

    ASSERT_GL_NO_ERROR();

    glBindVertexArray(mVertexArrays[0]);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);

    glBindVertexArray(mVertexArrays[1]);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);

    glBindVertexArray(mVertexArrays[0]);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);

    // Trigger the bug here.
    glDeleteBuffers(1, &mIndexBuffers[2]);

    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);

    ASSERT_GL_NO_ERROR();
}

// Verify that detaching shaders after linking doesn't break draw calls
TEST_P(DrawElementsTest, DrawWithDetachedShaders)
{
    const auto &vertices = GetIndexedQuadVertices();

    GLBuffer vertexBuffer;
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    GLBuffer indexBuffer;
    const auto &indices = GetQuadIndices();
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices[0]) * indices.size(), indices.data(),
                 GL_STATIC_DRAW);
    ASSERT_GL_NO_ERROR();

    GLuint vertexShader   = CompileShader(GL_VERTEX_SHADER, essl3_shaders::vs::Simple());
    GLuint fragmentShader = CompileShader(GL_FRAGMENT_SHADER, essl3_shaders::fs::Red());
    ASSERT_NE(0u, vertexShader);
    ASSERT_NE(0u, fragmentShader);

    GLuint program = glCreateProgram();
    glAttachShader(program, vertexShader);
    glAttachShader(program, fragmentShader);

    glLinkProgram(program);

    GLint linkStatus;
    glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
    EXPECT_EQ(GL_TRUE, linkStatus);

    glDetachShader(program, vertexShader);
    glDetachShader(program, fragmentShader);
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    ASSERT_GL_NO_ERROR();

    glUseProgram(program);

    GLint posLocation = glGetAttribLocation(program, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);

    GLVertexArray vertexArray;
    glBindVertexArray(vertexArray);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr);
    ASSERT_GL_NO_ERROR();

    glDeleteProgram(program);
    ASSERT_GL_NO_ERROR();
}

// Test drawing to part of the indices in an index buffer, and then all of them.
TEST_P(DrawElementsTest, PartOfIndexBufferThenAll)
{
    // Init program
    constexpr char kVS[] =
        "attribute vec2 position;\n"
        "attribute vec2 testFlag;\n"
        "varying vec2 v_data;\n"
        "void main() {\n"
        "  gl_Position = vec4(position, 0, 1);\n"
        "  v_data = testFlag;\n"
        "}";

    constexpr char kFS[] =
        "varying highp vec2 v_data;\n"
        "void main() {\n"
        "  gl_FragColor = vec4(v_data, 0, 1);\n"
        "}";

    mProgram = CompileProgram(kVS, kFS);
    ASSERT_NE(0u, mProgram);
    glUseProgram(mProgram);

    GLint positionLocation = glGetAttribLocation(mProgram, "position");
    ASSERT_NE(-1, positionLocation);

    GLint testFlagLocation = glGetAttribLocation(mProgram, "testFlag");
    ASSERT_NE(-1, testFlagLocation);

    mIndexBuffers.resize(1);
    glGenBuffers(1, &mIndexBuffers[0]);

    mVertexArrays.resize(1);
    glGenVertexArrays(1, &mVertexArrays[0]);

    mVertexBuffers.resize(2);
    glGenBuffers(2, &mVertexBuffers[0]);

    std::vector<GLubyte> indexData[2];
    indexData[0].push_back(0);
    indexData[0].push_back(1);
    indexData[0].push_back(2);
    indexData[0].push_back(2);
    indexData[0].push_back(3);
    indexData[0].push_back(0);
    indexData[0].push_back(4);
    indexData[0].push_back(5);
    indexData[0].push_back(6);
    indexData[0].push_back(6);
    indexData[0].push_back(7);
    indexData[0].push_back(4);

    // Make a copy:
    indexData[1] = indexData[0];

    std::vector<GLfloat> positionData = {// quad verts
                                         -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f,
                                         // Repeat position data
                                         -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f};

    std::vector<GLfloat> testFlagData = {// red
                                         1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
                                         // green
                                         0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f};

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffers[0]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLubyte) * indexData[0].size(), &indexData[0][0],
                 GL_STATIC_DRAW);

    glBindVertexArray(mVertexArrays[0]);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffers[0]);
    glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffers[0]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * positionData.size(), &positionData[0],
                 GL_STATIC_DRAW);
    glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 2, nullptr);
    glEnableVertexAttribArray(positionLocation);

    glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffers[1]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * testFlagData.size(), &testFlagData[0],
                 GL_STATIC_DRAW);
    glVertexAttribPointer(testFlagLocation, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 2, nullptr);
    glEnableVertexAttribArray(testFlagLocation);

    ASSERT_GL_NO_ERROR();

    // Draw with just the second set of 6 items, then first 6, and then the entire index buffer
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, reinterpret_cast<const void *>(6));
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);

    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, nullptr);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);

    glDrawElements(GL_TRIANGLES, 12, GL_UNSIGNED_BYTE, nullptr);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);

    // Reload the buffer again with a copy of the same data
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLubyte) * indexData[1].size(), &indexData[1][0],
                 GL_STATIC_DRAW);

    // Draw with just the first 6 indices, and then with the entire index buffer
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, nullptr);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::red);

    glDrawElements(GL_TRIANGLES, 12, GL_UNSIGNED_BYTE, nullptr);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);

    // Reload the buffer again with a copy of the same data
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLubyte) * indexData[0].size(), &indexData[0][0],
                 GL_STATIC_DRAW);

    // This time, do not check color between draws (which causes a flush):
    // Draw with just the second set of 6 items, then first 6, and then the entire index buffer
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, reinterpret_cast<const void *>(6));
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, nullptr);
    glDrawElements(GL_TRIANGLES, 12, GL_UNSIGNED_BYTE, nullptr);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);

    ASSERT_GL_NO_ERROR();
}

// Test that glDrawElements call with different index buffer offsets work as expected
TEST_P(DrawElementsTest, DrawElementsWithDifferentIndexBufferOffsets)
{
    const std::array<Vector3, 4> &vertices = GetIndexedQuadVertices();
    const std::array<GLushort, 6> &indices = GetQuadIndices();

    glClearColor(0.f, 0.f, 0.f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT);

    ANGLE_GL_PROGRAM(programDrawRed, essl3_shaders::vs::Simple(), essl3_shaders::fs::Red());
    ANGLE_GL_PROGRAM(programDrawGreen, essl3_shaders::vs::Simple(), essl3_shaders::fs::Green());
    ANGLE_GL_PROGRAM(programDrawBlue, essl3_shaders::vs::Simple(), essl3_shaders::fs::Blue());

    glUseProgram(programDrawRed);

    GLuint vertexArray;
    glGenVertexArrays(1, &vertexArray);
    glBindVertexArray(vertexArray);
    GLBuffer vertexBuffer;
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    GLint posLocation = glGetAttribLocation(programDrawRed, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    // Draw both triangles of quad
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices.data());
    EXPECT_PIXEL_COLOR_EQ(0, 1, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 2, GLColor::red);

    glUseProgram(programDrawGreen);

    GLuint vertexArray1;
    glGenVertexArrays(1, &vertexArray1);
    glBindVertexArray(vertexArray1);
    GLBuffer vertexBuffer1;
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer1);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    posLocation = glGetAttribLocation(programDrawGreen, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);

    GLBuffer indexBuffer;
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices[0]) * indices.size(), indices.data(),
                 GL_DYNAMIC_DRAW);

    // Draw right triangle of quad
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, reinterpret_cast<const void *>(6));
    EXPECT_PIXEL_COLOR_EQ(0, 1, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 2, GLColor::green);

    glUseProgram(programDrawBlue);

    glBindVertexArray(vertexArray);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    posLocation = glGetAttribLocation(programDrawBlue, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);

    // Draw both triangles of quad
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices.data());
    EXPECT_PIXEL_COLOR_EQ(0, 1, GLColor::blue);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 2, GLColor::blue);

    glDeleteVertexArrays(1, &vertexArray);
    glDeleteVertexArrays(1, &vertexArray1);

    ASSERT_GL_NO_ERROR();
}

// Test one element buffer bind to two vertexArrays and switch vertexArray should draw correctly
TEST_P(DrawElementsTest, TwoVertexArraysWithSameElementBuffer)
{
    glClearColor(0.f, 0.f, 0.f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT);

    ANGLE_GL_PROGRAM(programDrawRed, essl3_shaders::vs::Simple(), essl3_shaders::fs::Red());
    glUseProgram(programDrawRed);
    GLint posLocation = glGetAttribLocation(programDrawRed, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);

    GLBuffer vertexBuffer;
    const std::array<Vector3, 4> &vertices = GetIndexedQuadVertices();
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    GLBuffer elementBuffer;
    std::array<GLubyte, 6> zeros;
    size_t elementBufferSize = sizeof(zeros[0]) * zeros.size();
    zeros.fill(0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementBufferSize, zeros.data(), GL_DYNAMIC_DRAW);

    // Set up two vertex arrays using same set of buffers. Since initial element buffer all point to
    // the same vertex, it should only draw one point
    GLuint vertexArray[2];
    glGenVertexArrays(2, vertexArray);

    glBindVertexArray(vertexArray[0]);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, reinterpret_cast<const void *>(0));

    glBindVertexArray(vertexArray[1]);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, reinterpret_cast<const void *>(0));

    // Use vertexArray[0] and update elementBuffer and draw
    const std::array<GLubyte, 6> &indices = {0, 1, 2, 0, 2, 3};
    glBindVertexArray(vertexArray[0]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementBufferSize, indices.data(), GL_DYNAMIC_DRAW);
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_BYTE, reinterpret_cast<const void *>(0));

    // Use vertexArray[1] and and draw
    glBindVertexArray(vertexArray[1]);
    size_t elementBufferOffset = sizeof(indices[0]) * 3;
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_BYTE,
                   reinterpret_cast<const void *>(elementBufferOffset));

    // We should see both triangles
    EXPECT_PIXEL_COLOR_EQ(1, 1, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 1, GLColor::red);

    glDeleteVertexArrays(2, vertexArray);

    ASSERT_GL_NO_ERROR();
}

// Test that drawing with index value a little bit less than or equal to GL_MAX_ELEMENT_INDEX
// should not have error
TEST_P(DrawElementsTest, MaxElementIndex)
{
    constexpr GLuint indicesNumber = 10;
    std::array<GLuint, indicesNumber> indices;
    GLint64 maxIndex = 0;
    GLBuffer vertexBuffer;

    ANGLE_GL_PROGRAM(programDrawRed, essl3_shaders::vs::Simple(), essl3_shaders::fs::Red());
    glUseProgram(programDrawRed);
    GLint posLocation = glGetAttribLocation(programDrawRed, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);

    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);

    glEnableVertexAttribArray(posLocation);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glVertexAttribDivisor(posLocation, 0xFFFFFFFF);

    glGetInteger64v(GL_MAX_ELEMENT_INDEX, &maxIndex);
    // Draw using index from maxIndex - 9 to maxIndex. Should have no error
    for (GLuint i = 0; i < indicesNumber; ++i)
    {
        indices[i] = static_cast<GLuint>(maxIndex) - (indicesNumber - 1) + i;
    }

    glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(indicesNumber), GL_UNSIGNED_INT,
                   indices.data());
    ASSERT_GL_NO_ERROR();
}

// Test that the offset in the index buffer is forced to be a multiple of the element size
TEST_P(WebGLDrawElementsTest, DrawElementsTypeAlignment)
{
    constexpr char kVS[] =
        "attribute vec3 a_pos;\n"
        "void main()\n"
        "{\n"
        "    gl_Position = vec4(a_pos, 1.0);\n"
        "}\n";

    ANGLE_GL_PROGRAM(program, kVS, essl1_shaders::fs::Blue());

    GLint posLocation = glGetAttribLocation(program, "a_pos");
    ASSERT_NE(-1, posLocation);
    glUseProgram(program);

    const auto &vertices = GetQuadVertices();

    GLBuffer vertexBuffer;
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);

    GLBuffer indexBuffer;
    const GLubyte indices1[] = {0, 0, 0, 0, 0, 0};
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices1), indices1, GL_STATIC_DRAW);

    ASSERT_GL_NO_ERROR();

    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, nullptr);
    ASSERT_GL_NO_ERROR();

    const GLushort indices2[] = {0, 0, 0, 0, 0, 0};
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices2), indices2, GL_STATIC_DRAW);

    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_SHORT, reinterpret_cast<const void *>(1));
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
}

// Test that subsequent UNSIGNED_BYTE primitive restart draws work without problems.
// At the time of writing, Metal backend would use incorrect internal offset and
// fail the draw with validation.
TEST_P(DrawElementsTest, DrawElementsUintByteBytePrimitiveRestart)
{
    glClearColor(1.f, 0.f, 0.f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT);
    const char kVS[] = R"(#version 300 es
in vec4 a_position;
void main()
{
    gl_Position = a_position;
    gl_PointSize = 2.0;
})";
    ANGLE_GL_PROGRAM(mProgram, kVS, essl3_shaders::fs::Green());
    glUseProgram(mProgram);

    GLBuffer vertexBuffer;
    std::array<GLfloat, 3> vertices{-1.0f, -1.0f, 0.5f};
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    GLint posLocation = glGetAttribLocation(mProgram, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);
    glEnableVertexAttribArray(posLocation);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    GLubyte indices[4] = {0xff, 0xff, 0, 0};
    GLBuffer elementBuffer;
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    ASSERT_GL_NO_ERROR();

    glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
    glDrawElements(GL_POINTS, 1, GL_UNSIGNED_SHORT, nullptr);
    ASSERT_GL_NO_ERROR();
    glDrawElements(GL_POINTS, 4, GL_UNSIGNED_BYTE, nullptr);
    ASSERT_GL_NO_ERROR();
    glDrawElements(GL_POINTS, 4, GL_UNSIGNED_BYTE, nullptr);
    ASSERT_GL_NO_ERROR();

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_RECT_EQ(1, 1, getWindowWidth() - 1, getWindowHeight() - 1, GLColor::red);
    ASSERT_GL_NO_ERROR();
}

// Tests various draw element parameter, vertex buffer contents variants.
// Does not yet test using GL_BYTE 0xFF, GL_SHORT 0xFFFF with primitive restart off.
TEST_P(DrawElementsVariantsTest, Draw)
{
    const bool hasProvokingVertexExt = IsGLExtensionEnabled("GL_ANGLE_provoking_vertex");
    ANGLE_SKIP_TEST_IF(useProvokingVertexFirst() && !hasProvokingVertexExt);

    glClearColor(1.f, 0.f, 0.f, 1.f);

    constexpr char kFlatVS[] = R"(#version 300 es
flat out float p;
in vec4 a_position;
in float a_vertexMark;
void main()
{
    p = a_vertexMark;
    gl_Position = a_position;
})";

    constexpr char kFlatFS[] = R"(#version 300 es
precision highp float;
flat in highp float p;
out vec4 my_FragColor;
void main()
{
    if (p >= 0.5)
        my_FragColor = vec4(0.0, 1.0, 0.0, 1.0);
    else
        my_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
})";
    GLProgram program;
    if (useFlat())
    {
        program.makeRaster(kFlatVS, kFlatFS);
    }
    else
    {
        program.makeRaster(essl3_shaders::vs::Simple(), essl3_shaders::fs::Green());
    }
    ASSERT_GL_NO_ERROR();
    glUseProgram(program);

    GLBuffer vertexBuffer;
    std::array<GLfloat, 12> vertices = {
        -1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
    };
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    // First vertex convention, triangle strip {0,1,2,3}: 0, 1 are provoking.
    GLBuffer markFirstConventionStrip;
    std::array<GLfloat, 4> markFirstStripData = {1.0f, 1.0f, 0.0f, 0.0f};
    glBindBuffer(GL_ARRAY_BUFFER, markFirstConventionStrip);
    glBufferData(GL_ARRAY_BUFFER, sizeof(markFirstStripData), markFirstStripData.data(),
                 GL_STATIC_DRAW);

    // First vertex convention, triangle strip {0,1,2,0xff,2,1,3} and triangles {0,1,2,2,1,3}:
    // 0, 2 are provoking.
    GLBuffer markFirstConventionTriangles;
    std::array<GLfloat, 4> markFirstTriData = {1.0f, 0.0f, 1.0f, 0.0f};
    glBindBuffer(GL_ARRAY_BUFFER, markFirstConventionTriangles);
    glBufferData(GL_ARRAY_BUFFER, sizeof(markFirstTriData), markFirstTriData.data(),
                 GL_STATIC_DRAW);

    // Last vertex convention: triangle strip {0,1,2,3} and triangles {0,1,2,2,1,3}: 2, 3 are
    // provoking.
    GLBuffer markLastConvention;
    std::array<GLfloat, 4> markLastData = {0.0f, 0.0f, 1.0f, 1.0f};
    glBindBuffer(GL_ARRAY_BUFFER, markLastConvention);
    glBufferData(GL_ARRAY_BUFFER, sizeof(markLastData), markLastData.data(), GL_STATIC_DRAW);

    GLubyte contentStrip[]     = {0, 1, 2, 3};
    GLubyte contentTriangles[] = {0, 1, 2, 2, 1, 3};
    GLubyte contentSplit[]     = {0, 1, 2, 0xff, 2, 1, 3};

    if (usePrimitiveRestart())
    {
        glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
    }
    if (useProvokingVertexFirst())
    {
        glProvokingVertexANGLE(GL_FIRST_VERTEX_CONVENTION_ANGLE);
    }

    GLint posLocation = glGetAttribLocation(program, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glEnableVertexAttribArray(posLocation);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);

    if (useFlat())
    {
        GLint markLocation = glGetAttribLocation(program, "a_vertexMark");
        ASSERT_NE(-1, markLocation);
        if (!useProvokingVertexFirst())
        {
            glBindBuffer(GL_ARRAY_BUFFER, markLastConvention);
        }
        else if (drawStrip() && !splitContent())
        {
            glBindBuffer(GL_ARRAY_BUFFER, markFirstConventionStrip);
        }
        else
        {
            glBindBuffer(GL_ARRAY_BUFFER, markFirstConventionTriangles);
        }
        glEnableVertexAttribArray(markLocation);
        glVertexAttribPointer(markLocation, 1, GL_FLOAT, GL_FALSE, 0, 0);
    }

    std::vector<GLubyte> byteIndices;
    GLsizei contentStartCount = 0;
    uintptr_t offset          = 0;
    if (addOffset())
    {
        byteIndices.push_back(0);
    }
    if (addRestartAtBegin())
    {
        byteIndices.push_back(0xff);
    }
    if (addRestartDegenerate())
    {
        byteIndices.push_back(0);
        byteIndices.push_back(0xff);
    }
    contentStartCount = byteIndices.size();
    if (splitContent())
    {
        byteIndices.insert(byteIndices.end(), std::begin(contentSplit), std::end(contentSplit));
    }
    else if (drawStrip())
    {
        byteIndices.insert(byteIndices.end(), std::begin(contentStrip), std::end(contentStrip));
    }
    else
    {
        byteIndices.insert(byteIndices.end(), std::begin(contentTriangles),
                           std::end(contentTriangles));
    }
    if (addRestartAtEnd())
    {
        byteIndices.push_back(0xff);
    }

    // Prepare typed index data for both buffer and client-side paths.
    std::vector<GLushort> shortIndices;
    std::vector<GLuint> intIndices;
    if (type() == GL_UNSIGNED_SHORT)
    {
        shortIndices = convertIndexBufferWithRestarts<GLushort>(byteIndices);
    }
    else if (type() == GL_UNSIGNED_INT)
    {
        intIndices = convertIndexBufferWithRestarts<GLuint>(byteIndices);
    }

    GLBuffer elementBuffer;
    const void *indices = nullptr;
    if (useClientSideArrays())
    {
        ASSERT_FALSE(addOffset());
        if (type() == GL_UNSIGNED_BYTE)
        {
            indices = byteIndices.data();
        }
        else if (type() == GL_UNSIGNED_SHORT)
        {
            indices = shortIndices.data();
        }
        else
        {
            indices = intIndices.data();
        }
    }
    else
    {
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
        if (type() == GL_UNSIGNED_BYTE)
        {
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, byteIndices.size(), byteIndices.data(),
                         GL_STATIC_DRAW);
            if (addOffset())
            {
                offset = 1;
            }
        }
        else if (type() == GL_UNSIGNED_SHORT)
        {
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2 * shortIndices.size(), shortIndices.data(),
                         GL_STATIC_DRAW);
            if (addOffset())
            {
                offset = 2;
            }
        }
        else
        {
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4 * intIndices.size(), intIndices.data(),
                         GL_STATIC_DRAW);
            if (addOffset())
            {
                offset = 4;
            }
        }
        indices = reinterpret_cast<const void *>(offset);
    }
    ASSERT_GL_NO_ERROR();

    glClear(GL_COLOR_BUFFER_BIT);

    GLenum mode   = drawStrip() ? GL_TRIANGLE_STRIP : GL_TRIANGLES;
    GLsizei count = byteIndices.size() - (addOffset() ? 1 : 0);
    glDrawElements(mode, count, type(), indices);
    ASSERT_GL_NO_ERROR();

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(0, getWindowHeight() - 1, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 1, GLColor::green);
    ASSERT_GL_NO_ERROR();

    // Test drawing again to verify caching behavior and buffer regeneration.
    glClear(GL_COLOR_BUFFER_BIT);
    glDrawElements(mode, count, type(), indices);
    glDrawElements(mode, count, type(), indices);
    ASSERT_GL_NO_ERROR();

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(0, getWindowHeight() - 1, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 1, GLColor::green);
    ASSERT_GL_NO_ERROR();

    // Test drawing again with a subrange, to check that possibly cached ranges
    // are cropped correctly. Draw only one triangle.
    glClear(GL_COLOR_BUFFER_BIT);
    count = contentStartCount + 3 - (addOffset() ? 1 : 0);
    glDrawElements(mode, count, type(), indices);
    ASSERT_GL_NO_ERROR();

    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, 0, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(0, getWindowHeight() - 1, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 1, GLColor::red);
    ASSERT_GL_NO_ERROR();
}

class WebGLDrawElementsTest3 : public WebGLDrawElementsTest
{};
// Test one element buffer bind to two vertexArrays and switch vertexArray should draw correctly.
// With WebGL, we will go through element buffer range validation check which will catch bugs if the
// cached index range is incorrect.
TEST_P(WebGLDrawElementsTest3, TwoVertexArraysWithSameElementBuffer)
{
    glClearColor(0.f, 0.f, 0.f, 1.f);
    glClear(GL_COLOR_BUFFER_BIT);

    ANGLE_GL_PROGRAM(programDrawRed, essl3_shaders::vs::Simple(), essl3_shaders::fs::Red());
    glUseProgram(programDrawRed);
    GLint posLocation = glGetAttribLocation(programDrawRed, essl3_shaders::PositionAttrib());
    ASSERT_NE(-1, posLocation);

    GLBuffer vertexBuffer;
    const std::array<Vector3, 4> &vertices = GetIndexedQuadVertices();
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices[0]) * vertices.size(), vertices.data(),
                 GL_STATIC_DRAW);

    GLBuffer elementBuffer;
    std::array<GLuint, 6> invalidIndexData;
    size_t elementBufferSize = sizeof(invalidIndexData[0]) * invalidIndexData.size();
    invalidIndexData.fill(0xffffffff);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementBufferSize, invalidIndexData.data(),
                 GL_DYNAMIC_DRAW);

    // Set up two vertex arrays using same set of buffers. Since initial element buffer all point to
    // 0xffffffff, which exceed max index range, it should generate GL_INVALID_OPERATION.
    GLuint vertexArray[2];
    glGenVertexArrays(2, vertexArray);

    glBindVertexArray(vertexArray[0]);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, reinterpret_cast<const void *>(0));

    glBindVertexArray(vertexArray[1]);
    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(posLocation);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    size_t elementBufferOffset1 = sizeof(invalidIndexData[0]) * 3;
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT,
                   reinterpret_cast<const void *>(elementBufferOffset1));

    // This should alsop clear the context error code.
    ASSERT_TRUE(glGetError() == GL_INVALID_OPERATION);

    // Use vertexArray[0] and update elementBuffer and draw
    const std::array<GLuint, 6> &indices = {0, 1, 2, 0, 2, 3};
    glBindVertexArray(vertexArray[0]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, elementBufferSize, indices.data(), GL_DYNAMIC_DRAW);
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, reinterpret_cast<const void *>(0));

    // Use vertexArray[1] and and draw
    glBindVertexArray(vertexArray[1]);
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT,
                   reinterpret_cast<const void *>(elementBufferOffset1));
    ASSERT_TRUE(glGetError() == GL_NO_ERROR);

    // We should see both triangles
    EXPECT_PIXEL_COLOR_EQ(1, 1, GLColor::red);
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() - 1, getWindowHeight() - 1, GLColor::red);

    glDeleteVertexArrays(2, vertexArray);

    ASSERT_GL_NO_ERROR();
}

// Test that uploading a large index buffer (> 1MB) via glBufferSubData
// does not corrupt the data in the chunks after the first 1MB.
// This is a regression test for a bug in Metal backend where the offset
// was not applied to the source pointer when chunking the upload.
TEST_P(DrawElementsTest, LargeIndexBufferSubData)
{
    // We want the buffer size to be slightly larger than 1MB.
    // 1MB = 1024 * 1024 = 1,048,576 bytes.
    // With GL_UNSIGNED_INT (4 bytes), 1MB is 262,144 indices.
    // We use 263,168 indices (1,052,672 bytes).
    constexpr size_t kIndexCount = 263168;
    constexpr size_t kBufferSize = kIndexCount * sizeof(GLuint);

    // Staging buffer chunk size is 1MB.
    // First chunk: indices 0 to 262143.
    // Second chunk: indices 262144 to 263167.

    // Prepare indices.
    // We want to draw a triangle using the last 3 indices in the buffer.
    // These indices will point to green vertices.
    // The indices at the start of the buffer will point to red vertices.
    std::vector<GLuint> indices(kIndexCount, 0);
    // Start of buffer: points to red vertices (0, 1, 2)
    indices[0] = 0;
    indices[1] = 1;
    indices[2] = 2;
    // End of buffer: points to green vertices (3, 4, 5)
    indices[kIndexCount - 3] = 3;
    indices[kIndexCount - 2] = 4;
    indices[kIndexCount - 1] = 5;

    // Vertices with position and color.
    struct Vertex
    {
        float position[3];
        GLubyte color[4];
    };

    const std::vector<Vertex> vertices = {
        // Red triangle
        {{-1.0f, -1.0f, 0.0f}, {255, 0, 0, 255}},
        {{3.0f, -1.0f, 0.0f}, {255, 0, 0, 255}},
        {{-1.0f, 3.0f, 0.0f}, {255, 0, 0, 255}},
        // Green triangle
        {{-1.0f, -1.0f, 0.0f}, {0, 255, 0, 255}},
        {{3.0f, -1.0f, 0.0f}, {0, 255, 0, 255}},
        {{-1.0f, 3.0f, 0.0f}, {0, 255, 0, 255}},
    };

    // Shader program
    const char *kVS =
        "attribute vec3 a_position;\n"
        "attribute vec4 a_color;\n"
        "varying vec4 v_color;\n"
        "void main()\n"
        "{\n"
        "    gl_Position = vec4(a_position, 1.0);\n"
        "    v_color = a_color;\n"
        "}\n";
    const char *kFS =
        "precision mediump float;\n"
        "varying vec4 v_color;\n"
        "void main()\n"
        "{\n"
        "    gl_FragColor = v_color;\n"
        "}\n";

    ANGLE_GL_PROGRAM(program, kVS, kFS);
    glUseProgram(program);

    GLint posLocation   = glGetAttribLocation(program, "a_position");
    GLint colorLocation = glGetAttribLocation(program, "a_color");
    ASSERT_NE(-1, posLocation);
    ASSERT_NE(-1, colorLocation);

    GLVertexArray vao;
    glBindVertexArray(vao);

    GLBuffer vertexBuffer;
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(),
                 GL_STATIC_DRAW);

    glVertexAttribPointer(posLocation, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
                          reinterpret_cast<const void *>(offsetof(Vertex, position)));
    glEnableVertexAttribArray(posLocation);
    glVertexAttribPointer(colorLocation, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex),
                          reinterpret_cast<const void *>(offsetof(Vertex, color)));
    glEnableVertexAttribArray(colorLocation);

    GLBuffer indexBuffer;
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    // Allocate
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, kBufferSize, nullptr, GL_STATIC_DRAW);
    // Upload > 1MB
    glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, kBufferSize, indices.data());

    ASSERT_GL_NO_ERROR();

    // Draw using the indices at the end of the buffer.
    // Offset in bytes: (kIndexCount - 3) * sizeof(GLuint)
    size_t drawOffset = (kIndexCount - 3) * sizeof(GLuint);
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, reinterpret_cast<const void *>(drawOffset));

    ASSERT_GL_NO_ERROR();

    // If the bug is present, the indices at the end were copied from the start (which point to
    // red). If fixed, they point to green.
    EXPECT_PIXEL_COLOR_EQ(getWindowWidth() / 2, getWindowHeight() / 2, GLColor::green);
}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DrawElementsTest);
ANGLE_INSTANTIATE_TEST_ES3(DrawElementsTest);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DrawElementsVariantsTest);

ANGLE_INSTANTIATE_TEST_VARIANTS_COMBINE_7(
    NoRestart,
    DrawElementsVariantsTest,
    DrawElementsVariantsTestPrint,
    testing::Values(GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, GL_UNSIGNED_INT),
    testing::Bool(),                                  // useFlat
    testing::Values(PrimitiveRestartMode::Disabled),  // primitiveRestartMode
    testing::Bool(),                                  // drawStrip
    testing::Values(IndicesMode::Buffer,
                    IndicesMode::BufferAndOffset,
                    IndicesMode::ClientSideArray),
    testing::Values(RestartOption::None),  // restartOption
    testing::Bool(),                       // useProvokingVertexFirst
    ANGLE_ALL_TEST_PLATFORMS_ES3);

ANGLE_INSTANTIATE_TEST_VARIANTS_COMBINE_7(
    Restart,
    DrawElementsVariantsTest,
    DrawElementsVariantsTestPrint,
    testing::Values(GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, GL_UNSIGNED_INT),
    testing::Bool(),  // useFlat
    testing::Values(PrimitiveRestartMode::Enabled, PrimitiveRestartMode::EnabledSplitContent),
    testing::Bool(),  // drawStrip
    testing::Values(IndicesMode::Buffer,
                    IndicesMode::BufferAndOffset,
                    IndicesMode::ClientSideArray),
    testing::Values(RestartOption::None,
                    RestartOption::AtBegin,
                    RestartOption::AtEnd,
                    RestartOption::Degenerate),
    testing::Bool(),  // useProvokingVertexFirst
    ANGLE_ALL_TEST_PLATFORMS_ES3);

ANGLE_INSTANTIATE_TEST_ES2(WebGLDrawElementsTest);
ANGLE_INSTANTIATE_TEST_ES3(WebGLDrawElementsTest3);
}  // namespace