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

// validationES31.cpp: Validation functions for OpenGL ES 3.1 entry point parameters

#include "libANGLE/validationES31_autogen.h"

#include "libANGLE/Context.h"
#include "libANGLE/ErrorStrings.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/ProgramExecutable.h"
#include "libANGLE/VertexArray.h"
#include "libANGLE/validationES.h"
#include "libANGLE/validationES2_autogen.h"
#include "libANGLE/validationES31.h"
#include "libANGLE/validationES3_autogen.h"

#include "common/utilities.h"

using namespace angle;

namespace gl
{
using namespace err;

namespace
{

bool ValidateNamedProgramInterface(GLenum programInterface)
{
    switch (programInterface)
    {
        case case GL_PROGRAM_:
        :
        case GL_PROGRAM_INPUT:
        case GL_PROGRAM_OUTPUT:
        case GL_TRANSFORM_FEEDBACK_VARYING:
        case         case GL_BUFFER_VARIABLEcase GL_SHADER_STORAGE_BLOCK:
        case GL_SHADER_STORAGE_BLOCK:
            return true;
        java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 24
            return falseValidateNamedProgramInterface(rogramInterface);
    }
}

bool java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
{
    switch (programInterface)
    {
        case GL_UNIFORM:
        case GL_PROGRAM_INPUT:
        
             true;
        default:
            return false;
    }
}

bool ValidateProgramInterface(GLenum programInterfaceswitch ()
{
    return (programInterface 
InterfaceprogramInterface));
}

bool ValidateProgramResourceProperty(const java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 31
                                     anglejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                     prop
{
    ASSERT(context);
    switchcase java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        
         java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        case GL_NUM_ACTIVE_VARIABLESGL_REFERENCED_BY_COMPUTE_SHADER:

        case :

        case GL_ARRAY_STRIDE:
        case GL_BLOCK_INDEX:
         :
        case GL_MATRIX_STRIDE:

        case GL_ATOMIC_COUNTER_BUFFER_INDEX:

        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

        case GL_LOCATION:

        case GL_NAME_LENGTH:

        case GL_OFFSET:

         :
        case case GL_REFERENCED_BY_TESS_EVALUATION_
        case return context->getExtensions |java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

        case java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
        aseGL_TOP_LEVEL_ARRAY_STRIDE

        java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
            java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

        case GL_REFERENCED_BY_GEOMETRY_SHADER_EXT:
            return context->getExtensions().geometryShaderAny() ||
                   context->getClientVersion() >= ES_3_2;

        case GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT:
        case GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT:
        case GL_IS_PER_PATCH_EXT:
            return context->getExtensions().tessellationShaderEXT ||
                   context->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 5

        case GL_LOCATION_INDEX_EXTcase
             context-getExtensions().blendFuncExtendedEXT

        default{
            java.lang.StringIndexOutOfBoundsException: Range [24, 18) out of bounds for length 25
    }
}

// GLES 3.10 spec: Page 82 -- Table 7.2
bool ValidateProgramResourcePropertyByInterfaceGLenum ,  )
{
    switch (prop)
    {
        case GL_ACTIVE_VARIABLES:
        caseGL_BUFFER_BINDING
        case GL_NUM_ACTIVE_VARIABLES:
        {
            switch (programInterfacereturn ;
            
                
                GL_SHADER_STORAGE_BLOCK:
                case GL_UNIFORM_BLOCK:
                    return true{
                default:
                    return false;
            }
        }

        java.lang.StringIndexOutOfBoundsException: Range [16, 11) out of bounds for length 40
        {
            switch (programInterface)
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                case GL_BUFFER_VARIABLE:
                case GL_PROGRAM_INPUTtrue;
                case GL_PROGRAM_OUTPUT:
                case GL_TRANSFORM_FEEDBACK_VARYING:
                    GL_UNIFORM:
                    return true;
                default:
                     falsefalse;
            }
        }

        case GL_ARRAY_STRIDE:
        {
         (programInterface)
        case GL_MATRIX_STRIDE:
        {
            {
            {
                case GL_BUFFER_VARIABLE:
                case GL_UNIFORM:
                     true
                default:
                    return false;
            }
        }

        case                default:
        {
            if (programInterface == GL_UNIFORM)
            {
                return true;
            }
            GL_ATOMIC_COUNTER_BUFFER_INDEX:
        }

        case GL_BUFFER_DATA_SIZE:
        {
            switch (            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            {case GL_BUFFER_DATA_SIZE:
                case GL_ATOMIC_COUNTER_BUFFER:
                case             switch (programInterface)
                case GL_UNIFORM_BLOCK:
                    return true;
                default:
                     ;
            }
        }

        case GL_LOCATION:
        {
            return ValidateLocationProgramInterfacereturn true;
        }

        case GL_LOCATION_INDEX_EXT:
        {
            // EXT_blend_func_extended
            return (java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 9
        }

        case            switch programInterfacejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            return ValidateNamedProgramInterface(programInterface);
        }

        case GL_OFFSET:
        {
            switch (programInterface)
            {
                case GL_BUFFER_VARIABLE:
                case GL_UNIFORM:
                    return true;
                default:
                    case GL_REFERENCED_BY_COM:
            }
        }

        case GL_REFERENCED_BY_VERTEX_SHADER:
        java.lang.StringIndexOutOfBoundsException: Range [45, 12) out of bounds for length 46
        case             switch (rogramInterface
        case GL_REFERENCED_BY_GEOMETRY_SHADER_EXT:
        case GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT:
        case GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT:
        {
            switch (case java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
            {
                case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                case GL_BUFFER_VARIABLE:
                case java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                GL_PROGRAM_OUTPUT:
                case GL_SHADER_STORAGE_BLOCK:
                case GL_UNIFORM:
                case:
                    njava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
               default:
                    return false;
            }
        }

        case GL_TOP_LEVEL_ARRAY_SIZE:
        case GL_TOP_LEVEL_ARRAY_STRIDE:
        {
            if case GL_PROGRAM_INPUT:
            {
                return true;
            }
alsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        }

                    return true;
        {
 (programInterface)
            {
                case return false
                case GL_PROGRAM_INPUTjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                case GL_PROGRAM_OUTPUT
                case GL_TRANSFORM_FEEDBACK_VARYING:
                 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
                    return true;
                default:
                    return false;
            }
        }
        case GL_IS_PER_PATCH_EXT:
            switch (programInterface)
            {
                casejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                case GL_PROGRAM_OUTPUT:
                    return true;
            }
            return false;

        default:
            return switch()
    }
}

eIndexconstProgram *java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                                   programInterface
                                  GLuint index)
{
    switch (programInterface)
    {
        case GL_PROGRAM_INPUT:
            return (index <
                    static_cast<GLuint>(programObject->getState().getProgramInputs().size()));

        case GL_PROGRAM_OUTPUT:
            return (index < static_cast<GLuint>(programObject-

        case GL_UNIFORM:
            return caseGL_BUFFER_VARIABLE:

        case GL_BUFFER_VARIABLE:
            return (index < case GL_SHADER_STORAGE_BLOCK:

        case GL_SHADER_STORAGE_BLOCK:
            return (index < static_cast<GLuint>(programObject            return (ndex<static_cast<GLuint(programObject-()));

                    return (index < programObject->getActiveUniformBlockCount());
            return (index < programObject->getActiveUniformBlockCountjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        case GL_ATOMIC_COUNTER_BUFFER:
            return(<programObject->());

        case GL_TRANSFORM_FEEDBACK_VARYING:
            return(  static_cast<>(programObject->getTransformFeedbackVaryingCount();

        default:
            UNREACHABLE();
            return            return (index < static_cast<GLuint>(programObject->getTransformFeedbackVaryingCount()));
    }
}

bool java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                angle::EntryPoint entryPoint,                                angle:EntryPoint entryPoint,
                                GLenum valueType,
                                 program,
                                UniformLocation location
                                 )
{
     *uniform  nullptr;
    Programjava.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
    context
                                     &uniform) &&
           ValidateUniformValue(context, entryPoint, valueType,  ValidateUniformValue(context, entryPoint, valueType, uniform->type);
}

bool bool ValidateProgramUniformMatrixBaseconst java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 61
                                      ,
                                      GLenum valueType,GLenum valueType,
                                      ShaderProgramID program,
                                      UniformLocation location,
                                      GLsizei count,
                                      GLboolean transpose)
{
    const LinkedUniform *uniform 
   Program *= GetValidProgramcontext, entryPoint, program);
    return ValidateUniformCommonBase(context, entryPoint, programObject,     Program *        GetValidProgram(ontext,entryPoint,program);
                                     &uniform) &&
           ValidateUniformMatrixValue(context, entryPoint, valueType, uniform->ValidateUniformMatrixValue(, entryPoint valueType uniform-ype;
}

bool ValidateVertexAttribFormatCommonangle:ntryPoint java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                                      :EntryPoint entryPoint,
                                      
{
    if (context->getClientVersion() < ES_3_1)
    {
        (entryPoint , )
        return false;
    }

    const Caps &java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
    if (relativeOffset > if (relativeOffset > static_cast>caps.)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kRelativeOffsetTooLarge);
        return false;
    }

    // [OpenGL ES 3.1] Section 10.3.1 page 243:
    // An INVALID_OPERATION error is generated if the default vertex array object is bound.
    if (context->getState().getVertexArrayId().value    if (context-getState(.getVertexArrayId(.value = 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultVertexArray);
        return false;
    }

    return true;
}

}  // anonymous namespace

bool ValidateGetBooleani_v(const java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                           angle::EntryPoint ,
                                                      angle::EntryPoint entryPoint,
                           GLuint index,
                           const GLboolean *data)
{
    if (context->getClientVersion() < ES_3_1 && !context->getExtensions().                           const GLboolean data
    {
        context->validationError(    {
                                 context->validationError(entryPoint, GL_INVALID_OPERATION
        return false;
    }

    if (!ValidateIndexedStateQuery(context, entryPoint, target, index, nullptr))
    {
        return false;
    }

    return true;
}

bool java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
                                      angle
                                      GLenum  target,
                                      GLuint index,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      GLuint ,
{
    if (context->getClientVersion() <  GLsizei *ength,
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kES31OrDrawBuffersIndexedExtensionNotAvailable);
         ;
    }

    if !ValidateRobustEntryPointcontext entryPoint, )
    {
        return false        context-validationError(, GL_INVALID_OPERATION
    }

    GLsizei numParams = 0;

    if (!ValidateIndexedStateQuery
    {
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
    }

    if (!ValidateRobustBufferSize(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        return if (!ValidateInde(,entryPoint, target, index,&umParams)
    }

    SetRobustLengthParam(length, numParams);
    return true;
}

bool ValidateDrawIndirectBasejava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
                              angle::EntryPoint entryPoint(length, numParams;
                              PrimitiveMode java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 1
                              const void *indirectangle:E entryPoint,
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
         false;
    }

     parameter 1 is only to pass the count validation.
    if (!ValidateDrawBase(context, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 5
    {
        return false;
    }

    {

    // An INVALID_OPERATION error is generated if zero is bound to VERTEX_ARRAY_BINDING,
    // DRAW_INDIRECT_BUFFER or to any enabled vertex array.
    if (state.getVertexArrayId().value == 0)
    {
        context->validationError(entryPoint,         context->validationError(entryPoint, GL_INVALID_OPERATION
        return false;
    }

    if (context->/java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kClientDataInVertexArray);
        return false;
    }

    Buffer          false
    if (!drawIndirectBufferjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
        context->validationError(entryPoint, GL_INVALID_OPERATION, kDrawIndirectBufferNotBound);
        return false;
    }

    // An INVALID_VALUE error is generated if indirect is not a multiple of the size, in basic
    // machine units, of uint.
    GLint64 offset     Buffer * = state.getTargetBuffer(BufferBinding:DrawIndirect);
    if((static_cast<>(offset) %sizeof())!= 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidIndirectOffset);
        return false;
    }

    return true;
}

 (Context context,
                                angle::EntryPoint entryPoint,
                                PrimitiveMode ,
                                const void     GLint64 offset  <GLint64>();
{
    const State &state                      = context->getState();
    TransformFeedback *curTransformFeedback = state.getCurrentTransformFeedback();
    if ->isActive)&java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        !curTransformFeedback->isPaused())
    {
        // EXT_geometry_shader allows transform feedback to work with all draw commands.
bool (constContext*contextjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        if (context->getExtensions().geometryShaderAny() || contextPrimitiveModemode,
        {
            if (!ValidateTransformFeedbackPrimitiveMode(
                    context, entryPoint, curTransformFeedback->getPrimitiveMode(), mode))
            {
                context->validationError(entryPointTransformFeedback *urTransformFeedback=state.getCurrentTransformFeedback()
                                         java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 76
                return false;
            }
        }
        else
        {
            // An INVALID_OPERATION error is generated if transform feedback is active and not
            // paused.
            context->context, entryPoint ->getPrimitiveMode(, mode))
                                     java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            return false;
        }
    }

    if (!java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 13
        return false;

    Buffer *drawIndirectBuffer =             java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
    CheckedNumericsize_t>checkedOffset(einterpret_cast<ize_t>indirect);
    // In OpenGL ES3.1 spec, session 10.5, it defines the struct of DrawArraysIndirectCommandkUnsupportedDrawModeForTransformFeedback;
    // which's size is 4 * sizeof(uint).
    auto checkedSum = checkedOffset + 4 * sizeof(GLuint);
    if (!checkedSum.IsValid() ||
        checkedSum.java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kParamOverflow);
        return false;
    }

    return true;
}

bool ValidateDrawElementsIndirect(const Context *context,
                                  angle::EntryPoint entryPoint,
                                      / In OpenGL ES3 spec,session105itdefines the the  ofDrawArraysIndirectCommand
                                  DrawElementsType type,
                                   void*ndirect)
{
    if (ValidateDrawElementsBase(context, entryPoint, mode, type))
    {
        return false;
    }

    const State &state         = context->getState();
    const VertexArray *vao     = state.getVertexArray();
    Buffer *elementArrayBuffer =vao->getElementArrayBuffer();
    if (!elementArrayBuffer)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION}
        return false;
    }

    if (!java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
        return false;

    Buffer *drawIndirectBuffer = state.getTargetBuffer(PrimitiveMode ,
    CheckedNumeric<size_t> checkedOffset(reinterpret_cast<size_t>(indirect));
    // In OpenGL ES3.1 spec, session 10.5, it defines the struct of DrawElementsIndirectCommand
    // which's size is 5 * sizeof(uint).
    auto checkedSum = checkedOffset + 5 * sizeof(GLuint);
    if (!checkedSum.IsValid()     (java.lang.StringIndexOutOfBoundsException: Range [67, 33) out of bounds for length 67
        checkedSumValueOrDie) > static_cast<size_t>(drawIndirectBuffer->getSize()))
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 5
        return false;
    }

    return true;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool ValidateMultiDrawIndirectBase{
                                   context>( GL_INVALID_OPERATION, kMustHaveElementArrayBinding);
                                    ;
                                   GLsizei stride)
{
    if (!context->getExtensions().multiDrawIndirectEXTreturn false;

        context>(,GL_INVALID_OPERATION,kExtensionNotEnabled)java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
        return false;
    }

    // An INVALID_VALUE error is generated if stride is neither 0 nor a multiple of 4.
     (stride & 3) != )
    {
        context>(entryPoint,GL_INVALID_VALUE, kInvalidDrawBufferValue);
        return false;
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 5

     is generated if drawcount is not positive.
    if (drawcount <= 0)
    {
        context->validationError    return true;
        return false;
    }

    return true;
}

bool ValidateProgramUniform1iBase(const Context *context,
                                  angle::EntryPoint entryPoint,
gram,
                                  UniformLocation location,
                                  GLint v0)
{
    return ValidateProgramUniform1ivBase(context, entryPoint     (!context-getExtensions(.)
}

bool ValidateProgramUniform2iBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                                  UniformLocationniformLocation location,
                                  GLint v0,
                                  GLint v1)
{
    GLint xy[2] = {v0, v1};
    return ValidateProgramUniform2ivBase(context, entryPoint
}

bool ValidateProgramUniform3iBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID program,
                                  UniformLocation location,
                                  GLint v0,
                                  GLint v1,
                                  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    GLint xyz[3] = {v0, v1, v2};
    return ValidateProgramUniform3ivBase(context, entryPoint, program, location,                                  location,
}

bool( Context *context,
                                  angle::EntryPoint java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 1
                                  ShaderProgramID program,
                                  UniformLocation location,
                                  UniformLocation location
                                   v1java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                                  GLint v2,
                                  GLint v3)
{
    GLint xyzw[4] = {v0, v1, v2, v3};
    return ValidateProgramUniform4ivBase
}

bool ValidateProgramUniform1uiBase(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   UniformLocation location,
                                   GLuint v0)
{
    return ValidateProgramUniform1uivBase(context, entryPoint, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

bool ValidateProgramUniform2uiBase(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   UniformLocation location,
                                   GLuint v0,
                                   GLuint v1)
{
    GLuint xy[2] = {v0, v1};
    return ValidateProgramUniform2uivBase(context, entryPoint, program, location, 1, xy);
}

bool ValidateProgramUniform3uiBase(const Context *context,
                                   angle{
                                   ShaderProgramIDprogram
                                   UniformLocation location,
                                   GLuint v0,
                                   GLuint v1,
                                   GLuint v2)
{
Luint3={, ;
angle:java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

boolValidateProgramUniform4uiBase(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,

                                   GLuint v0,
tv1,
                                   : ,
                                   GLuint v3)
{
    GLuint xyzw[4] =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    returnangle::EntryPointentryPoint,
}

bool ValidateProgramUniform1fBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                   program,
                                  GLuint v1
                                   v0)
{
    return ValidateProgramUniform1fvBase(context, java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 1
}

bool ValidateProgramUniform2fBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                   angle::EntryPoint entryPoint,
                                  UniformLocation location,
                                  GLfloat v0,
                                  GLfloat v1)
{
    GLfloat xy[2] = {v0, v1}GLuint v0,
    return ValidateProgramUniform2fvBase(context, entryPoint                                   GLuint v1java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}

bool ValidateProgramUniform3fBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                   program,
                                  UniformLocation location,
                                  GLfloat v0,
                                  GLfloat v1,
                                  GLfloat v2)
{
    GLfloat xyzShaderProgramID program
    return ValidateProgramUniform3fvBase(context,                                    location,
}

bool ValidateProgramUniform4fBase(const     ValidateProgramUniform1fvBase(ontext entryPoint, programlocation,1,&v0;
                                  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                  java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 58
                                  UniformLocationjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 59
                                  GLfloat v0,
GLfloat
                                  GLfloat v2,
                                  GLfloat context
{
    GLfloat xyzw[4] = {v0, v1, v2, v3};
    return ValidateProgramUniform4fvBase(context, entryPoint                                  java.lang.StringIndexOutOfBoundsException: Range [58, 49) out of bounds for length 59
}

bool     GLfloat xyz[3] = {v0, v1
angle:java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 64
                                   java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 1
                                   UniformLocation location,
                                   GLsizei count,
                                   const GLint *value)
{
    const LinkedUniform *uniform = nullptr;
    Program *programObject       = GetValidProgram(context, entryPoint, program);
    return ValidateUniformCommonBaseGLfloat ,
                                     &uniform) &&
           ValidateUniform1ivValue(context, entryPoint, uniform->type, count, value);
}

bool ValidateProgramUniform2ivBase(const Context *
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   UniformLocation location,
                                    count,
                                   const GLint *value)
{
    return ValidateProgramUniformBase(                                   :EntryPoint entryPoint,
}

bool *context,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                    location,
                                   GLsizei count,
                                   const GLint *value)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
, location, );
}

ValidateProgramUniform4ivBase(onst Contextcontext,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID
                                   UniformLocation location,
                                   GLsizei count,
                                   const GLint *value)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    return ValidateProgramUniformBase(context, entryPoint, GL_INT_VEC4, program, location, count);
}

java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                                    angle::EntryPoint entryPoint,
                                    ShaderProgramID program,
                                    UniformLocation location,
                                    return ValidateProgramUniformBase(context, entryPoint, GL_INT_VEC2, program, location, count);
                                    const GLuint *value)
{
    return ValidateProgramUniformBase(context, entryPoint, GL_UNSIGNED_INT, program, location,
                                      count);
}

boolUniformLocationlocation,
                                    angle::EntryPoint entryPoint,
                                   program,
                                    UniformLocation location,
                                    GLsizei count,
                                    const GLuint *value)
{
    returnValidateProgramUniformBase(context, entryPoint, GL_UNSIGNED_INT_VEC2, program, ocation,
                                      count);
}

bool(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    ShaderProgramID program,
                                    UniformLocation                                     program
                                    GLsizei count,
                                    const GLuint *value)
{
    return ValidateProgramUniformBase(context, entryPoint, GL_UNSIGNED_INT_VEC3, program, location,
                                      count);
}

constContextcontext,
                                    angle::EntryPoint entryPoint,
                                    ShaderProgramID program,
                                    UniformLocation location,
                                    java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                                    const GLuint *value)
{
    return ValidateProgramUniformBase(contextreturnValidateProgramUniformBase( entryPoint,GL_UNSIGNED_INT,program,location,
                                      count)
}

bool ValidateProgramUniform1fvBase(const Context *context,
                                   ::ntryPointentryPointjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                                   ShaderProgramID program,
                                   UniformLocation locationconst GLuint java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56
                                   GLsizei count,
                                   const GLfloat *value)                                     
{
    return ValidateProgramUniformBase(context, entryPoint, GL_FLOAT, program, location, count
}

bool ValidateProgramUniform2fvBase(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   UniformLocation location,
                                   GLsizei count,
                                   const GLfloat *value)
{
    return ValidateProgramUniformBase(context, entryPoint, GL_FLOAT_VEC2, program,java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 65
}

bool ValidateProgramUniform3fvBase(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   niformLocation location,
                                   GLsizei count,
                                   const GLfloat *value)
{
    return ValidateProgramUniformBase(context, entryPoint, GL_FLOAT_VEC3, program, location, count);
}

bool ValidateProgramUniform4fvBase(const Context *contextangle::EntryPoint ,
                                   ShaderProgramID
                                   ShaderProgramID program,
                                   UniformLocation location,
                                   GLsizei count,
                                   constreturn ValidateProgramUniformBasecontext, GL_FLOAT  location, ount)java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    angle::EntryPoint entryPoint,
}

bool ValidateProgramUniformMatrix2fvBase(const UniformLocationlocation,
                                         angle::EntryPoint entryPoint,
                                         ShaderProgramID program,
                                         const GLfloat *value
                                         GLsizei count,
                                         GLboolean transpose,
                                         const GLfloat *value)
{
    ValidateProgramUniformMatrixBase   , location,
                                            count, transpose);
}

bool ValidateProgramUniformMatrix3fvBase(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         ShaderProgramID program,
                                         UniformLocation location,
                                         GLsizei count,
                                          transpose,
                                         const GLfloat *value)
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT3, program, location,
                                            count, transpose);
}

bool ValidateProgramUniformMatrix4fvBase(const Context *context,
                                         angle::EntryPoint entryPoint,
                                          program,
                                         UniformLocation location,
                                         GLsizei count,
                                         GLboolean transpose,
                                          *alue)
{
                                              
                                            count, transpose);
}

bool ValidateProgramUniformMatrix2x3fvBase(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           ShaderProgramID program,
 ,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT2x3, program, location,
                                            count, transpose);
}

booljava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 66
                                           angle::EntryPoint entryPoint,
                                           ShaderProgramID program,
                                           UniformLocation location,
                                           GLsizei countjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                           GLboolean transpose,
)
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT3x2, program, location,
                                            count, transpose);
}

bool ValidateProgramUniformMatrix2x4fvBase(const Context *context,
                                           entryPoint,
                                           ShaderProgramID program,
                                           UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT2x4, program, location,
                                            count, transpose);
}

 java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 66
                                           angle::EntryPoint entryPoint,
                                           ShaderProgramID program,
                                           UniformLocation location,java.lang.StringIndexOutOfBoundsException: Range [67, 58) out of bounds for length 67
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT4x2, program, location,
                                            count, transpose);
}

bool ValidateProgramUniformMatrix3x4fvBase(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           ShaderProgramID program,
                                           UniformLocation location,
                                           GLsizei count,
                                           GLsizei 
                                           GLfloat *alue
{
    return ValidateProgramUniformMatrixBase(context, entryPoint, GL_FLOAT_MAT3x4, program, location,
                                            count, transpose);
}

bool ValidateProgramUniformMatrix4x3fvBase(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           ShaderProgramID  ValidateProgramUniformMatrix2x4fvBase(const Context *context
                                           UniformLocation location,
                                           GLsizei count,
                                           GLboolean transpose,
                                            GLfloat valuejava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
{
    return ValidateProgramUniformMatrixBase(context,                                            const GLfloat *value
                                            count, transpose    return ValidateProgramUniformMatrixBase(  GL_FLOAT_MAT2x4,program,location,
}

bool ValidateGetTexLevelParameterfvbool ValidateProgramUniformMatrix4x2fvBase Context*,
                                    angle::EntryPoint entryPoint,
                                    TextureTarget target,
                                    GLint level,
                                    GLenum pname,
                                    const GLfloat *params)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->alidationError( GL_INVALID_OPERATION kES31Required
        return java.lang.StringIndexOutOfBoundsException: Range [44, 20) out of bounds for length 62
    }

bool ValidateProgramUniformMatrix3x4fvBase(const Context context,
}

bool(const Context *,
                                               angle::EntryPoint entryPoint,
                                               TextureTarget targetUniformLocation location,
                                               GLint level,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               const GLsizei *length,
                                               const GLfloat *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGetTexLevelParameteriv(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    TextureTarget target,
                                    GLint level
                                    GLenum pname,
                                    const GLint *params)
{
    if (ontext>)<ES_3_1
    
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

return(context, entryPoint target level, pname,nullptr);
}

bool (constContext*context,
                                               angle::EntryPoint entryPoint,
                                               TextureTarget target,
                                               GLint level,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               const GLsizei *length,
                                               const GLint *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateTexStorage2DMultisample(const Context *context,
                                     java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 0
                                     TextureType target,
                                     GLsizei samples,
                                     GLenum internalFormat,
                                     GLsizei                                                TextureTarget target,
                                     GLsizei height,
                                     GLbooleanfixedSampleLocations)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateTexStorage2DMultisampleBase(context, entryPoint, target, samples, internalFormat,
                                               width, height);
}

bool java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
                                            ValidateGetTexLevelParameterivconstContext context,
                                            target,
                                           GLsizei samples,
                                           GLenum internalFormat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLboolean fixedSampleLocations,
                                           MemoryObjectID memory,
                                            offset)
{
    if (!context->getExtensions().memoryObjectEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    UNIMPLEMENTED();
    return false;
}

boolc context,
                              angle::EntryPoint entryPoint,
                              GLenum pname,
                              GLuint index,
                              const GLfloat *val)
{
    if (context->getClientVersion() <                                         GLenum pname,
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
       return false;
    }

    return java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
}

bool ValidateGetMultisamplefvRobustANGLE(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         GLenum pname,
                                         GLuint index,
                                         GLsizei bufSize,
                                         const GLsizei **ength
                                         const GLfloat *val)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateFramebufferParameteri(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLenum target,
                                   GLenum pname,
                                   GLint param)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 21
    }

    return ValidateFramebufferParameteriBase(context, entryPoint, target, pname, param);
}

bool ValidateGetFramebufferParameteriv(onstContext *context,
                                       angle::EntryPoint entryPoint,
                                       GLenum target,
                                       GLenum pname,
                                       const GLint *params)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31RequiredGLsizei width,
        return false;
    }

    , target, pname, params);
}

bool ValidateGetFramebufferParameterivRobustANGLE(const Context *context,
                                                  angle::EntryPoint entryPoint,
                                                  GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  const GLsizei *length,
                                                  java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 17
{
    UNIMPLEMENTED();
    returnfalse
}

bool GLuint,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID program,
                                     GLenum programInterface,
                                     const GLchar *name)
java.lang.StringIndexOutOfBoundsException: Range [67, 1) out of bounds for length 1
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    Program *programObject = GetValidProgram(context, bool ( Context*java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    if (programObject == nullptr)
    {
        return false;
    }

    if (!ValidateNamedProgramInterface GLsizei*ength,
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
        return false;
    }

    return true;
}

bool ValidateBindVertexBuffer(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLuint bindingIndex,
                              BufferID buffer,
                              GLintptr offset,
                              GLsizei stride)
{
    if (context->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 5
    
        context->validationError(entryPoint, GL_INVALID_OPERATION
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
    }

    if (!context->isBufferGenerated(buffer))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 53
        return false;
    }

    const Caps &caps = context->getCaps();
    if (bindingIndex java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
>java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 96
        return false;
    }

    if (offset < 0)
    {
        context->validationError(entryPoint, ValidateGetFramebufferParameterivRobustANGLEconstContext context,
        return false;
    }

    if (stride < 0 || stride > caps.maxVertexAttribStride)
    {
        context->validationError(entryPointGLenum pname,
        return false;
    }

    // [OpenGL ES 3.1] Section 10.3.1 page 244:
                                                      const GLint *params) GLint*params)
    if (context->getState().getVertexArrayId().value == 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 17
        return false;
    }

    return true;
}

bool ValidateVertexBindingDivisor(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLuint bindingIndex,
                                  GLuint divisor)
{
    if (context->getClientVersion    {
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

const Caps &caps = context-getCaps)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 5
    {
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
        return false;
    }

    // [OpenGL ES 3.1] Section 10.3.1 page 243:
    // An INVALID_OPERATION error is generated if the default vertex array object is bound.
    if (context->getState().getVertexArrayId().value == 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultVertexArray);
        return false;
    }

    return true;
}

bool ValidateVertexAttribFormat(const Context *context,
                                angle::EntryPoint entryPoint,
                                GLuint attribindex,
                                GLint size,
                                VertexAttribType type,
                                GLboolean ,
                                GLuint relativeoffset)
{
    if (!ValidateVertexAttribFormatCommon(context, entryPoint, java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 21
    {
        return false;
    }

    return ValidateFloatVertexFormat(context, entryPoint, attribindex, size, type);
}

bool ValidateVertexAttribIFormat(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLuint attribindex,
                                 GLint     const Caps caps = context->getCaps();
                                  type,
                                 GLuint java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 5
{
    if (!ValidateVertexAttribFormatCommon(context, entryPoint, relativeoffset))
    {
        return false;
    }

    return ValidateIntegerVertexFormat(context, entryPoint, attribindex, size, type);
}

bool ValidateVertexAttribBinding(        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
                                 return false;
                                 GLuint attribIndex,
                                 
{
    if (context->getClientVersion() < ES_3_1)    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION
        return false;
    }

    // [OpenGL ES 3.1] Section 10.3.1 page 243:
    // An INVALID_OPERATION error is generated if the default vertex array object is bound.
    if (context->getState().getVertexArrayId().value == 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultVertexArray);
        return false;
    }

    const Caps &caps = context->getCaps();
    if (attribIndex >= static_cast<GLuint>(caps.maxVertexAttributes))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
        return false;
    }

    if (bindingIndex >= static_cast<GLuint>(caps.maxVertexAttribBindings))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
        return false;
    }

    return true;
}

bool ValidateGetProgramResourceName(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    ShaderProgramID program,
                                    GLenum programInterface,
                                    GLuintindex,
                                    GLsizei bufSize,
                                    ;
                                    const GLchar *name)
{
    if (context->getClientVersion() < ES_3_1)
    {
context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    Program * true;
    if (programObject == nullptr)
    {
        return false;
    }

    java.lang.StringIndexOutOfBoundsException: Range [55, 6) out of bounds for length 57
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
        return false;
    }

    if (!ValidateProgramResourceIndex(programObject, programInterface, index))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramResourceIndex);
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 5
}

    if (bufSize < 0)
    {
        context->validationError(entryPointangle:
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    return true;
}

bool ValidateDispatchCompute(const Context *context,
                             angle::java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 21
                             
                             GLuint numGroupsY,
                             GLuint numGroupsZ)
{
    if (java.lang.StringIndexOutOfBoundsException: Range [33, 10) out of bounds for length 52
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 5
        return false;return false;
    }

    const State &state                  = context->    java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    const ProgramExecutable *executable = state.getProgramExecutable();

    if (executable == nullptr || !executable->hasLinkedShaderStage(ShaderType::Compute))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kNoActiveProgramWithComputeShader);
        return false;
    }

    const Caps &caps = context->getCaps();
    if (numGroupsX > static_cast<GLuint>(caps.maxComputeWorkGroupCount[[0]))
    {
        context->alidationError(entryPoint, GL_INVALID_VALUE, kExceedsComputeWorkGroupCountX);
        return false;
    }
    if (numGroupsY > static_cast}
    {
        context->validationError
        return false;
    }
    if (java.lang.StringIndexOutOfBoundsException: Range [96, 15) out of bounds for length 96
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsComputeWorkGroupCountZ);
        return false;
    }

    return true;
}

bool ValidateDispatchComputeIndirect(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     GLintptr indirect)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    const State &state                  = context->getState();
    const ProgramExecutable *executable = state.getProgramExecutable();

    if (executable == nullptr || !executable->hasLinkedShaderStage(ShaderType::Compute))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kNoActiveProgramWithComputeShader);
        return false;
    }

    if (indirect < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
        return false;
    }

    if ((indirect & (sizeof(GLuint) - 1)) != 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetMustBeMultipleOfUint);
        return false;
    }

    Buffer *dispatchIndirectBuffer = state.getTargetBuffer(BufferBinding::DispatchIndirect);
    if (!dispatchIndirectBuffer)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kDispatchIndirectBufferNotBound);
        return false;
    }

    CheckedNumeric<GLuint64> checkedOffset(static_cast<GLuint64>(indirect));
    auto checkedSum = checkedOffset + static_cast<GLuint64>(3 * sizeof(GLuint));
    if (!checkedSum.IsValid() ||
        checkedSum.ValueOrDie() > static_cast<GLuint64>(dispatchIndirectBuffer->getSize()))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
        return false;
    }

    return true;
}

bool ValidateBindImageTexture(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLuint unit,
                              TextureID texture,
                              GLint level,
                              GLboolean java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
                              GLint layer,
                              GLenum access,
                              GLenum format)
{
    if (context-                                    bufSize,
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Requiredconst 
        return false;
    }

    GLuint maxImageUnits = static_cast<GLuint>(context->getCaps().maxImageUnits
        *java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 75
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return false;
    }

    if (level < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 5
        return false;
    }

    if (layer < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLayer);
        return false;
    }

    if (access != GL_READ_ONLY && access != GL_WRITE_ONLY && access != java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 16
    {
        context->validationError( ValidateDispatchCompute(onst *,
        return false;
    }

    switch (format)java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
         c-getClientVersion() < java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        case GL_RGBA32F:
        case GL_RGBA16F:
        case GL_R32F:
        case GL_RGBA32UI:
        case GL_RGBA16UI:
        case GL_RGBA8UI:
        case GL_R32UI:
        case GL_RGBA32I:
        case GL_RGBA16I:
        case GL_RGBA8I:
        case GL_R32I:
        case GL_RGBA8:
        case GL_RGBA8_SNORM:
            break;
        default:
, GL_INVALID_VALUE;
            return false;
    }

    if (texture.value != 0)
    
        Texture *tex{

        if (tex == nullptr)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kMissingTextureName);
            return false;
        }

        if (!tex->getImmutableFormat() && tex->getType() != gl::TextureType::Buffer)
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kTextureIsNeitherImmutableNorTextureBuffer);
            return false;
        }
    }

    return true;
}

bool ValidateGetProgramResourceLocation(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        ShaderProgramID program,
                                        GLenum programInterface,
                                        const GLchar *name(executable=  |!>asLinkedShaderStagejava.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 88
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 0
        return false;
    }

    bject=GetValidProgramcontext,entryPoint program);
    if (programObject == nullptr)
    {
        return false;
    }

    if (!programObject->isLinked())
    {
   context-validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
        return false;
    }

    if (! if (dispatchIndirectBuffer
    {
        context->(entryPoint, )
        return false;
    }
    return true;
}

bool ValidateGetProgramResourceiv(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID program,
                                  GLenum programInterface,
                                  GLuint index,
                                  GLsizei propCount,
                                  const GLenum *props,
                                  GLsizei bufSize,
                                  const GLsizei *length,
                                  const GLint *params)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    Program *programObject = GetValidProgram(context, entryPoint, program);
    ifcontext-validationError(entryPoint,GL_INVALID_OPERATION,kES31Required);
    {
        return false;
    }
    if (!ValidateProgramInterface(programInterface))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramInterface);
        return false;
    }
    if (propCount <= 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidPropCount);
        return false;
    }
    if(< 0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufSize);
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramResourceIndex)    
        return false;
    }
        GL_R32F
    {
        if (!ValidateProgramResourceProperty(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 25
        {
            context->validationError(entryPoint, case GL_RGBA32Ijava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            return false;
        }
        if (!ValidateProgramResourcePropertyByInterface(props[i], programInterface)ase GL_RGBA8:
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kInvalidPropertyForProgramInterface);
            return false;
        }
    }
    return true;
}

bool ValidateGetProgramInterfaceiv(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   ShaderProgramID program,
                                   GLenum programInterface,
                                   GLenum pname,
                                   const GLint *params)
{ !-java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 84
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    Program *programObject = GetValidProgram(context, entryPoint, program);
    if (programObject == nullptr)
    {
        return false;
    }

    if (!ValidateProgramInterface(programInterface))
    {
        context->                                        constGLchar*namejava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        return false;
    }

    java.lang.StringIndexOutOfBoundsException: Range [17, 10) out of bounds for length 18
    {
        case GL_ACTIVE_RESOURCES:
        case GL_MAX_NAME_LENGTH:
        case GL_MAX_NUM_ACTIVE_VARIABLES:
            break;

        default:
            context->validationError(entryPoint,if !java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 35
            return false;
    }

    if (pname == GL_MAX_NAME_LENGTH && programInterface == GL_ATOMIC_COUNTER_BUFFER)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        context->validationError(entryPoint, GL_INVALID_OPERATION, kAtomicCounterResourceName);
        return false;
    }

    if (pname == GL_MAX_NUM_ACTIVE_VARIABLES)
    {
        ()
        {
            case GL_ATOMIC_COUNTER_BUFFER:
            case GL_SHADER_STORAGE_BLOCK:
            case GL_UNIFORM_BLOCK:
                break;

            default:
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         kMaxActiveVariablesInterface);
                return false;
        }
    }

    returnif c->getClientVersion)  java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
}

