src/tests/gl_tests/GLSLUBTest.cpp

//
// Copyright 2025 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.
//

#include "test_utils/ANGLETest.h"

#include "test_utils/angle_test_configs.h"
#include "test_utils/gl_raii.h"
#include "util/shader_utils.h"

namespace
{
using namespace angle;

class GLSLUBTest : public ANGLETest<>
{
  protected:
    GLSLUBTest()
    {
        setWindowWidth(128);
        setWindowHeight(128);
        setConfigRedBits(8);
        setConfigGreenBits(8);
        setConfigBlueBits(8);
        setConfigAlphaBits(8);
    }
};

// grep TEST_P src/tests/gl_tests/GLSLUBTest.cpp
// For prefixes Add, Sub find:
//   IntInt
//   IntIvec
//   IvecInt
//   IvecIvec
//   AssignIvecInt
//   AssignIvecIvec

// Test int + int with overflow. Expect wraparound.
TEST_P(GLSLUBTest, AddIntIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int r0 = u + -1;
    int r1 = u + 0;
    int r2 = 2147483646 + u;
    int r3 = u + 2147483647;

    gl_FragColor.r = r0 == 1 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == 2 ? 1.0 : 0.0;
    gl_FragColor.b = r2 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.a = r3 == -2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int + ivec overflow. Expect wraparound.
TEST_P(GLSLUBTest, AddIntIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    ivec4 r = u + ivec4(0, -1, 1, 2147483647);
    gl_FragColor.r = r.x == 2 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == 1 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == 3 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == -2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int + ivec overflow. Expect wraparound.
TEST_P(GLSLUBTest, AddIvecIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    ivec4 r = ivec4(0, -1, 1, 2147483647) + u;
    gl_FragColor.r = r.x == 2 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == 1 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == 3 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == -2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ivec + ivec, ivec + int overflow. Expect wraparound.
TEST_P(GLSLUBTest, AddIvecIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r0 = u + ivec4(0, -1, 1, 2147483647);
    ivec4 r1 = ivec4(0, -1, 1, 2147483647) + u;
    gl_FragColor.r = r0 == r1 ? 1.0 : 0.0;
    gl_FragColor.g = r0.y == 1 ? 1.0 : 0.0;
    gl_FragColor.b = r0.z == 3 ? 1.0 : 0.0;
    gl_FragColor.a = r0.w == -2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 2, 2, 2, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test highp ivec += int overflow. Expect wraparound.
TEST_P(GLSLUBTest, AddAssignIvecIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    ivec4 r = ivec4(0, -1, 1, 2147483647);
    r += u;
    gl_FragColor.r = r.x == 2 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == 1 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == 3 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == -2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test highp ivec += ivec overflow. Expect wraparound.
TEST_P(GLSLUBTest, AddAssignIvecIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r = ivec4(0, -1, 1, 2147483647);
    r += u;
    gl_FragColor.r = r.x == 2 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == 1 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == 3 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == -2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 2, 2, 2, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int - int with overflow. Expect wraparound.
TEST_P(GLSLUBTest, SubIntIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int r0 = u - (-1);
    int r1 = u - 0;
    int r2 = -2147483646 - u;
    int r3 = u - (-2147483647);

    gl_FragColor.r = r0 == 3 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == 2 ? 1.0 : 0.0;
    gl_FragColor.b = r2 == 2147483648 ? 1.0 : 0.0;
    gl_FragColor.a = r3 == -2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test highp int - ivec underflow. Expect wraparound.
TEST_P(GLSLUBTest, SubIntIvecUnderflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    ivec4 r = u - ivec4(0, -1, 1, 2147483647);
    gl_FragColor.r = r.x == 2 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == 3 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == 1 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == -2147483645 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test highp ivec - int underflow. Expect wraparound.
TEST_P(GLSLUBTest, SubIvecIntUnderflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    ivec4 r = ivec4(0, -1, 1, -2147483647) - u;
    gl_FragColor.r = r.x == -2 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == -3 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == -1 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == 2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test highp int vec -= scalar underflow. Expect wraparound.
TEST_P(GLSLUBTest, SubAssignIvecIntUnderflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    ivec4 r = ivec4(0, -1, 1, -2147483647);
    r -= u;
    gl_FragColor.r = r.x == -2 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == -3 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == -1 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == 2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test highp int vec -= scalar underflow. Expect wraparound.
TEST_P(GLSLUBTest, SubAssignIvecIvecUnderflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r = ivec4(0, -1, 1, -2147483647);
    r -= u;
    gl_FragColor.r = r.x == -2 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == -3 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == -1 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == 2147483647 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 2, 2, 2, 2);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ++int with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PreIncrementIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int r0 = u;
    int r1 = ++r0;

    gl_FragColor.r = r0 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.b = u == 2147483647 ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2147483647);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int++ with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PostIncrementIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int r0 = u;
    int r1 = r0++;

    gl_FragColor.r = r0 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == 2147483647 ? 1.0 : 0.0;
    gl_FragColor.b = u == 2147483647 ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2147483647);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test --int with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PreDecrementIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int r0 = u;
    int r1 = --r0;

    gl_FragColor.r = r0 == 2147483648 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == 2147483648 ? 1.0 : 0.0;
    gl_FragColor.b = u == -2147483647 ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, -2147483647);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int-- with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PostDecrementIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int r0 = u;
    int r1 = r0--;

    gl_FragColor.r = r0 == 2147483648 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == -2147483647 ? 1.0 : 0.0;
    gl_FragColor.b = u == -2147483647 ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, -2147483647);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ++ivec with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PreIncrementIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r0 = u;
    ivec4 r1 = ++r0;

    gl_FragColor.r = r0 == ivec4(1, 2, 3, -2147483648) ? 1.0 : 0.0;
    gl_FragColor.g = r1 == ivec4(1, 2, 3, -2147483648) ? 1.0 : 0.0;
    gl_FragColor.b = u == ivec4(0, 1, 2, 2147483647) ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 0, 1, 2, 2147483647);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}
// Test ivec++ with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PostIncrementIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r0 = u;
    ivec4 r1 = r0++;

    gl_FragColor.r = r0 == ivec4(1, 2, 3, -2147483648) ? 1.0 : 0.0;
    gl_FragColor.g = r1 == ivec4(0, 1, 2, 2147483647) ? 1.0 : 0.0;
    gl_FragColor.b = u == ivec4(0, 1, 2, 2147483647) ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 0, 1, 2, 2147483647);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test --ivec with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PreDecrementIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r0 = u;
    ivec4 r1 = --r0;

    gl_FragColor.r = r0 == ivec4(-1, 0, 1, 2147483648) ? 1.0 : 0.0;
    gl_FragColor.g = r1 == ivec4(-1, 0, 1, 2147483648) ? 1.0 : 0.0;
    gl_FragColor.b = u == ivec4(0, 1, 2, -2147483647) ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 0, 1, 2, -2147483647);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ivec-- with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PostDecrementIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r0 = u;
    ivec4 r1 = r0--;

    gl_FragColor.r = r0 == ivec4(-1, 0, 1, 2147483648) ? 1.0 : 0.0;
    gl_FragColor.g = r1 == ivec4(0, 1, 2, -2147483647) ? 1.0 : 0.0;
    gl_FragColor.b = u == ivec4(0, 1, 2, -2147483647) ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 0, 1, 2, -2147483647);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int++ with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PostIncrementIntOverflowInForDynamic)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int z = 0;
    for (int i = u; i > 4; i++) {
        z++;
    }
    gl_FragColor.r = z == 7 ? 1.0 : 0.0;
    gl_FragColor.g = u == 2147483641 ? 1.0 : 0.0;
    gl_FragColor.b = 1.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2147483641);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int++ with overflow. Expect wraparound.