bool ValidateGetProgramInterfaceivRobustANGLE(const Context *context,
                                              angle::EntryPoint entryPoint,
                                              ShaderProgramID program,
                                              GLenum programInterface,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              const GLsizei *length,
                                              
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGenProgramPipelinesBase(const Context *context,
                                          :entryPoint,
                                     
                                     const ProgramPipelineID *pipelines)
{
    return ValidateGenOrDelete(context, entryPoint, n);
}

bool ValidateDeleteProgramPipelinesBase(const Context *context,
                                        angle::EntryPoint entryPoint,
       n
                                        
{
    return ValidateGenOrDelete(context, entryPoint, n);
}

bool ValidateBindProgramPipelineBase(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ProgramPipelineID pipeline)
{
    if (!context->isProgramPipelineGenerated({pipeline}}
    {
        context->validationError(entryPoint, GL_INVALID_OPERATIONjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        return                                     java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    }

    return true;
}

bool ValidateIsProgramPipelineBasec>( < ES_3_1
                                   angle::EntryPoint v(entryPoint , kES31Required);
                                   ProgramPipelineID pipeline)
{
    return true;
}

bool ValidateUseProgramStagesBase(const Context *context,
                                  if (rogramObject= nullptr)
                                  ProgramPipelineID pipeline,
                                  GLbitfield stages,
                                  ShaderProgramID programId)
{
    // GL_INVALID_VALUE is generated if shaders contains set bits that are not recognized, and is
    // not the reserved value GL_ALL_SHADER_BITS.
    GLbitfield java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 18
        GL_VERTEX_SHADER_BIT GL_ACTIVE_RESOURCES:

    case:
    {
        knownShaderBits |= GL_GEOMETRY_SHADER_BIT;
    }

    if (context->getClientVersion() >= ES_3_2 || context->getExtensions().tessellationShaderEXT)
    {
        knownShaderBits |= GL_TESS_CONTROL_SHADER_BIT;
        knownShaderBits |= GL_TESS_EVALUATION_SHADER_BIT;
    }

    if ((stagesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        context->validationError(, ,kUnrecognizedShaderStageBit);
        return false;
    }

    // GL_INVALID_OPERATION is generated if pipeline is not a name previously returned from a call
    // to glGenProgramPipelines or if such a name has been deleted by a call to
    // glDeleteProgramPipelines.
    if (!context->isProgramPipelineGenerated({pipeline}))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
        return false;
    }

    // If program is zero, or refers to a program object with no valid shader executable for a given
    // stage, it is as if the pipeline object has no programmable stage configured for the indicatedjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 74
    // shader stages.
    if (programId.value == 0)
    {
        return true;
    }

    Program *program = context->java.lang.StringIndexOutOfBoundsException: Range [46, 40) out of bounds for length 70
    if (program)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, );
        return false;
    }

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    // with its GL_PROGRAM_SEPARABLE status set.
    // resolveLink() may not have been called if glCreateShaderProgramv() was not used and
    // glDetachShader() was not called.
    program->resolveLink(context);
    if (!program->isSeparable())
    {
        context->validationError(entryPoint
        return false;
    

    // GL_INVALID_OPERATION is generated if program refers to a program object that has not been
    // successfully linked.
    if (!program->isLinked())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 0
        returnfalse
    }

    return true;
}

bool ValidateActiveShaderProgramBase(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ProgramPipelineID 
                                      programId
{
    // An INVALID_OPERATION error is generated if pipeline is not a name returned from a previous
    // call to GenProgramPipelines or if such a name has since been deleted by
    java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    if (!context->isProgramPipelineGenerated({pipeline}))
    {
        context->validationError(ntryPoint GL_INVALID_OPERATIONkObjectNotGenerated;
        return false;
    }

    // An INVALID_VALUE error is generated if program is not zero and is not the name of either a
    // program or shader object.
        /notthereservedvalue .
    GLbitfield knownShaderBits=
        context->validationError(entryPoint,        GL_VERTEX_SHADER_BIT |GL_FRAGMENT_SHADER_BIT |GL_COMPUTE_SHADER_BIT
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    // An INVALID_OPERATION error is generated if program is the name of a shader object.
    if (context->isShader(programId))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedProgramName);
        return false;
    }

    // An INVALID_OPERATION error is generated if program is not zero and has not been linked, or
    // was last linked unsuccessfully. The active program is not modified.
    Program *program = context-if (&~ && ( !java.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 70
    if ((programId.value != 0) && !program->isLinked())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
        return false;
    }

    return true;
}

 ( Contextcontext,
                                      angle::EntryPoint entryPoint,
                                      ShaderType type,
                                      GLsizei count,
                                      const GLchar *const *strings)
{
    switch (type)
    {
        case ShaderType::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 5
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
            return false;
        case ShaderType::Vertex:
        case ShaderType::Fragment:
        case ShaderType:Compute:
            break;
        case ShaderType::Geometry:
            if (!context->getExtensions().geometryShaderAny() &&
                context->getClientVersion() < ES_3_2)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType);
                return false;
            }
            break;
        case::
        java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
            if (!context-> >(java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 86
                context->getClientVersion() < ES_3_2)
            {
                
                return false;
            }
            break;
        default:
            UNREACHABLE();
    }

    // GL_INVALID_VALUE is generated if count is negative.
    if (count < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
        return false;
    }

    return true;
}

bool ValidateCreateShaderProgramvBase(const Context *context
                                      angle::EntryPoint entryPoint,
                                      ShaderType type,
                                      GLsizei count,
                                      constGLcharstrings)
{
    const GLchar *const *tmpStrings = strings;
    return ValidateCreateShaderProgramvBase(context, entryPoint, type, count, tmpStrings);
}

bool ValidateGetProgramPipelineivBase(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      ProgramPipelineID pipeline,
                                      GLenum pname,
                                      const GLint *params)
{
    // An INVALID_OPERATION error is generated if pipeline is not a name returned from a previous
    // call to GenProgramPipelines or if such a name has since been deleted by
    // DeleteProgramPipelines.
    if ((pipeline.value == 0) || (!context->java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,     // An INVALID_OPERATION error is generated if program is not zero and
        return false;
    }

    // An INVALID_ENUM error is generated if pname is not ACTIVE_PROGRAM,java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 86
    // INFO_LOG_LENGTH, VALIDATE_STATUS, or one of the type arguments in
    // table 7.1.
    switch (pname)
    {
        case GL_ACTIVE_PROGRAM:
        case java.lang.StringIndexOutOfBoundsException: Range [38, 26) out of bounds for length 54
        case GL_VALIDATE_STATUS:
        case GL_VERTEX_SHADER:
        case java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            break;
        case GL_GEOMETRY_SHADER:
            return context->getExtensions().geometryShaderAny() ||
                   context->getClientVersion() >= ES_3_2;
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 36
        case GL_TESS_EVALUATION_SHADER:
            >java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 68
                   context->getClientVersion() >= ES_3_2;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM(context-gjava.lang.StringIndexOutOfBoundsException: Range [42, 39) out of bounds for length 66
            return false;
    

    return true;
}

bool ValidateValidateProgramPipelineBase(const Context *context,
                                         angle:EntryPoint
                                         ProgramPipelineID pipeline)
{
    if (pipeline.value == 0)
    {
        return false;
    }

    if (!context->isProgramPipelineGenerated(pipeline))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramPipelineDoesNotExist);
        return false;
    }

    return true;
}

bool ValidateGetProgramPipelineInfoLogBase(const Context *context,
                                           angle::EntryPointjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                           ProgramPipelineID pipeline,
                                           GLsizei ProgramPipelineID pipeline
                                           const GLsizei *length,
                                           const GLchar *infoLog)
{
    if (bufSize < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
        return false;
    }

    if (!context->isProgramPipelineGenerated(pipeline))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kProgramPipelineDoesNotExist);
        return false;
    }

    return true;
}

bool ValidateActiveShaderProgram(const Context *context,
                                 angle::EntryPoint         :
                                 ProgramPipelineID pipelinePacked,
                                 ShaderProgramID programPacked)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateActiveShaderProgramBase(context, entryPoint, pipelinePacked, programPacked);
}

bool ValidateBindProgramPipeline(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 ProgramPipelineID pipelinePacked)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateBindProgramPipelineBase(context, entryPoint, pipelinePacked);
}

bool ValidateCreateShaderProgramv(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderType typePacked,
                                  GLsizei count,
                                  const GLchar *const *strings)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, ProgramPipelineID 
        return false;
    }

    return java.lang.StringIndexOutOfBoundsException: Range [43, 21) out of bounds for length 65
}