TEST_P(GLSLUBTest, PostIncrementIntOverflowInForStatic)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
void main() {
    int z = 0;
    for (int i = 2147483642; i > 4; i++) {
        z++;
    }
    gl_FragColor.r = z == 6 ? 1.0 : 0.0;
    gl_FragColor.g = 1.0;
    gl_FragColor.b = 1.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test abs() on the smallest negative int. The spec defines abs(x) as -x for negative x, and that
// negation overflows, so expect wraparound, i.e. the value is unchanged.
TEST_P(GLSLUBTest, AbsIntOverflow)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform int u;
uniform ivec4 uv;
out vec4 color;
void main() {
    int r0 = abs(u);
    ivec4 r1 = abs(uv);

    color.r = r0 == -2147483648 ? 1.0 : 0.0;
    color.g = r1 == ivec4(0, 1, 2147483647, -2147483648) ? 1.0 : 0.0;
    // abs() of a negative value is negative only when it overflows.
    color.b = abs(u) < 0 ? 1.0 : 0.0;
    color.a = abs(u) == u ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint uv = glGetUniformLocation(testProgram, "uv");
    EXPECT_NE(-1, uv);
    glUniform1i(u, -2147483647 - 1);
    glUniform4i(uv, 0, -1, -2147483647, -2147483647 - 1);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test unary - on the smallest negative int, which overflows. Expect wraparound, i.e. the value is
// unchanged. The comparisons are written so that a compiler that assumes the negation cannot
// overflow can fold them to a constant.
TEST_P(GLSLUBTest, NegateIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int r0 = -u;
    int r1 = -(-u);

    gl_FragColor.r = r0 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == -2147483648 ? 1.0 : 0.0;
    // -u == u only holds for 0 and for the smallest negative value.
    gl_FragColor.b = -u == u ? 1.0 : 0.0;
    // The negation of a negative value is negative only when it overflows.
    gl_FragColor.a = -u < 0 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, -2147483647 - 1);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test unary - on an ivec containing the smallest negative int. Expect wraparound.
TEST_P(GLSLUBTest, NegateIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r0 = -u;
    ivec4 r1 = -(-u);

    gl_FragColor.r = r0 == ivec4(0, -1, -2147483647, -2147483648) ? 1.0 : 0.0;
    gl_FragColor.g = r1 == u ? 1.0 : 0.0;
    gl_FragColor.b = -u.w == u.w ? 1.0 : 0.0;
    gl_FragColor.a = -u.w < 0 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 0, 1, 2147483647, -2147483647 - 1);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int * int with overflow. Expect wraparound.
TEST_P(GLSLUBTest, MulIntIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int r0 = u * u;
    int r1 = u * 32768;
    int r2 = 49152 * u;
    int r3 = u * -49152;

    gl_FragColor.r = r0 == 0 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.b = r2 == -1073741824 ? 1.0 : 0.0;
    gl_FragColor.a = r3 == 1073741824 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 65536);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int * ivec with overflow. Expect wraparound.
TEST_P(GLSLUBTest, MulIntIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    ivec4 r = u * ivec4(1, 32768, 49152, -49152);

    gl_FragColor.r = r.x == 65536 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == -1073741824 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == 1073741824 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 65536);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ivec * int with overflow. Expect wraparound.
TEST_P(GLSLUBTest, MulIvecIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    ivec4 r = ivec4(1, 32768, 49152, -49152) * u;

    gl_FragColor.r = r.x == 65536 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == -1073741824 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == 1073741824 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 65536);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ivec * ivec with overflow. Expect wraparound.
TEST_P(GLSLUBTest, MulIvecIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r = u * u;

    gl_FragColor.r = r.x == 0 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == 1073741824 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == -1879048192 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == -1879048192 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 65536, 32768, 49152, -49152);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int *= int with overflow. Expect wraparound.
TEST_P(GLSLUBTest, MulAssignIntIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    int r0 = u;
    r0 *= u;
    int r1 = 32768;
    r1 *= u;

    gl_FragColor.r = r0 == 0 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.b = u == 65536 ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 65536);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ivec *= int and ivec *= ivec with overflow. Expect wraparound.
TEST_P(GLSLUBTest, MulAssignIvecOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void main() {
    ivec4 r0 = ivec4(1, 32768, 49152, -49152);
    r0 *= u;
    ivec4 r1 = ivec4(1, 32768, 49152, -49152);
    r1 *= ivec4(u);

    gl_FragColor.r = r0 == ivec4(65536, -2147483648, -1073741824, 1073741824) ? 1.0 : 0.0;
    gl_FragColor.g = r0 == r1 ? 1.0 : 0.0;
    gl_FragColor.b = 1.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 65536);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int / int where the divisor is 0. GLSL ES 3.00 section 5.9 makes this an unspecified value,
// so the value asserted here is only what the emulation happens to produce, which is the dividend.
// The well defined divisions must not be affected.
TEST_P(GLSLUBTest, DivIntIntByZero)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
uniform int z;
void main() {
    int r0 = u / z;
    int r1 = -u / z;
    int r2 = u / 2;
    int r3 = z / u;

    gl_FragColor.r = r0 == 7 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == -7 ? 1.0 : 0.0;
    gl_FragColor.b = r2 == 3 ? 1.0 : 0.0;
    gl_FragColor.a = r3 == 0 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint z = glGetUniformLocation(testProgram, "z");
    EXPECT_NE(-1, z);
    glUniform1i(u, 7);
    glUniform1i(z, 0);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test the int / int case that overflows, i.e. dividing the smallest negative value by -1. The
// spec allows either the smallest or the largest representable value to be returned here (GLSL ES
// 3.00 section 4.1.3), and the emulation returns the smallest, which is what is asserted.
TEST_P(GLSLUBTest, DivIntIntOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
uniform int m;
void main() {
    int r0 = u / m;
    int r1 = u / 2;
    int r2 = (u + 1) / m;
    int r3 = u / 1;

    gl_FragColor.r = r0 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == -1073741824 ? 1.0 : 0.0;
    gl_FragColor.b = r2 == 2147483647 ? 1.0 : 0.0;
    gl_FragColor.a = r3 == -2147483648 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint m = glGetUniformLocation(testProgram, "m");
    EXPECT_NE(-1, m);
    glUniform1i(u, -2147483647 - 1);
    glUniform1i(m, -1);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ivec / ivec, ivec / int and ivec /= int with a 0 divisor and with an overflow.
TEST_P(GLSLUBTest, DivIvecByZero)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
uniform ivec4 zv;
uniform int z;
void main() {
    ivec4 r0 = u / zv;
    ivec4 r1 = u / z;
    ivec4 r2 = u;
    r2 /= z;

    gl_FragColor.r = r0 == ivec4(7, -7, 0, -2147483648) ? 1.0 : 0.0;
    gl_FragColor.g = r1 == u ? 1.0 : 0.0;
    gl_FragColor.b = r2 == u ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint zv = glGetUniformLocation(testProgram, "zv");
    EXPECT_NE(-1, zv);
    GLint z = glGetUniformLocation(testProgram, "z");
    EXPECT_NE(-1, z);
    glUniform4i(u, 7, -7, 0, -2147483647 - 1);
    glUniform4i(zv, 0, 0, 0, -1);
    glUniform1i(z, 0);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int /= int where the divisor is 0.
TEST_P(GLSLUBTest, DivAssignIntIntByZero)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
uniform int z;
void main() {
    int r0 = u;
    r0 /= z;
    int r1 = u;
    r1 /= 2;

    gl_FragColor.r = r0 == 7 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == 3 ? 1.0 : 0.0;
    gl_FragColor.b = 1.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint z = glGetUniformLocation(testProgram, "z");
    EXPECT_NE(-1, z);
    glUniform1i(u, 7);
    glUniform1i(z, 0);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test uint / uint where the divisor is 0.
TEST_P(GLSLUBTest, DivUintUintByZero)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform uint u;
uniform uint z;
out vec4 color;
void main() {
    uint r0 = u / z;
    uint r1 = u / 2u;
    uvec4 r2 = uvec4(u) / uvec4(z);

    color.r = r0 == 7u ? 1.0 : 0.0;
    color.g = r1 == 3u ? 1.0 : 0.0;
    color.b = r2 == uvec4(7u) ? 1.0 : 0.0;
    color.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint z = glGetUniformLocation(testProgram, "z");
    EXPECT_NE(-1, z);
    glUniform1ui(u, 7u);
    glUniform1ui(z, 0u);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int % int where the divisor is 0. GLSL ES 3.00 section 5.9 leaves the result undefined per
// component, so the value asserted here is only what the emulation produces, which is 0. The well
// defined remainders must not be affected.
TEST_P(GLSLUBTest, ModIntIntByZero)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform int u;
uniform int z;
out vec4 color;
void main() {
    int r0 = u % z;
    int r1 = -u % z;
    int r2 = u % 2;
    int r3 = z % u;

    color.r = r0 == 0 ? 1.0 : 0.0;
    color.g = r1 == 0 ? 1.0 : 0.0;
    color.b = r2 == 1 ? 1.0 : 0.0;
    color.a = r3 == 0 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint z = glGetUniformLocation(testProgram, "z");
    EXPECT_NE(-1, z);
    glUniform1i(u, 7);
    glUniform1i(z, 0);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test the int % int case where the corresponding division overflows, i.e. the smallest negative
// value modulo -1. GLSL ES 3.00 section 5.9 leaves the result undefined because an operand is
// negative, and the emulation returns the mathematically correct 0, which is what is asserted.
TEST_P(GLSLUBTest, ModIntIntOverflow)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform int u;
uniform int m;
out vec4 color;
void main() {
    int r0 = u % m;
    int r1 = u % 2;
    int r2 = (u + 1) % m;
    int r3 = u % 1;

    color.r = r0 == 0 ? 1.0 : 0.0;
    color.g = r1 == 0 ? 1.0 : 0.0;
    color.b = r2 == 0 ? 1.0 : 0.0;
    color.a = r3 == 0 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint m = glGetUniformLocation(testProgram, "m");
    EXPECT_NE(-1, m);
    glUniform1i(u, -2147483647 - 1);
    glUniform1i(m, -1);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int % int with negative operands, which GLSL ES 3.00 section 5.9 leaves undefined. The
// emulation truncates towards zero, so the sign follows the dividend, which is what is asserted.
TEST_P(GLSLUBTest, ModIntIntNegative)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform int a;
uniform int b;
out vec4 color;
void main() {
    int r0 = -a % b;
    int r1 = a % -b;
    int r2 = -a % -b;
    int r3 = a % b;

    color.r = r0 == -1 ? 1.0 : 0.0;
    color.g = r1 == 1 ? 1.0 : 0.0;
    color.b = r2 == -1 ? 1.0 : 0.0;
    color.a = r3 == 1 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint a = glGetUniformLocation(testProgram, "a");
    EXPECT_NE(-1, a);
    GLint b = glGetUniformLocation(testProgram, "b");
    EXPECT_NE(-1, b);
    glUniform1i(a, 7);
    glUniform1i(b, 3);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ivec % ivec, ivec % int and ivec %= int with a 0 divisor and with an overflow.
TEST_P(GLSLUBTest, ModIvecByZero)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform ivec4 u;
uniform ivec4 zv;
uniform int z;
out vec4 color;
void main() {
    ivec4 r0 = u % zv;
    ivec4 r1 = u % z;
    ivec4 r2 = u;
    r2 %= z;

    color.r = r0 == ivec4(0) ? 1.0 : 0.0;
    color.g = r1 == ivec4(0) ? 1.0 : 0.0;
    color.b = r2 == ivec4(0) ? 1.0 : 0.0;
    color.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint zv = glGetUniformLocation(testProgram, "zv");
    EXPECT_NE(-1, zv);
    GLint z = glGetUniformLocation(testProgram, "z");
    EXPECT_NE(-1, z);
    glUniform4i(u, 7, -7, 0, -2147483647 - 1);
    glUniform4i(zv, 0, 0, 0, -1);
    glUniform1i(z, 0);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test uint % uint where the divisor is 0.
TEST_P(GLSLUBTest, ModUintUintByZero)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform uint u;
uniform uint z;
out vec4 color;
void main() {
    uint r0 = u % z;
    uint r1 = u % 2u;
    uvec4 r2 = uvec4(u);
    r2 %= z;

    color.r = r0 == 0u ? 1.0 : 0.0;
    color.g = r1 == 1u ? 1.0 : 0.0;
    color.b = r2 == uvec4(0u) ? 1.0 : 0.0;
    color.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint z = glGetUniformLocation(testProgram, "z");
    EXPECT_NE(-1, z);
    glUniform1ui(u, 7u);
    glUniform1ui(z, 0u);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int << int with a shift amount that is out of range. The result is undefined, so this only
// tests that the shader runs. The emulation masks the shift amount to 5 bits, so shifting by 32
// shifts by 0 and shifting by -1 shifts by 31.
TEST_P(GLSLUBTest, ShiftLeftIntAmountOutOfRange)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform int u;
uniform int big;
uniform int neg;
out vec4 color;
void main() {
    int r0 = u << big;
    int r1 = u << neg;
    int r2 = u << 31;
    int r3 = u << 0;

    color.r = r0 == 1 ? 1.0 : 0.0;
    color.g = r1 == -2147483648 ? 1.0 : 0.0;
    color.b = r2 == -2147483648 ? 1.0 : 0.0;
    color.a = r3 == 1 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint big = glGetUniformLocation(testProgram, "big");
    EXPECT_NE(-1, big);
    GLint neg = glGetUniformLocation(testProgram, "neg");
    EXPECT_NE(-1, neg);
    glUniform1i(u, 1);
    glUniform1i(big, 32);
    glUniform1i(neg, -1);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int << int where the value is negative or where the shift overflows. Expect the bits to be
// shifted out.
TEST_P(GLSLUBTest, ShiftLeftIntNegativeValue)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform int u;
uniform int h;
out vec4 color;
void main() {
    int r0 = u << 1;
    int r1 = u << 31;
    int r2 = h << 1;
    int r3 = h << 2;

    color.r = r0 == -2 ? 1.0 : 0.0;
    color.g = r1 == -2147483648 ? 1.0 : 0.0;
    color.b = r2 == -2147483648 ? 1.0 : 0.0;
    color.a = r3 == 0 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint h = glGetUniformLocation(testProgram, "h");
    EXPECT_NE(-1, h);
    glUniform1i(u, -1);
    glUniform1i(h, 1073741824);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int >> int with a shift amount that is out of range. The result is undefined, so this only
// tests that the shader runs. The emulation masks the shift amount to 5 bits. The in range shifts
// must sign extend.
TEST_P(GLSLUBTest, ShiftRightIntAmountOutOfRange)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform int u;
uniform int big;
uniform int neg;
out vec4 color;
void main() {
    int r0 = u >> big;
    int r1 = u >> neg;
    int r2 = u >> 1;
    int r3 = u >> 31;

    color.r = r0 == -8 ? 1.0 : 0.0;
    color.g = r1 == -1 ? 1.0 : 0.0;
    color.b = r2 == -4 ? 1.0 : 0.0;
    color.a = r3 == -1 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint big = glGetUniformLocation(testProgram, "big");
    EXPECT_NE(-1, big);
    GLint neg = glGetUniformLocation(testProgram, "neg");
    EXPECT_NE(-1, neg);
    glUniform1i(u, -8);
    glUniform1i(big, 32);
    glUniform1i(neg, -1);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test uint << uint and uint >> uint with a shift amount that is out of range.
TEST_P(GLSLUBTest, ShiftUintAmountOutOfRange)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform uint u;
uniform uint big;
out vec4 color;
void main() {
    uint r0 = u << big;
    uint r1 = u >> big;
    uint r2 = u << 31u;
    uint r3 = u >> 31u;

    color.r = r0 == 4294967295u ? 1.0 : 0.0;
    color.g = r1 == 4294967295u ? 1.0 : 0.0;
    color.b = r2 == 2147483648u ? 1.0 : 0.0;
    color.a = r3 == 1u ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint big = glGetUniformLocation(testProgram, "big");
    EXPECT_NE(-1, big);
    glUniform1ui(u, 4294967295u);
    glUniform1ui(big, 32u);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test int <<= int and int >>= int with a shift amount that is out of range.
TEST_P(GLSLUBTest, ShiftAssignIntAmountOutOfRange)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform int u;
uniform int big;
out vec4 color;
void main() {
    int r0 = u;
    r0 <<= big;
    int r1 = u;
    r1 >>= big;
    int r2 = u;
    r2 <<= 1;
    int r3 = u;
    r3 >>= 1;

    color.r = r0 == -8 ? 1.0 : 0.0;
    color.g = r1 == -8 ? 1.0 : 0.0;
    color.b = r2 == -16 ? 1.0 : 0.0;
    color.a = r3 == -4 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint big = glGetUniformLocation(testProgram, "big");
    EXPECT_NE(-1, big);
    glUniform1i(u, -8);
    glUniform1i(big, 32);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ivec << ivec, ivec << int and ivec <<= int with shift amounts that are out of range.
TEST_P(GLSLUBTest, ShiftLeftIvecAmountOutOfRange)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform ivec4 u;
uniform ivec4 amounts;
uniform int big;
out vec4 color;
void main() {
    ivec4 r0 = u << amounts;
    ivec4 r1 = u << big;
    ivec4 r2 = u;
    r2 <<= big;

    color.r = r0 == ivec4(1, 2, 1, -2147483648) ? 1.0 : 0.0;
    color.g = r1 == ivec4(1) ? 1.0 : 0.0;
    color.b = r2 == ivec4(1) ? 1.0 : 0.0;
    color.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint amounts = glGetUniformLocation(testProgram, "amounts");
    EXPECT_NE(-1, amounts);
    GLint big = glGetUniformLocation(testProgram, "big");
    EXPECT_NE(-1, big);
    glUniform4i(u, 1, 1, 1, 1);
    glUniform4i(amounts, 0, 1, 32, -1);
    glUniform1i(big, 64);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test float to int conversion where the value is out of range. GLSL ES 3.00 section 5.4.1 only
// specifies that the fractional part is dropped and does not define a result for values that are
// not representable, so the values asserted here are what the emulation produces: it clamps to the
// representable range.
TEST_P(GLSLUBTest, FloatToIntOutOfRange)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform float hi;
uniform float lo;
void main() {
    int r0 = int(hi);
    int r1 = int(lo);
    int r2 = int(2.7);
    int r3 = int(-2.7);

    gl_FragColor.r = r0 == 2147483520 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.b = r2 == 2 ? 1.0 : 0.0;
    gl_FragColor.a = r3 == -2 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint hi = glGetUniformLocation(testProgram, "hi");
    EXPECT_NE(-1, hi);
    GLint lo = glGetUniformLocation(testProgram, "lo");
    EXPECT_NE(-1, lo);
    glUniform1f(hi, 1.0e10f);
    glUniform1f(lo, -1.0e10f);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test float to int conversion of the values at the edges of the int range. Unlike the out of range
// cases, these are representable, so GLSL ES 3.00 section 5.4.1 requires the exact values and the
// clamping must not perturb them.
TEST_P(GLSLUBTest, FloatToIntInRange)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform float hi;
uniform float lo;
void main() {
    int r0 = int(hi);
    int r1 = int(lo);

    gl_FragColor.r = r0 == 2147483520 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.b = 1.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint hi = glGetUniformLocation(testProgram, "hi");
    EXPECT_NE(-1, hi);
    GLint lo = glGetUniformLocation(testProgram, "lo");
    EXPECT_NE(-1, lo);
    // The largest float that is smaller than 2^31, and -2^31.
    glUniform1f(hi, 2147483520.0f);
    glUniform1f(lo, -2147483648.0f);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test float to uint conversion where the value is out of range. Note that GLSL ES 3.00 section
// 5.4.1 does explicitly make conversion of a negative value to uint undefined.
TEST_P(GLSLUBTest, FloatToUintOutOfRange)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform float hi;
uniform float lo;
out vec4 color;
void main() {
    uint r0 = uint(hi);
    uint r1 = uint(lo);
    uint r2 = uint(2.7);
    uvec2 r3 = uvec2(vec2(hi, lo));

    color.r = r0 == 4294967040u ? 1.0 : 0.0;
    color.g = r1 == 0u ? 1.0 : 0.0;
    color.b = r2 == 2u ? 1.0 : 0.0;
    color.a = r3 == uvec2(4294967040u, 0u) ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint hi = glGetUniformLocation(testProgram, "hi");
    EXPECT_NE(-1, hi);
    GLint lo = glGetUniformLocation(testProgram, "lo");
    EXPECT_NE(-1, lo);
    glUniform1f(hi, 1.0e10f);
    glUniform1f(lo, -1.0e10f);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test vec4 to ivec4 conversion where the values are out of range. The asserted values are what
// the emulation clamps to, see FloatToIntOutOfRange.
TEST_P(GLSLUBTest, FloatToIvecOutOfRange)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform vec4 u;
void main() {
    ivec4 r = ivec4(u);

    gl_FragColor.r = r.x == 2147483520 ? 1.0 : 0.0;
    gl_FragColor.g = r.y == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.b = r.z == 2 ? 1.0 : 0.0;
    gl_FragColor.a = r.w == -2 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4f(u, 1.0e10f, -1.0e10f, 2.7f, -2.7f);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test a multi argument ivec constructor where the values are out of range. These are split into
// per component conversions before being emitted. The asserted values are what the emulation clamps
// to, see FloatToIntOutOfRange.
TEST_P(GLSLUBTest, FloatToIvecMultiArgumentOutOfRange)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform float a;
uniform float b;
uniform vec2 v;
void main() {
    ivec2 r0 = ivec2(a, b);
    ivec4 r1 = ivec4(v, v);
    ivec3 r2 = ivec3(a, v);

    gl_FragColor.r = r0 == ivec2(2147483520, -2147483648) ? 1.0 : 0.0;
    gl_FragColor.g = r1 == ivec4(2147483520, -2147483648, 2147483520, -2147483648) ? 1.0 : 0.0;
    gl_FragColor.b = r2 == ivec3(2147483520, 2147483520, -2147483648) ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint a = glGetUniformLocation(testProgram, "a");
    EXPECT_NE(-1, a);
    GLint b = glGetUniformLocation(testProgram, "b");
    EXPECT_NE(-1, b);
    GLint v = glGetUniformLocation(testProgram, "v");
    EXPECT_NE(-1, v);
    glUniform1f(a, 1.0e10f);
    glUniform1f(b, -1.0e10f);
    glUniform2f(v, 1.0e10f, -1.0e10f);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ++ and -- on a vector element with a dynamic index. Expect wraparound. The operand of the
// emulated operators has to be addressable.
TEST_P(GLSLUBTest, IncrementIvecElementOverflow)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform ivec4 u;
uniform int i;
out vec4 color;
void main() {
    ivec4 r0 = u;
    r0[i]++;
    ivec4 r1 = u;
    ++r1[i];
    ivec4 r2 = u;
    r2[i + 1]--;
    ivec4 r3 = u;
    --r3[i + 1];

    color.r = r0 == ivec4(0, 1, -2147483648, -2147483648) ? 1.0 : 0.0;
    color.g = r0 == r1 ? 1.0 : 0.0;
    color.b = r2 == ivec4(0, 1, 2147483647, 2147483647) ? 1.0 : 0.0;
    color.a = r2 == r3 ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint i = glGetUniformLocation(testProgram, "i");
    EXPECT_NE(-1, i);
    glUniform4i(u, 0, 1, 2147483647, -2147483647 - 1);
    glUniform1i(i, 2);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test ++ and -- on a swizzle. Expect wraparound. The operand of the emulated operators has to be
// addressable.
TEST_P(GLSLUBTest, IncrementIvecSwizzleOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform ivec4 u;
void main() {
    ivec4 r0 = u;
    r0.z++;
    ivec4 r1 = u;
    r1.zw--;
    ivec4 r2 = u;
    --r2.wz;

    gl_FragColor.r = r0 == ivec4(0, 1, -2147483648, -2147483648) ? 1.0 : 0.0;
    gl_FragColor.g = r1 == ivec4(0, 1, 2147483646, 2147483647) ? 1.0 : 0.0;
    gl_FragColor.b = r1 == r2 ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform4i(u, 0, 1, 2147483647, -2147483647 - 1);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test compound assignment to a vector element and to a swizzle. Expect wraparound.
TEST_P(GLSLUBTest, AssignIvecElementOverflow)
{
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
    constexpr char kFS[] = R"(#version 300 es
precision highp int;
precision highp float;
uniform ivec4 u;
uniform int i;
out vec4 color;
void main() {
    ivec4 r0 = u;
    r0[i] += 2;
    ivec4 r1 = u;
    r1.z -= -2;
    ivec4 r2 = u;
    r2.zw *= 2;
    ivec4 r3 = u;
    r3[i] <<= 33;

    color.r = r0 == ivec4(0, 1, -2147483647, -2147483648) ? 1.0 : 0.0;
    color.g = r0 == r1 ? 1.0 : 0.0;
    color.b = r2 == ivec4(0, 1, -2, 0) ? 1.0 : 0.0;
    // The shift amount is masked, so shifting by 33 shifts by 1.
    color.a = r3 == ivec4(0, 1, -2, -2147483648) ? 1.0 : 0.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl3_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    GLint i = glGetUniformLocation(testProgram, "i");
    EXPECT_NE(-1, i);
    glUniform4i(u, 0, 1, 2147483647, -2147483647 - 1);
    glUniform1i(i, 2);
    drawQuad(testProgram, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

// Test that the emulated operators work on function out and inout arguments.
TEST_P(GLSLUBTest, OutArgumentOverflow)
{
    constexpr char kFS[] = R"(
precision highp int;
precision highp float;
uniform int u;
void addOne(inout int x) { x++; }
void mulTwo(inout ivec2 x) { x *= 2; }
void main() {
    int r0 = u;
    addOne(r0);
    ivec4 r1 = ivec4(u, u, 1, 2);
    addOne(r1[2]);
    ivec4 r2 = ivec4(u, u, 1, 2);
    mulTwo(r2.xy);

    gl_FragColor.r = r0 == -2147483648 ? 1.0 : 0.0;
    gl_FragColor.g = r1 == ivec4(2147483647, 2147483647, 2, 2) ? 1.0 : 0.0;
    gl_FragColor.b = r2 == ivec4(-2, -2, 1, 2) ? 1.0 : 0.0;
    gl_FragColor.a = 1.0;
}
)";
    ANGLE_GL_PROGRAM(testProgram, essl1_shaders::vs::Simple(), kFS);
    ASSERT_GL_NO_ERROR();
    glUseProgram(testProgram);
    GLint u = glGetUniformLocation(testProgram, "u");
    EXPECT_NE(-1, u);
    glUniform1i(u, 2147483647);
    drawQuad(testProgram, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, true);
    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor(255, 255, 255, 255));
    ASSERT_GL_NO_ERROR();
}

}  // anonymous namespace

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(GLSLUBTest);
ANGLE_INSTANTIATE_TEST(GLSLUBTest, ES2_METAL(), ES3_METAL());