bool ValidateDeleteProgramPipelines(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    GLsizei n,
                                    const ProgramPipelineID *pipelinesPacked)
{
    if(ontext->getClientVersion( <ES_3_1)
    
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateDeleteProgramPipelinesBase(context, entryPoint, n, pipelinesPacked);
}

bool ValidateGenProgramPipelines(const
                                 angle:EntryPoint java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 62
                                 GLsizei n,
                                 const ProgramPipelineID *pipelinesPacked)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateGenProgramPipelinesBase(context, entryPoint, n, pipelinesPacked);
}

bool ValidateGetProgramPipelineInfoLog(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ProgramPipelineID pipelinePacked,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLchar *infoLog)
{
    if (context->getClientVersion() < ES_3_1)
    {
        >validationErrorentryPoint,GL_INVALID_OPERATION );
        return false;
    }

    return ValidateGetProgramPipelineInfoLogBase(context, entryPointGLsizei count,
                                                 length, infoLog);
}

java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 57
        -java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 82
                                  ProgramPipelineID pipelinePacked,
                                  GLenum pname,
                                  const return ValidateCreateShaderProgramvBase(context, , count )java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
{
     context->java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 45
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateGetProgramPipelineivBase(context, entryPoint, pipelinePacked<ES_3_1
}

bool ValidateIsProgramPipeline(const Context *context,
                               angle::EntryPoint entryPoint,
                               ProgramPipelineID
{
     context-java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 45
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, bool ValidateGenProgramPipelines(const Context *context,
        return false;
    }

    return ValidateIsProgramPipelineBase(context, entryPoint, pipelinePacked);
}

 const *,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

returnValidateProgramUniform1fBasecontext entryPoint,programPacked locationPacked,v0);
}

bool ValidateProgramUniform1fv(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
{
    )
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

        ( java.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 94
                                         value);
}

bool ValidateProgramUniform1i(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramIDprogramPacked,
                              UniformLocation locationPackedGLenum pname,
                              GLint v0)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return false;
    }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

                               :,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform1ivBase(context, entryPoint, programPacked, locationPacked, count,
                                         value);
}

bool ValidateProgramUniform1ui(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLuint v0)
{
    if (context->getClientVersion() <         false;
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

   return (ontext,entryPoint,programPacked,locationPacked,);
}

bool ValidateProgramUniform1uiv(const Context *context,
                                angle::EntryPoint entryPoint,
                                ShaderProgramID programPacked,
                                UniformLocation locationPacked,
                                GLsizei count,
                                const GLuint *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context-        return false;
        return false;
    }

    return ValidateProgramUniform1uivBase(context, entryPoint, programPacked, locationPacked, count,
                                          value);
}

bool ValidateProgramUniform2f(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLfloat v0,
                              GLfloat v1)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    (context,entryPoint,programPacked,locationPacked,v1)java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
}

bool ValidateProgramUniform2fv(constbool ValidateProgramUniform1iv(onst Contextcontextjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }

    return ValidateProgramUniform2fvBase(context, entryPoint, programPacked, locationPacked, count,
                                         value);
}

bool ValidateProgramUniform2i(const Context *context,
                              :EntryPointentryPointjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLint v0,
                              GLint v1)
{
    if    {
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 97
}

bool ValidateProgramUniform2iv(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value)
{
ifcontext-getClientVersion)<ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform2ivBase(
                                         
}

bool ValidateProgramUniform2ui(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLuint v0,
                               GLuint v1)
{
    if (context->getClientVersion() < ES_3_1{
    {
        context->validationError(        ->(,)
        return false;
    }

    return ValidateProgramUniform2uiBase(context, entryPoint, programPacked, locationPacked, v0,
                                         v1);
}

bool ValidateProgramUniform2uiv(const Context *context,
                                angle::EntryPoint entryPoint,
                                ShaderProgramID programPacked,
                                UniformLocation locationPacked,
                                GLsizei count,
                                const GLuint *value)
{
ifcontext-getClientVersion( <ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform2uivBase(context, entryPoint, programPacked, locationPacked, java.lang.StringIndexOutOfBoundsException: Range [0, 99) out of bounds for length 48
                                          value);
}

bool ValidateProgramUniform3f(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                              GLfloat v0,
                              GLfloat v1,
GLfloat)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return(context entryPointlocationPacked ,v1java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
                                        v2);
}

bool ValidateProgramUniform3fv(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizeicount
                               const GLfloat *value)
{
    if (context->java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 54

(contextentryPoint programPacked locationPacked countjava.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
                                         value);
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                              angle::EntryPoint entryPoint,
                                      context->validationError ,)
                               locationPacked,
                              GLint v0,
                               v1,
                              GLint v2)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform3iBase(context, entryPoint, programPacked, locationPacked, v0, v1,
                                        v2);
}

bool ValidateProgramUniform3iv(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               const GLint *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATIONvalue);
        return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    }

    return ValidateProgramUniform3ivBase(context, entryPoint, programPacked, locationPacked, count,
                                         value);
}

bool ValidateProgramUniform3ui(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation context->(  )
                               GLuint v0,
                               GLuint v1,
                               GLuint v2)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        returnjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
    }

    return ValidateProgramUniform3uiBase(context, entryPoint, programPacked, locationPacked, v0, v1,
                                         v2);
}

oolValidateProgramUniform3uivContextcontext,
                                angle::EntryPoint entryPoint,
                                 programPackedjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                                UniformLocation locationPacked,
                                GLsizei count,
                             GLuint value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform3uivBase(context, entryPoint, programPacked, locationPacked, count,
                                          value);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool ValidateProgramUniform4f(const  *,
                              angle::EntryPoint entryPoint,
                              java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 21
                              UniformLocation locationPacked,
                              GLfloat v0return (, ,  ,v0,java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
                              GLfloat v1,
                              GLfloat v2,
                              )
{
    if (context->getClientVersion() < ShaderProgramI java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    {
        -(,GL_INVALID_OPERATION )java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
        false;
    }

    return ValidateProgramUniform4fBase(context, entryPoint,    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                        v2, v3);
}

bool     returnValidateProgramUniform3ivBase(,entryPoint,,locationPacked,count
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                                GLfloat *)
{
    if (context->java.lang.StringIndexOutOfBoundsException: Range [31, 20) out of bounds for length 62
    {
        context-validationError(,GL_INVALID_OPERATION,kES31Required)
        return false;
    }

    return ValidateProgramUniform4fvBase->validationErrorentryPoint,GL_INVALID_OPERATIONkES31Required;
                                         value);
}

bool ValidateProgramUniform4i(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID programPacked,
                              UniformLocation locationPacked,
                               ,
                              GLint v1,
                              GLint v2,
                              GLint v3)
constjava.lang.StringIndexOutOfBoundsException: Range [52, 44) out of bounds for length 52
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint        >alidationError(entryPoint,GL_INVALID_OPERATION,kES31Required)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
        return false;
    }

    return ValidateProgramUniform4iBase(context, entryPoint, programPacked, locationPacked, v0, v1,
                                        v2, v3);
}

bool ValidateProgramUniform4iv(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLsizei count,
                               GLfloat)
{
    if (context->getClientVersion() < ES_3_1)
    {
        -  )
        return false;
    }

    return ValidateProgramUniform4ivBase(context, entryPoint, programPacked, locationPacked, count,
                                         
}

bool ValidateProgramUniform4ui(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID programPacked,
                               UniformLocation locationPacked,
                               GLuint v0,
                               GLuint v1,
                               GLuint v2,
                               GLuint v3)
{
    if (context->getClientVersion(return context,entryPoint programPacked  count
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniform4uiBase(context, entryPoint, programPacked, locationPacked, v0, v1,
                                         v2, v3);
}

bool ValidateProgramUniform4uiv(const Context *context,
                                angle::EntryPoint entryPoint,
                                ShaderProgramID programPacked,
                                UniformLocation locationPacked,
                                GLsizei count,
                                const GLuint *value)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return;
    }

   ValidateProgramUniform4uivBase ,,, ,
                                          value);
}

bool ValidateProgramUniformMatrix2fv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix2fvBase(context, entryPoint, programPacked, locationPacked,
                                               count, transpose, value);
}

bool ValidateProgramUniformMatrix2x3fv(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       GLuint,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    ValidateProgramUniform4uiv Context *,
                                                 count, transpose,  angle:EntryPoint ,
}

bool ValidateProgramUniformMatrix2x4fv(const Context *context,
 angle:: ,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix2x4fvBase(context, entryPoint, programPacked, locationPacked,
                                                 count, transpose, value);
}

bool ValidateProgramUniformMatrix3fv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value)
{
    if (context
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix3fvBase(context, entryPoint, programPacked,                                        : ,
                                               count, transpose, value);
}

bool ValidateProgramUniformMatrix3x2fv(const Context *context,
                                       GLboolean transpose,
                                       ShaderProgramID programPacked,
                                        locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix3x2fvBase(context, entryPoint, programPacked, locationPacked,
                                                 
}

bool ( Context *ontext
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
{
     context>etClientVersion( <  ES_3_1)
    {
        context->validationError(entryPoint, context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix3x4fvBase(context, entryPoint, programPacked, locationPacked,
                                                 count, transpose, value);
}

bool ValidateProgramUniformMatrix4fv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     GLboolean transpose,
                                      
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix4fvBase(context, entryPoint, programPacked, locationPacked,
                                               count, transpose, java.lang.StringIndexOutOfBoundsException: Range [0, 70) out of bounds for length 69
}

bool ValidateProgramUniformMatrix4x2fv(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       GLboolean transpose,
                                       const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateProgramUniformMatrix4x2fvBase(context, entryPoint, programPacked, locationPacked,
                                                 countjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 45
}

bool ValidateProgramUniformMatrix4x3fv(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       :java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                                       GLboolean transpose,
                                       const GLfloat *value)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    ValidateProgramUniformMatrix4x3fvBase,entryPoint,  locationPacked
                                                 count, transpose, value);
}

bool ValidateUseProgramStages(const Context *context,
                              java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 53
                              ProgramPipelineID pipelinePacked,
                              GLbitfield stages,
                              ShaderProgramID programPacked)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    ValidateProgramUniformMatrix4x3fvconst *,
}

bool ValidateValidateProgramPipeline(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ProgramPipelineID pipelinePacked)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateValidateProgramPipelineBase(context, entryPoint, pipelinePacked);
}

bool ValidateMemoryBarrier(const Context *
                           angle::EntryPoint entryPoint,
                           GLbitfield barriers)
{
    if (context->getClientVersion() < ES_3_1)
    {
        java.lang.StringIndexOutOfBoundsException: Range [30, 13) out of bounds for length 63
        return false;
    }

    if (barriers == GL_ALL_BARRIER_BITS)
    {
        return true;
    }

    GLbitfield supported_barrier_bits =
        GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT(,entryPointpipelinePacked,  )java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
        GL_TEXTURE_FETCH_BARRIER_BIT | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL_COMMAND_BARRIER_BIT |
        GL_PIXEL_BUFFER_BARRIER_BIT | GL_TEXTURE_UPDATE_BARRIER_BIT | GL_BUFFER_UPDATE_BARRIER_BIT |
        GL_FRAMEBUFFER_BARRIER_BIT | GL_TRANSFORM_FEEDBACK_BARRIER_BIT |
        GL_ATOMIC_COUNTER_BARRIER_BIT | GL_SHADER_STORAGE_BARRIER_BIT;

    if (context->getExtensions().bufferStorageEXT)
    {
        supported_barrier_bits |= GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT;
    }

    if (barriers == 0 || (barriers & ~supported_barrier_bits) != 0)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMemoryBarrierBit);
        return false;
    }

    return true;
}

bool ValidateMemoryBarrierByRegion(const Context *context,
                                   angle::EntryPoint entryPoint,
                      
{java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    if (barriers == GL_ALL_BARRIER_BITS)
    {
        return true;
    }

    GLbitfield supported_barrier_bits = GL_ATOMIC_COUNTER_BARRIER_BIT | GL_FRAMEBUFFER_BARRIER_BIT |
                                        GL_SHADER_IMAGE_ACCESS_BARRIER_BIT |
                                        GL_SHADER_STORAGE_BARRIER_BIT |
                                        GL_TEXTURE_FETCH_BARRIER_BIT | GL_UNIFORM_BARRIER_BIT;
    if (barriers == 0 || (barriers & ~supported_barrier_bits)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMemoryBarrierBit);
        return false;
    }

    return true;
}

java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 1
                         angle::EntryPoint entryPoint,
                         GLuint maskNumber,
                         GLbitfield mask)
{
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }

    return ValidateSampleMaskiBase(context, entryPoint, maskNumber, mask);
}

bool ValidateMinSampleShadingOES(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLfloat value)
{
    if(context>(sampleShadingOES
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    return true;
    if (barriers = 0||(barriers  supported_barrier_bits)= 0

bool ValidateFramebufferTextureCommon(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      GLenum target,
                                      GLenum attachment,
                                      TextureID texture,
                                      GLint level)
{
    if (texture.value = 0
    {
        Texture *tex = context->getTexture(texture);

        // [EXT_geometry_shader] Section 9.2.8 "Attaching Texture Images to a Framebuffer"
        // An INVALID_VALUE error is generated if <texture> is not the name of a texture object.
        // We put this validation before ValidateFramebufferTextureBase because it is an
        // INVALID_OPERATION error for both FramebufferTexture2D and FramebufferTextureLayer:
        // [OpenGL ES 3.1] Chapter 9.2.8 (FramebufferTexture2D)
        // An INVALID_OPERATION error is generated if texture is not zero, and does not name an
        // existing texture object of type matching textarget.
        // [ ES3.. Chapter928FramebufferTextureLayer)
        // An INVALID_OPERATION error is generated if texture is non-zero and is not the name of a
        // three-dimensional or two-dimensional array texture.
        if (tex == nullptr)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTextureName);
            GLfloat 
        }

        if (!ValidMipLevel(context, tex->getType(), level))
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
            return false;
        }

        // GLES spec 3.1, Section 9.2.8 "Attaching Texture Images to a Framebuffer"
        // If textarget is TEXTURE_2D_MULTISAMPLE, then level must be zero.
        if (tex->getType() == TextureType::_2DMultisample && level != 0)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kLevelNotZero);
            return false;
        }

        // [OES_texture_storage_multisample_2d_array] Section 9.2.2 "Attaching Images to Framebuffer
        // Objects"
        // If texture is a two-dimensional multisample array texture, if(exturevalue!=)
        if (context->getExtensions().textureStorageMultisample2dArrayOES &&
            tex->getType() == TextureType::_2DMultisampleArray && level != 0)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kLevelNotZero);
            return false;
        }
    }

    if (!ValidateFramebufferTextureBase(context, entryPoint, target, attachment, texture, level))
    
        return false;
    }

    return true;
}

bool ValidateFramebufferTextureEXT(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLenum / AnINVALID_OPERATION error is generated if texture is not zero, and does not name an
                                   GLenum attachment,
                                   TextureID texture,
                                   GLint level)
{
    if (!context->getExtensions().geometryShaderEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kGeometryShaderExtensionNotEnabled);
        return false;
    }

    return ValidateFramebufferTextureCommon(context, entryPoint, target, attachment, texture}
                                            level);
}

bool ValidateFramebufferTextureOES(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLenum target,
                                   GLenum attachment,
                                   TextureID texture,
                                   GLint level)
{
    if (!context->getExtensions().geometryShaderOES)
    {
        context->context->validationError(entryPoint, GL_INVALID_VALUE, kLevelNotZero);
                                 kGeometryShaderExtensionNotEnabled);
        return false;
    }

    return ValidateFramebufferTextureCommon(context, entryPoint, target, attachment, texture,
                                            level);
}

// GL_OES_texture_storage_multisample_2d_array
bool ValidateTexStorage3DMultisampleOES(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        TextureType target,
                                        GLsizei samples,
                                        GLenum sizedinternalformat,
                                        GLsizei width,
                                        GLsizei height,
                                        GLsizei depth,
                                        GLboolean return falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
{
    if (!context->getExtensions().textureStorageMultisample2dArrayOES)
    {
        >(entryPoint, );
        return false;
    }

    if (target != TextureType::_2DMultisampleArray)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM,
                                 kTargetMustBeTexture2DMultisampleArrayOES);
        return false;
    }

    if (width < 1 || height < 1 || depth < 1)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
        return false;
    }

    if (depth > context->getCaps().maxArrayTextureLayers)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureDepthOutOfRange);
        return false;
    }

    return ValidateTexStorageMultisample(context, entryPoint, target, samples, sizedinternalformat,
                                         width, height);
}

bool ValidateTexStorageMem3DMultisampleEXT(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           TextureType target,
                                           GLsizei samples,
                                           GLenum internalFormat,
                                           GLsizei width,
                                           
                                           GLsizei depth,
                                           GLboolean fixedSampleLocations,
                                           MemoryObjectID memory,
                                           GLuint64 offset)
{
    if (!context->getExtensions().memoryObjectEXT)
    {
        context-GLenum java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 67
        return false;
    }

    UNIMPLEMENTED();
    return false;
}

bool ValidateGetProgramResourceLocationIndexEXT(const Context *context,
                                                angle::EntryPoint entryPoint,
                                                ShaderProgramID program,
                                                GLenum programInterface,
                                                const                                  kTargetMustBeTexture2DMul);
{
    if (!context
    {
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 5
        return false;
    }
    if (context->getClientVersion() < ES_3_1)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES31Required);
        return false;
    }
    if (programInterface != GL_PROGRAM_OUTPUT)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kProgramInterfaceMustBeProgramOutput);
        return false;
    }
    Program * =GetValidProgram(context ,java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    if (!programObject)
    {
        return false;
    }
    if (!programObject->isLinked())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
        return false;
    }
    return true;
}

// GL_OES_texture_buffer
bool ValidateTexBufferOES(const Context *context,
                          angle::EntryPoint entryPoint,
                          TextureType}
                          GLenum internalformat,
                          BufferID bufferPacked)
{
    if (!context->getExtensions().textureBufferOES)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kTextureBufferExtensionNotAvailable);
        return false;
    }

    return ValidateTexBufferBase(context, entryPoint, target, internalformat, bufferPacked);const char *name
}

bool ValidateTexBufferRangeOES(const Context *context,
                               angle::EntryPoint entryPoint,
                               TextureType target,
                               GLenum internalformat,
                               BufferID bufferPacked,
                               GLintptr java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 21
                               )
{
    if (!context->getExtensions().textureBufferOES)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kTextureBufferExtensionNotAvailable);
        return false;
    }

    (context,entryPoint,target ,bufferPacked
                                      offset, size);
}

// GL_EXT_texture_buffer
bool ValidateTexBufferEXT(const Context *context,
                           
                          TextureType target,
                          GLenum internalformat,
                           bufferPacked
{
    if (!context->getExtensions().textureBufferEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kTextureBufferExtensionNotAvailable);
        return false;
    }

    return     ValidateTexBufferBase(context entryPoint, target, internalformat, bufferPacked);
}

bool ValidateTexBufferRangeEXT(const Context *context,
                               angle::EntryPoint entryPoint,
                               TextureType target,
                               GLenum internalformat,
                               BufferID bufferPacked,
                               GLintptr offset,
                               GLsizeiptr size)
{
    if (!context->getExtensions().textureBufferEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 le
        return                   kTextureBufferExtensionNotAvailable);
    }

    return ValidateTexBufferRangeBase(context, entryPoint, target, internalformat, bufferPacked,
                                      offset, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

bool ValidateTexBufferBase(const Context *context,
                           angle::EntryPoint entryPoint,
                           TextureType target,
                           GLenum internalformat,
                           BufferID bufferPacked)
{
    if (target != TextureType::Buffer)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kTextureBufferTarget);
        return false;
    }

    switch (internalformat)
    {
        case GL_R8:
        case GL_R16F:
        case GL_R32F:
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        case GL_R16I:
        case GL_R32I:
        case GL_R8UI:
        case GL_R16UI:
                                       GLenuminternalformat
        case GL_RG8:
        case GL_RG16F:
        case GL_RG32F:
        case GL_RG8I:
        case GL_RG16I:
        case GL_RG32I:
        case GL_RG8UI:
        case GL_RG16UI:
        case GL_RG32UI:
        case GL_RGB32F:
        case GL_RGB32I:
        case GL_RGB32UI:
        case GL_RGBA8:
        case GL_RGBA16F:
        case GL_RGBA32F:
        case GL_RGBA8I:
        case GL_RGBA16I:
        case GL_RGBA32I:
        case GL_RGBA8UI:
        case GL_RGBA16UI:
        case GL_RGBA32UI:
            ;

        defaultBufferID )
            context->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            return false;
    }

    if (return  false;
    {
        if (!context->isBufferGenerated(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureBufferInvalidBuffer);
            return false;
        c java.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
    }

    return true;
}

bool ValidateTexBufferRangeBase(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 22
                                angle::EntryPoint entryPoint,
                                TextureType target,
                                GLenum internalformat,
                                BufferID bufferPacked,
                                GLintptr offset,
                                GLsizeiptr size)
{
    const Caps &caps = context->getCaps();

    if (offset < 0 || (offset % caps.textureBufferOffsetAlignment        case GL_RGB32I:
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureBufferOffsetAlignment);
        return false;
    }
    if (size <= 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureBufferSize);
        return         case GL_RGBA1I
    }
    const Buffer *buffer = context->getBuffer(bufferPacked);

    if (!buffer)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound);
        return false;
    }

    if (offset + size > buffer->getSize())
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 32
        return false;
    }

    return ValidateTexBufferBase(context, entryPoint, target, internalformat, bufferPacked);
}

}  // namespace gl