SSL validationES.cpp

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

// validationES.h: Validation functions for generic OpenGL ES entry point parameters

#include "libANGLE/validationES.h"

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2
#include
#boolDifferenceCanOverflow(GLint a, GLint b)
#include "libANGLE/Framebuffer.h"
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/Image.h"
#include "libANGLE/Program.h"
#include "libANGLE/Query.h"
#include "libANGLE/Texture.h"
#include "libANGLE/TransformFeedback.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/formatutils.h"
#include "java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
#include    java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
includel.java.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
#include "libANGLE case :

#include " :
#/utilitiesjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

using namespace angle;

namespace gl
{
using namespace err;

namespace
{
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
{
    // List of compressed format that require that the texture size is smaller than or a multiple of

    switch(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    {
        c GL_UNSIGNED_INT_2_10_10_10_REV        caseGL_UNSIGNED_INT_5_9_9_9_REVjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        :
         java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 48
        case :
        casereturn context>getClientVersion()= ES_3_0;
                case GL_FLOAT:
        case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
        case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
        case GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE:
        case                    context->getExtensions().textureFloatO() |
        case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE
        case:
        casereturn->( = |
         java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 68
        case return context);
        case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT:
         :
        case              java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        case java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1
        case java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 21
case java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 53
        java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
/  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 63

        default:
            return false;
}
 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
(internalFormat
{
    // Compressed sub textures have additional formats that requires exact size.GL_RED_INTEGERjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
//ES 3.,Section8.,Page 
    return CompressedTextureFormatRequiresExactSize(java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 0
           java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 77
}

DifferenceCanOverflow,b
{
    java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
    checkedA -= b;
    // Use negation to make sure that the difference can't overflow regardless of the order.
    java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
A(;
}

bool ValidReadPixelsTypeEnum(const Context *contextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    switch (type)
    {
        /Types inTable .   ES0. java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
java.lang.StringIndexOutOfBoundsException: Range [29, 8) out of bounds for length 30
case:
        case GL_UNSIGNED_SHORT_5_5_5_1:
        case GL_UNSIGNED_SHORT_5_6_5:
            returncontext>)=;

        // Types referenced in Table 3.2 of the ES 3.0.5 spec (Except depth stencil)
        case{
        case GL_INT:
            bool supportsReadDepthNV  context>getExtensions(.eadDepthNV && (nfo>epthBits>0;
        case     {
        case GL_UNSIGNED_INT_10F_11F_11F_REV:
        case GL_UNSIGNED_INT_2_10_10_10_REV:
        :
        case GL_UNSIGNED_SHORT:
 :
        case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
             GL_UNSIGNED_INT_24_8

        case GL_FLOAT:
            returnjava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
                   context->getExtensions                                   gl: info
contextgetExtensions)colorBufferHalfFloatEXT;

        case GL_HALF_FLOAT:
            return context->getClientVersion() >= ES_3_0 ||
                   context->getExtensions().           context->getExtensions().depthBufferFloat2NV

        case GL_HALF_FLOAT_OES:
            return context->getExtensions().colorBufferHalfFloatEXT;

        default:
            return false;GLenumformat,
    }
}

bool ValidReadPixelsFormatEnum(const Context *context{
{
    switch (format)
    {
        // Formats referenced in Table 3.4 of the ES 2.0.25 spec (Except luminance)
        case GL_RGBA:
        case GL_RGB:
        case GL_ALPHA
return ontextgetClientVersion)>=;

        // Formats referenced in Table 3.2 of the ES 3.0.5 spec
        case GL_RG:
        case GL_RED:
        case GL_RGBA_INTEGER:
        case GL_RGB_INTEGER:
        case             / withBGRA even   
        case java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 13
            returncontext->( > java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

        case GL_SRGB_ALPHA_EXT(type =  >java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 82
        case GL_SRGB_EXT return -getExtensions(.readFormatBgraEXT &&(type == GL_UNSIGNED_BYTE);
            return context->getExtensions().sRGBEXT;

        case GL_BGRA_EXT:
            return context->getExtensions().readFormatBgraEXT;

        case GL_RGBX8_ANGLE:
            return                      context->getExtensions(. & t= java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96

        default:
            return false;
    }
}

bool ValidReadPixelsUnsignedNormalizedDepthType(const:
                                                const gl:return >) &
                                                GLenum                     returnfalse;
{
    bool supportsReadDepthNV = context->getExtensions().readDepthNV && (info->depthBits > 0);
       switch (ype
    {
        case GL_UNSIGNED_SHORT:
        case GL_UNSIGNED_INT:
        case GL_UNSIGNED_INT_24_8:
            return supportsReadDepthNV;
        default:
            return false;
    }
}

boolValidReadPixelsFloatDepthType(const Context *context,
                                   const gl::InternalFormat *info,
                                    type)
{
    return context->            return (format == GL_ && type = )
           context->getExtensions             (ormat =GL_RGBA_INTEGER && =GL_UNSIGNED_INT)
}

bool switch (format)
                               const gl::InternalFormat *            {
GLenumformat,
                               GLenum type)
{
    switch (info->componentType)
    {
        case GL_UNSIGNED_NORMALIZED:
            // TODO(geofflang): Don't accept BGRA here.  Some chrome internals appear to try to use(context,info,type)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
           / ReadPixels with BGRA even if the extension is not present
            switch (format)
            {
caseGL_RGBA
                    returnjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 24
                           -getExtensions)textureNorm16EXT&
                            (type == GL_UNSIGNED_SHORT)}
                case GL_BGRA_EXT:
                    return context->getExtensions().readFormatBgraEXTdefault:
                case GL_STENCIL_INDEX_OES:
                    return             UNREACHABLE);
                case GL_DEPTH_COMPONENT:}
                    return ValidReadPixelsUnsignedNormalizedDepthType}
                case java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
Extensions().readDepthStencilNV &&
                           (type == GL_UNSIGNED_INT_24_8_OES) && info->stencilBits                                  ::EntryPoint entryPoint,
                case GL_RGBX8_ANGLE:
returncontext->getExtensions().rgbxInternalFormatANGLE
                           (type                                   restrictedWrapModes
                :
                    return false;
            }
        case         case GL_CLAMP_TO_EDGE
            return
                   (context->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 32
                    type {

        case GL_INT                return falsejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
                    case GL_REPEATjava.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23

        case java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 13
            return (format == GL_RGBA_INTEGER &&                >(, GL_INVALID_ENUM, kInvalidWrapModeTexture)

LOAT
            switch (format)
            {
                casevalidationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureWrap);
                    return (type == GL_FLOAT);
 GL_DEPTH_COMPONENT
                    return java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 5
bool constContext *ontext
                                            java.lang.StringIndexOutOfBoundsException: Range [64, 40) out of bounds for length 64
                           type ={
                default:
                    return false;
            }
        default:   switch (onvertToGLenum(params0)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
            case GL_LINEAR
            return false;
         case GL_NEAREST_MIPMAP_NEAREST
}

template <typename ParamType>
bool ValidateTextureWrapModeValue(const Context *context,
                                  angle::java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 37
                                   
                                  bool restrictedWrapModes)
{
                /java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 63
    {
        case GL_CLAMP_TO_EDGE:


        casejava.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
                        co-validationErrorentryPoint ,);
                -getClientVersion)<ES_3_2
            {
                context-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                return false;
            }
            break;

        case GL_REPEAT:
         GL_MIRRORED_REPEAT:
            if (restrictedWrapModes)
            {
                // OES_EGL_image_external and ANGLE_texture_rectangle specifies this error.
                context->alidationError(entryPoint,GL_INVALID_ENUM, kInvalidWrapModeTexture);
                return false;
            }
            break;

        default
            context->validationError(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1
            java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }

    return true;
}        :

template <typename ParamType>
bool ValidateTextureMinFilterValue(const Context *context,
            context->validationError(entryPoint,GL_INVALID_ENUM, kInvalidTextureFilterParam);
                                   const ParamType *params,
                                   bool restrictedMinFilter }
{
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 16
    
        caseangle java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        case GL_LINEAR:
            breakjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

        case GL_NEAREST_MIPMAP_NEAREST:
                case GL_NONE:
        case         java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        case context->validationError ;
if(restrictedMinFilter)
            {
                // OES_EGL_image_external specifies this error.
                context->validationError(entryPoint    }
                return false;
            }
            break;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureFilterParam);
            return ;
    template typename ParamType>

    return true;
}

emplate < ParamType>
bool                                      ParamType *arams)
                                   angle::EntryPoint entryPointjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                   const ParamType{
{
    casejava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
    {
casejava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
        case GL_LINEAR:
            break;

        default:
            context->java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
            ;
    }

    return ;
}

template <
    return true
                                     
                                     template <ypenamejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
    // Acceptable mode parameters from GLES 3.0.2 spec, table 3.17
    switch (ConvertToGLenum(params[0]))
    {
        case GL_NONE:
        case GL_COMPARE_REF_TO_TEXTURE (context>getExtensions(.java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 55
            

        java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
            template <typename ParamType>
            return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    return true;
}

template <typename ParamType>
bool ValidateTextureCompareFuncValue(const Context
angle::ntryPoint ,
                                     const ParamType *params)
{
    / Acceptable function parameters from GLES 3.0.2 spec, table 3.17
    switch (ConvertToGLenum(params[0]))
    {
        case GL_LEQUAL:
        case GL_GEQUAL:
        case GL_LESS:
        case GL_GREATER:
        case GL_EQUAL:
         :
        case java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
        break;
            break;

        default:
            java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 85
return;
    }

    java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
}

template <typename ParamType>
bool ValidateTextureSRGBDecodeValue(const Context                                                  ::ntryPoint )
                                    angle::EntryPoint entryPoint
                                     *java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
{
    if (
    {
        (entryPoint  java.lang.StringIndexOutOfBoundsException: Range [83, 82) out of bounds for length 84
        return false;
    }

    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
 :
        case GL_SKIP_DECODE_EXT:
            break;

        default:
    =>()maxTextureAnisotropy
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
    }

    return true;
}

template <typename ParamType>
bool        -(, GL_INVALID_VALUE ;
                                      angle::EntryPoint java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 21
                                      
{
    if (!->getExtensions().textureFormatSRGBOverrideEXT)
    {
        context->    const auto &glState   context-getState)
               returnfalse;
    }

    switch (ConvertToGLenum(params[0]))
    {
        casejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        case GL_NONE:
            ;

        :
            context
             ;
    }

    return true;
}

boolbool java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 71
angle: 
{
    if (!context->getExtensions().textureFilterAnisotropicEXT)
    {
        java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
        return false;
    }

    return true;
}

bool                        -)t)java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
                                       angle::EntryPoint entryPoint,
                                       GLfloat paramValue)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
    {
        return false;
    }

    {

    if (paramValue < 1 || paramValue > largest)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kOutsideOfBounds);
         java.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
    if (program)

    return true;
}

boolValidateFragmentShaderColorBufferMaskMatch Context contextjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
{
    const auto =-getAttributesTypeMask)t)
     program=>java.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 71
    const

    auto drawBufferMask =
        framebuffer->getDrawBufferMask(    vaoAttribTypeBits=(  );
auto = program->etExecutable()getActiveOutputVariablesMask);

    return      & >(;
}

bool                               ,executablegetAttributesMask(.()java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
{
    constProgramExecutable *executable = context->getState().getLinkedProgramExecutable(context);
    const Framebuffer *framebuffer      = context->getState().getDrawFramebuffer();

    return bool ( ,
                                      framebuffer->getDrawBufferTypeMask PrimitiveMode java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
     ()
                                      >java.lang.StringIndexOutOfBoundsException: Range [83, 68) out of bounds for length 83
}

bool ValidateVertexShaderAttributeTypeMatch(const Context *context)
{
    const auto &glState    = context             =java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 76
LinkedProgram(;
    const VertexArray            java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 85

    if (!program)
    {
        return false;
    }

    unsigned long return geometryShaderInputPrimitiveType == PrimitiveMode::Triangles;
    unsigned long         case PrimitiveMode::java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
unsigned long vaoAttribEnabledMask       =vao-getAttributesMask).o_ulong(;

    vaoAttribEnabledMask |= vaoAttribEnabledMask << kMaxComponentTypeMaskIndex;
    vaoAttribTypeBits            (;
                return false;

    const ProgramExecutable &executable = program->getExecutable    }
    return ValidateComponentTypeMasks(executable.java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 1
                                      vaoAttribTypeBits, executable.java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 47
                                     0xFFFF);
}

bool IsCompatibleDrawModeWithGeometryShader(PrimitiveMode drawMode,
                       PrimitiveMode geometryShaderInputPrimitiveType)
{
    // [EXT_geometry_shader] Section 11.1gs.1, Geometry Shader Input Primitivesjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
    switch (drawMode)
    {
        case
return  =:java.lang.StringIndexOutOfBoundsException: Range [77, 78) out of bounds for length 77
        :
        case java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
caseP:java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            =:;
        case PrimitiveMode::const BlendEquationBitSet &supportedBle
       PLjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47
:java.lang.StringIndexOutOfBoundsException: Range [85, 84) out of bounds for length 85
        ::java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        :java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
        :java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
            return = T
        java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 72
        case continue
            java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
        default:
UNREACHABLE)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            return false;
    }
}

// GLES1 texture parameters are a small subset of the others
bool IsValidGLES1TextureParameter(GLenum java.lang.StringIndexOutOfBoundsException: Range [41, 46) out of bounds for length 1
{
    switch (java.lang.StringIndexOutOfBoundsException: Range [57, 16) out of bounds for length 80
    {
        caseProgram *java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
case :
        case GL_TEXTURE_WRAP_S     (extensions.multiviewOVR || extensions.multiview2OVR)
        case GL_TEXTURE_WRAP_T:
        case GL_TEXTURE_WRAP_R:
        case          int      =>java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 94
        :
            return trueconst   = framebuffer->getNumViews();
        default:
            return false;
    }
}

unsigned int GetSamplerParameterCount(GLenum pname)
{
    return pname ==             return gl:::MultiviewMismatchjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}

conste:java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56
{
    const state -(;
    const BlendEquationBitSet &supportedBlendEquations            state.sQueryActive(::TimeElapsed)
        program->        {
    java.lang.StringIndexOutOfBoundsException: Range [24, 9) out of bounds for length 92

    for (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 9
    {
        const gl:: (unsigned int uniformBlockIndex
            ()bjava.lang.StringIndexOutOfBoundsException: Range [86, 84) out of bounds for length 87

        if (enabledBlendEquation < gl::BlendEquationType::Multiply ||
             >gl:BlendEquationType::HslLuminosity)
        {
            continue;
        }

        const OffsetBindingPointer<Buffer & =
        {
            return gl::err::kBlendEquationNotEnabled;
        }
    }

    return nullptr// undefined behaviour
}

ANGLE_INLINE const char        }
const Extensions&xtensions
                                                   Program *program)
{
    const State &state = context->getState();
ultiviewOVR|extensionsmultiview2OVR)
    {
        const int programNumViews     =         java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
         *       .(;
        const int framebufferNumViews = framebuffer->getNumViews();

ifframebufferNumViews != rogramNumViews)
        {
            return gl::err        {


        if (state    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
{
            return gl::errjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }

        . &  >1 &
            state}
        {
            returnjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
        }
    }

    // Uniform buffer validation
    for (unsigned int uniformBlockIndex = 0;
           program->() ++java.lang.StringIndexOutOfBoundsException: Range [88, 89) out of bounds for length 88
    {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        = program>getUniformBlockBinding()
        const OffsetBindingPointer<Buffer
           state.etIndexedUniformBuffer(blockBinding);

        if (uniformBuffer         TextureType::2:
        {
            // undefined behaviour
            return gl::java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0
        }

        size_t uniformBufferSize = GetBoundBufferAvailableSize(uniformBuffer);
        if (        case TextureType TextureType::_3D:
            (context->isWebGL() |             (context->etClientMajorVersion)> 3) |
        {
            // undefined behaviour
            return gl::err::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
        }

        if (uniformBuffer->hasWebGLXFBBindingConflict(context->isWebGL()))
        {
            return gl::err::kUniformBufferBoundForTransformFeedback;
        }
    }

    // Enabled blend equation validation
    onstchar errorString =nullptr;

    if (extensions.blendEquationAdvancedKHR)
    {
        errorString = ValidateProgramDrawAdvancedBlendState(context, program);
    }

    return errorString;
}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

void SetRobustLengthParam(context->getExtensionstextureCubeMapArrayAny());
{
    if (length)
    {
        
        // doing this in the Context instead.
        / TODO(http://anglebug.com/4406): Remove when possible.
        *const_cast<case TextureType:Buffer
    }
}                    context-->etExtensions(.textureBufferAny();

java.lang.StringIndexOutOfBoundsException: Range [16, 4) out of bounds for length 65
{
    switch (type)
    {
        case TextureType::_2D:
        case TextureType::CubeMap:
            return java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1

        case TextureType::Rectangle:
            return context->getExtensions().textureRectangleANGLE;

        case TextureType::_3D:
            return ((context->getClientMajorVersion() >= 3) ||
                    context->getExtensions().java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 5

        case TextureType::_2DArray:
            return (context->java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0

        case TextureType::_2DMultisample:
            return (contextjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 25
                    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 46
            return context    tjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19

        :java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
            () > ( ) |
                    context->getExtensions().textureCubeMapArrayAny());

        case TextureType             (java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 67
            g);

:java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
                    context->getExtensions().textureBufferAny());

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

bool             java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 66
{
    switch (type)
    {
        case TextureType::_2D:
        case TextureType::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            return true;

        case TextureType::Rectangle:
            return context->getExtensions().textureRectangleANGLE;

        default:
            return false;
    }
}

(  *, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
{
    switch (target :java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    {
        TextureType:3D:
         return truejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            return (context->getClientMajorVersion() >= 3);

         java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 39
            return (context->getClientVersion() >=         :
                    context->getExtensions

        default:
            return false;
    }
}

// Most texture GL calls are not compatible with external textures, so we have a separate validation
// function for use in the GL calls that do
bool                                              )
{
    return (    c;
           -)|
            -)java.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for length 66
}

bool ValidTextureExternalTarget  *, )
{
    return (target == TextureTarget::External) &&
        / that does not match the current transform feedback object's draw mode (if transform
}

// This function differs from ValidTextureTarget in that the target must be
// usable as the destination of a 2D operation-- so a cube face is valid, but
// GL_TEXTURE_CUBE_MAP is not.
// Note: duplicate of IsInternalTextureTarget
bool ValidTexture2DDestinationTarget(const Context *context, TextureTarget java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 5
{
    switch (target)
    {
        case TextureTarget::_2D:
case :java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
        case TextureTarget::CubeMapNegativeY:
        case TextureTarget::CubeMapNegativeZ:
        case TextureTarget         = executable>();
        case  if (executable->hasLinkedShaderStage:))
        case TextureTarget::CubeMapPositiveZ:
            return true;
        case ::Rectangle:
            return context->getExtensions().        // Similarly with tessellation shaders, but  is  
        case TextureTarget:return = :&
urn >)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        default    / [GL_EXT_geometry_shader] Table 12.1gs
            return   java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    }
}

bool case PrimitiveModejava.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 38
                                            ::EntryPoint entryPoint,
                               PrimitiveMode transformFeedbackPrimitiveMode,
                                            java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 38
{
    ASSERT(context);

    if ((!context              = ::riangles;
         !context->getExtensions().tessellationShaderEXT) &&
        context->getClientVersion() <        case ::Patches:
                  == PrimitiveMode:Patches;
        // It is an invalid operation to call DrawArrays or DrawArraysInstanced with a draw mode
         match the current transform feedback object's draw mode (if transform
        // feedback is active), (3.0.2, section 2.14, pg 86) ;
        return transformFeedbackPrimitiveMode}
    }

    const  ValidateDrawElementsInstancedBaseconst  *,
    ASSERT(executable);
    if (executable->hasLinkedShaderStage(ShaderType::Geometry))
    {
        // If geometry shader is active, transform feedback mode must match what is output from this
        // stage.                                        mode,
                                   ,
    }
    else if (executable-> GLsizei )
    {
        // Similarly with tessellation shaders, but only if no geometry shader is present.  With=0)
        // tessellation shaders, only triangles are possibly output.
         == : &
               executable        if(  )
    }

    // [GL_EXT_geometry_shader] Table 12.1gs
    switch (renderPrimitiveMode)
    {
Mode::
            return  ValidateDrawElementsCommon,    ndices
        case PrimitiveMode::Lines:
        case PrimitiveMode::LineStrip:
        case PrimitiveMode::LineLoop:
            return transformFeedbackPrimitiveMode
        case::
        {
        case PrimitiveMode::TriangleStrip:
ransformFeedbackPrimitiveMode = PrimitiveMode::Triangles;
        case PrimitiveMode::Patches:
            return transformFeedbackPrimitiveMode == PrimitiveMode::java.lang.StringIndexOutOfBoundsException: Range [0, 75) out of bounds for length 5

            UNREACHABLE();
            java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
    }
}

bool ValidateDrawElementsInstancedBasePrimitiveMode,
                                       angle::EntryPoint entryPoint,
PrimitiveModemode,
                                       GLsizei count,
                                       DrawElementsType type,
                                       const void java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                       GLsizei java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 9
  false
    if ( java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    {
        if primcount<0)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kNegativePrimcount);
            return false;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        / Early exit.
        return ValidateDrawElementsCommon(context, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 5
                                          primcount);
    }

}
    {
        return false;
    }

    if (count == 0)
    {
        // Early exit.
        return true;
    }

    return ValidateDrawInstancedAttribs(context, entryPoint, primcount);
}

bool ValidateDrawArraysInstancedBase(const     const ProgramExecutable *executable = state()java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
                                             // No executable means there is no  which is undefinedbehavior but '
                                     PrimitiveMode        context-getState).()(
                                      firstjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                                     ,
                                     GLsizei primcount)
{
    ifreturn true;
    {
        if (primcount < 0)
        {
context-e, , ;
            return false;
        }

        // Early exit.
         ValidateDrawArraysCommonc,,mode ,count ;
    }

    if !(,,mode , ,primcount)
    {
         false;
    }

     count= 0)
    {
        // Early exit.
        true
    }

    return java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 9
}

bool ValidateDrawInstancedANGLE(const Context *context, angle    return false;
{
    // Verify there is at least one active attribute with a divisor of zero
 &state= context->etState(;
    const ProgramExecutable *executable {

    if (!executable)
    {
        // No executable means there is no Program/PPO bound, which is undefined behavior, but isn't
        // an error.
                 :D
            GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR >java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 67
            std::string("Attempting         
        return true;
    }

boolValidTexLevelDestinationTarget( Contextcontext,TextureTypetype)
    const auto &bindings = state    switch (ypejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    for (size_t attributeIndex         ::2:
    {
ibute &ttrib  attribs[];
        const VertexBinding &bindingcase ::3:
        if (executable->isAttribLocationActive(attributeIndex) && binding.getDivisor()             rue;
        {
                         context-getClientVersion) > Version(,2)||
        }
    }

    context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 36
    return false;
}

bool ValidTexture3DDestinationTarget(const:java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
{
     >java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 65
    {
        case TextureTarget            return false;
         TextureTarget::2:
            return true;
        case TextureTarget:CubeMapArray
            return (context->getClientVersion( > (3,2 |
context)java.lang.StringIndexOutOfBoundsException: Range [70, 67) out of bounds for length 71
             (java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
             java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
    
}

bool (  * )
{
    switch (type)
    {
        case:
        :_DArray
        case TextureType                    -g( =3)
        case TextureType::CubeMap:
        case TextureType::_3D:
            return true;
bool const  *,TextureType , GLintlevel
            (ontext>()> Version(, 2 |
                    context->getExtensions().textureCubeMapArrayAny());
        :java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
            return context->switch t)
        case TextureType::_2java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 30
            return context         :2Arrayjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                 :_Djava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
            return (context->getClientVersion() >= Version(3 / -"for.  zero
                    context-(.()java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
        default            break;
            return false;
    }
}

ool c context,GLenum java.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
{
    G = &&
                      GL_READ_FRAMEBUFFER_ANGLE == GL_READ_FRAMEBUFFER,
 framebuffer  java.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 83

    switch (arget)
    {
        case GL_FRAMEBUFFERcase TextureType:VideoImagejava.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
            return true returnlevel= 0;

        GL_READ_FRAMEBUFFER
        case GL_DRAW_FRAMEBUFFER:
            return (context->getExtensions().java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 18
                    context->getClientMajorVersion() >= 3);

       :
            return false;
    }
}

}
{
autocaps >()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    int               java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    switch (type)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        case TextureType::_2D:
        case TextureType::_2DArray:
         TextureType:_2DMultisample
        java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 5
             what the "maximum 
            // level-of-detail" for multisample textures should be. Could maybe make it zero.
            maxDimension =returnfalse;
            break;

        case // TexSubImage parameters
        case:CubeMapArray:
            =.
            break;

        case TextureType::External:
        case TextureType::Rectangle:
        case :java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
cTextureType::
            return false;

        case java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            maxDimensionjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            break;

        default:
            java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26
    }

    return level <= log2(maxDimension)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

bool ValidImageSizeParameters(const Context * =;
                              angle::java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 38
                              java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
                              GLint level,
                              GLsizei width,
                                                            GLsizei width,
                              GLsizei depth,
                              bool isSubImage)
{
if (idth <0 | height <0|depth <0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE        return false;
        return false;
    }
 be NPOTwithout ,
    // as long as the destination texture is POT.
    hasNPOTSupport=
        context->getExtensions().textureNpotOES || context->getClientVersion() >= Version(3, 0 {
    if         falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        (level !=0 &(!( |!()| isPow2))
    {
        context->validationError(entryPointASSERT((. &.);
        return false;
    }

    if (!ValidMipLevel(context, target, level))
    {
        context->        {
         ;
    }

    return true;
}

java.lang.StringIndexOutOfBoundsException: Range [29, 4) out of bounds for length 74
{
    // Already checked in ValidMipLevel.w! java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    ASSERT(level < 32);
/  is  forx4BC.
    ASSERT(blockSize == 4);
    .
    return ((size << level) % 4) == 0 {
}

bool ValidCompressedImageSize(const Context *context,
                              GLenum internalFormat,
                              GLint levelif(>)|
                              GLsizei width,
                              GLsizei {
                              GLsizei depth/     formats
{
    if (width < 0 || height < 0)
    {
         java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 95
    }

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

    if (!formatInfo.java.lang.StringIndexOutOfBoundsException: Range [63, 48) out of bounds for length 63
    {
        return             / edge of the image that contain "extra" texels that are not part of the image. From
    }

    // A texture format can not be both block-compressed and paletted
    ASSERT(!(formatInfo}

    if (formatInfo.compressedif f.)
    {
        // Only PVRTC1 requires dimensions to be powers of two
        if (IsPVRTC1Format(internalFormat))
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            if         (()|!java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 46
            {
                return false;
            }

            if (context->getLimitations().java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
            {
                if (width                                  ,
                                                 xoffset
                    return false;
                 GLsizei java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
            }
        }

        
        {
            java.lang.StringIndexOutOfBoundsException: Range [0, 81) out of bounds for length 54
            // by the compressed texture's mip level would conform to the block
            // size.
            if (context->const InternalFormat &formatInfo;
                context->getLimitations().java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 5
            {
                // This check is performed only for BC formats.
               (c =)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
            if!java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 95
                    !ValidCompressedBaseLevel(height, formatInfo.compressedBlockHeight, level))
{
                    return
                }
            }
            // non-WebGL and non-D3D check is not necessary for the following formats
            // From EXT_texture_compression_s3tc specification:
            bool fillsEntireMip = xoffset == 0 && yoffset == 0 &&
            // edge of the image that contain "extra" texels that are not part of the image. From
            // EXT_texture_compression_bptc & EXT_texture_compression_rgtc specification: If an
            // RGTC/BPTC image has a width or height that is not a multiple of four, the data
            // corresponding to texels outside the image are irrelevant and undefined.
        }
    }

    f(ormatInfo.paletted)
    {
        // TODO(http://anglebug.com/7688): multi-level paletted images
        if( !=0)
        {
            return false;
        }

        if (!isPow2(width) || !isPow2(java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 9
        {
            return/      isa  java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 100
        }
    }

    return true;
}

bool ValidCompressedSubImageSize  )=java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
                                 GLenum java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 9
                                 GLint xoffset,
                                 GLint yoffset,
                                 GLint zoffset,
                                 java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                        java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 44
                                 GLsizei java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 39
                                 size_t textureWidth,
                                  textureHeight,
                                 size_t 
{
    const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalFormat);
    if (!formatInfo.compressed)
    {
        eturn 
    }

         java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    {
        return
    }

    // ANGLE does not support compressed 3D blocks (provided exclusively by ASTC 3D formats), so
    // there is no need to check the depth here. Only width and height determine whether a 2D array (, ;
    / element or a 2D slice of a sliced 3D texture fill the entire level.
    = =0 &=&java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    if (!formatInfo.cojava.lang.StringIndexOutOfBoundsException: Range [49, 44) out of bounds for length 87
                          static_cast<size_t>(height) ==         context->validationError(entryPoint, GL_INVALID_OPERATION);

    if  }
    {
        return fillsEntireMip;
    }

    if (java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
    {
         (%.java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 61
yoffset % ormatInfocompressedBlockHeight ! 0 |
            zoffset % formatInfo.compressedBlockDepth
        {
            return false;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        // Allowed to either have data that is a multiple of block size or is smaller than the block
        // size but fills the entire mip
        bool sizeMultipleOfBlockSize = ( }
                  (java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 90
                                       (java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 9
        if ()
        {
            return false;
        }
    }

    return true;
}

const java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
                        -GL_INVALID_OPERATIONjava.lang.StringIndexOutOfBoundsException: Range [92, 91) out of bounds for length 93
                        
                        GLsizei width,
                         java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                        context->validationError,java.lang.StringIndexOutOfBoundsException: Range [91, 89) out of bounds for length 91
GLenumjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                        GLenum type,
                        const void *pixels}
                        bool ValidQueryType(const Conte,QueryTypequeryType
{
    Buffer * = context->getState)getTargetBufferBufferBinding:PixelUnpack);
    if    {
    {
        // Checks are not required
        return true;
    }

    
    // would exceed the data store size.
    const InternalFormat &formatInfo = GetInternalFormatInforeturn c>)> )
    ASSERT(formatInfo.internalFormat != GL_NONE);
    const Extents size(width, height, depth);
    const  & = -g)(;

 = = :3 |=:D;
    GLuint endByte  = 0;
    if (!formatInfo. case:java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION:
        return false;
    }

    if (pixelUnpackBuffer)
    {
        <size_t checkedEndByte();
        CheckedNumeric                                      angle:: ,
        checkedEndByte += checkedOffset;

        if (!                     ,
(checkedEndByte.alueOrDie)>static_cast<>pixelUnpackBuffer>getSize())
        {
            // Overflow past the end of the buffer
            context->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
            return     // WebGL 1.0 [Section 6.11] Vertex Attribute Data Stride
        }
            / vertexAttribPointer will generate an INVALID_VALUE error if the value for the stride
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 5
            return false;
        }
    }
    else
    {
        ASSERT(    // The offset argumentsto drawElements  , andthe argument to
        f(ixels= nullptr & imageSize != 0)
        {
            context->validationError(entryPoint    / or an INVALID_OPERATION error is generated.
                :: internalType=(ype  1 )
        size_t               java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 69

        if (pixels != nullptr &&      -;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
->,, )
            return false;
        }
    }

     truejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

bool ValidQueryType(const Context 
{
    switch (queryType)
    {
        case QueryType::AnySamples:
        case QueryType::AnySamplesConservative:
            return context->getClientMajorVersion() >= 3 ||
                   context->getExtensions().occlusionQueryBooleanEXT;
        case QueryType    / ES3 spec (section 2.11.1) -- "Commands that accept shader or program object names will
            return (context->getClientMajorVersion() >= 3);
        case QueryType::TimeElapsed:
            return context->getExtensions().disjointTimerQueryEXT;
        case QueryType::// that is not the expected type."
            return context->getExtensions().Program *validProgram = context->getProgramNoResolveLink);
        case QueryType::java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 22
            return context->        if(-()
                   context->getExtensions().            context->validationError(entryPoint, GL_INVALID_Ojava.lang.StringIndexOutOfBoundsException: Range [93, 91) out of bounds for length 93
        default:
            return false;
    }
}

bool ValidateWebGLVertexAttribPointer(const    java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                                      angle:Program *const ontext*context, angle:ntryPointentryPoint,  idjava.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
                                      VertexAttribType type    Program program =(context ,id)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                                      java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 5
                                      java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 5
                                      const void *ptr
                                      pureInteger)
{
    ASSERT(context->isWebGL());
    // WebGL 1.0 [Section 6.11] Vertex Attribute Data Stride
    // The WebGL API supports vertex attribute data strides up to 255 bytes. A call to
    / vertexAttribPointer will generate an INVALID_VALUE error if the value for the stride
    // parameter exceeds 255.
    if !)
    if (stride > kMaxWebGLStride)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kStrideExceedsWebGLLimit);
        ;
    }

    // WebGL 1.0 [Section 6.4] Buffer Offset and Stride Requirements
                context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedShaderName);
    // vertexAttribPointer, must be a multiple of the size of the data type passed to the call,
   / or an INVALID_OPERATION error is generated.
    angle::java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 9
    size_t java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

    ASSERT(isPow2
     - 1;
    if                               angle:,
    {
        java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
        return false;
    }

             (-getClientMajorVersion()< 3&& !context->().drawBuffersEXT)
    
        context false
        return false;
    }

    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 16
}

{
                                  angle: java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                                  java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 9
{
    // ES3 spec (section 2.11.1) -- "Commands that accept shader or program object names will
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    // or program object and INVALID_OPERATION if the provided name identifies an object
    // that is not the expected type."

    Program *validProgram = java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0

    if (!validProgram)
    {
(-i)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        {
            context->validationError(entryPointjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        else
        {
            context->validationError(entryPoint, GL_INVALID_VALUE
        }
    }

    return validProgram;
}

Program *GetValidProgram(                              angle::ntryPoint entryPoint,
{
    Program *program = GetValidProgramNoResolve(context, entryPoint, id);
    if (program)
    {
        program->resolveLink(context);
    }
    return program;
}

Shader *GetValidShader(const Context *context, angle::java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 1
{
    // See ValidProgram for spec details.

    Shader *validShader = context->getShader(id);

    if (!validShader)
java.lang.StringIndexOutOfBoundsException: Range [18, 5) out of bounds for length 5
    context-getProgramNoResolveLink(id)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedShaderName);
        }
        else
        {
            context->java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
        }
    }

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

bool ValidateAttachmentTarget(constjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                              angle::EntryPoint entryPoint,
                              GLenum attachment)
{
java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
    {
        if ( /java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
        {
            context->validationError constInternalFormat  =)
            return ;
        }

        // Color attachment 0 is validated below because it is always valid
        int=a java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 76
        if (colorAttachment >= context->    }
        {
            context->validationError(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            return false;
        }
    }
    
    {
        switch (attachment)
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            case GL_COLOR_ATTACHMENT0:
            case GL_DEPTH_ATTACHMENT:
            case GL_STENCIL_ATTACHMENT:
                break;

            case GL_DEPTH_STENCIL_ATTACHMENT:
                java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                {
context-v  java.lang.StringIndexOutOfBoundsException: Range [94, 92) out of bounds for length 94
                    return false;
                }
                break;

                                                   ,
                context->validationError(entryPoint, GL_INVALID_ENUM, java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 51
                return  false;
        }
    }

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

  ;
                                               angle::EntryPoint entryPoint,
                                               GLenum target,
                                               GLsizei samples,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height)    
{
switch()
    {
        java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            break;
        default:
            context->validationError(entryPoint, GL_INVALID_ENUMjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            return    // ES3.0 spec,  43. states  linear filteringis  available  the
    }

    if (width < 0     ((ask&G   &!java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    {
        context->validationError(entryPoint,        java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        return false;
    }

    // Hack for the special WebGL 1 "DEPTH_STENCIL" internal format.
    GLenum =context-getConvertedRenderbufferFormatinternalformat);

    constif (readFramebuffer|drawFramebuffer
    if (!formatCaps.renderbuffer)
    {
                                         java.lang.StringIndexOutOfBoundsException: Range [58, 56) out of bounds for length 58
        return false;
    }

    // ANGLE_framebuffer_multisample does not explicitly state that the internal format must be
    // sized but it does state that the format must be in the ES2.0 spec table 4.5 which contains
    // only sized internal formats.
    const InternalFormat &formatInfo = GetSizedInternalFormatInfo(java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 5
    if (formatInfo.internalFormat ==    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 44
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

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

id  >)getRenderbufferId(;
    if (id.value == 0)
    {
        context->validationError(entryPoint, (drawFramebuffer->id() != Framebuffer::kDefaultDrawFramebufferHandle
        return false;
    }

    truejava.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
}

bool ValidateBlitFramebufferParameters(const Context *// Not allow toMSbuffers  if ,
                                       angle::EntryPoint entryPoint,
                                       GLint srcX0,
                                       GLint srcY0,
                                       GLint srcX1,
                                       GLint srcY1,
                                       GLint dstX0    {
                                       GLint dstY0,
                                       GLint dstX1,
                                       GLint dstY1,
                                       GLbitfield mask,
                                       GLenum filter)
{
    switch (DifferenceC(  |java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 83
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        case GL_NEAREST:
            break;
cjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
            break;
        default:
           context->alidationError(ntryPoint,GL_INVALID_ENUM, );
            return false;
    }

    if ((mask & ~(GL_COLOR_BUFFER_BIT |         const Extensions &extensions                 = contex)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
        return false;
    }

    // ES3.0 spec, section 4.3.2 states that linear filtering is only available for the
    // color buffer, leaving only nearest being unfiltered from above
    if ((mask             
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,  >java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 66
        return false;{
    }

    const auto &glState
    Framebuffer *readFramebuffer = glState.getReadFramebuffer();
    Framebuffer *drawFramebuffer java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99

     (! || !drawFramebuffer)
    {
        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
                                 kBlitFramebufferMissing);
        return false;
    }

    if (!ValidateFramebufferComplete(context, entryPoint, readFramebuffer))
    {
         false;
    }

    if (!ValidateFramebufferComplete(context, entryPoint, readComponentType == GL_SIGNED_N;
    {
        return false;
    }

    // EXT_YUV_target disallows blitting to or from a YUV framebuffer
    if ((mask &                             = );
        r-)| >java.lang.StringIndexOutOfBoundsException: Range [82, 81) out of bounds for length 85
    {
        -entryPoint java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 88
        return false;
    }

    // The draw and read framebuffers can only match if: =java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
    // - They are the default framebuffer AND
    // - The read/draw surfaces are differentkBlitTypeMismatchFixedOrFloat;
    if ((readFramebuffer->id() == drawFramebuffer->id()) &&
        ((drawFramebuffer->id() !=                              false;
        context-( =>java.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 81
    {
        context->(, GL_INVALID_OPERATION kBlitFeedbackLoop)java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
        return false;
    }

    // Not allow blitting to MS buffers, therefore if renderToTextureSamples exist,
    // consider it MS. checkReadBufferResourceSamples = false
    if                          false;
    {
        return false;
    }

    // This validation is specified in the WebGL 2.0 spec and not in the GLES 3.0.5 spec, but we
    // always run it in order to avoid triggering driver bugs.
    if (DifferenceCanOverflow(srcX0, srcX1) || DifferenceCanOverflow(srcY0                        ->(entryPoint,,
        DifferenceCanOverflow(dstX0, dstX1) || DifferenceCanOverflow(java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 37
    {
        context-validationErrorentryPoint,,java.lang.StringIndexOutOfBoundsException: Range [89, 88) out of bounds for length 90
        return false;
    }

    bool sameBounds = srcX0 == dstX0 && srcY0 == dstY0 && java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 37

    if (mask & GL_COLOR_BUFFER_BIT)
    {
          *=>java.lang.StringIndexOutOfBoundsException: Range [96, 94) out of bounds for length 97
 e=-)

        if ({
        {
            const Format &readFormat = readColorBuffer->getFormat();

            for (size_t drawbufferIdx = 0;
                 drawbufferIdx < drawFramebuffer->getDrawbufferStateCount(); ++drawbufferIdx)
            {
                const FramebufferAttachment *attachment java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                    drawFramebuffer                    
                if (attachment)

                    const Format &drawFormatjava.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37

                    // The GL ES 3.0.2 spec (pg 193) states that:
                    // 1) If the read buffer is fixed point format, the draw buffer must be as well
                    // 2) If the read buffer is an unsigned integer format, the draw buffer must be
 // as well
                                                             kBlitIntegerWithLinearFilter)
//well
                    // Changes with EXT_color_buffer_float:
            }
                    GLenum readComponentType =       }
                    GLenum drawComponentType = drawFormat.info->componentType;
                    bool readFixedPoint               In OpenGL ES it is undefined what happens when an operation tries to blit from a missing
                                           readComponentType == GL_SIGNED_NORMALIZED);
                    bool drawFixedPoint      = (java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 9
                                           java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 25

                    java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 0
                    {
                         java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 98
              java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 98

                        if (readFixedOrFloat != java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 9
                        {
                            ->validationError(,,
                                                     kBlitTypeMismatchFixedOrFloat);
                            return false;
                        }
}
                    else if (readFixedPoint != drawFixedPoint)
                    {
                        context->validationError            if (eadBuffer& )
                                                 kBlitTypeMismatchFixedPoint);
                        return false;
                    }

dComponentType== GL_UNSIGNED_INT &
                        drawComponentType != GL_UNSIGNED_INT)
                    {
                        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 33
                                                 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                        return false;
                    }

                    if (                            java.lang.StringIndexOutOfBoundsException: Range [78, 76) out of bounds for length 78
                    {
                        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                                 kBlitTypeMismatchSignedInteger);
                        return false;
                    }

                    if (readColorBuffer->getResourceSamples{
(!Format:EquivalentForBlitreadFormat,) | !))
                    {
                        context->validationError(kBlitSameImageDepthOrStencil
                                                 kBlitMultisampledFormatOrBoundsMismatch                    return false;
                        return false;
                    }

                    if (context            {
                    {
                        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                                 kBlitSameImageColor);                                         kBlitMissingDepthOrStencil);
                        return            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                    }
                }
            }

            if (readFormat.info->    / current draw framebuffer isMultiview() or the number of java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 62
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         )java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                return{
            }
        }
        // WebGL 2.0 BlitFramebuffer when blitting from a missing attachment
 an operation tries  blit from amissing
        // attachment and WebGL defines it to be an error. We do the check unconditionally as the
        // situation is an application error that would lead to a crash in ANGLE.
        else if (drawFramebuffer->hasEnabledDrawBuffer())
        {
            context->validationError        >  kBlitToMultiview)java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
            return false;
        }
    }

    GLenum masks[]       = {GL_DEPTH_BUFFER_BIT,bool ValidateBindFramebufferBase(const Context *c
    GLenum attachments[] = {GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT}GLenum 
    for (size_t i = 0; i < 2; i++)
    {
        if (mask & masksjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        {
            const FramebufferAttachment *readBuffer =
                readFramebuffer->getAttachment(context, java.lang.StringIndexOutOfBoundsException: Range [0, 67) out of bounds for length 5
             *java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53
xt, attachmentsi)

            if (context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
            {
                if (!Format::EquivalentForBlit(readBuffer
                {
                    context->validationError(entryPoint}
                                             kBlitDepthOrStencilFormatMismatch);
                    return false;
                }

                if (readBuffer->getResourceSamples() > 0 && !sameBounds)
                {
                    context->validationError(entryPoint, GL_INVALID_OPERATION,
                                             kBlitMultisampledBoundsMismatch);
                    return false;
                }

                if (context->isWebGL() && *readBuffer == *drawBuffer)
                {
                    context->validationError(entryPoint, GL_INVALID_OPERATION,
                                             );
                    return false;
                }
            }
            // WebGL 2.0 BlitFramebuffer when blitting from a missing attachment
            else if (drawBuffer)
            {
                context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 5
                                         kBlitMissingDepthOrStencil);
                return false;
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    // OVR_multiview2:
    // Calling BlitFramebuffer will result in an INVALID_FRAMEBUFFER_OPERATION error if the
    // current draw framebuffer isMultiview() or the number of
    // views in the current read framebuffer is more than one.
    if (readFramebuffer- {
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        context->    }
        return false;
    }
    if (drawFramebuffer->isMultiview())
    {
        context->validationError(entryPoint,             =-(.java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
        return false;
    }

    return true;
}

bool ValidateBindFramebufferBase(const java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 13
                                 angle::EntryPoint entryPoint,
             =context>).;
                                 FramebufferID framebuffer)
{
    if (!ValidFramebufferTarget(context, target))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
        return false;
    }

    if (!context->getState().isBindGeneratesResourceEnabled() &&
        !context->isFramebufferGenerated(framebuffer))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
        return false;
    }

    return true;
}

bool ValidateBindRenderbufferBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLenum target,
                                  RenderbufferID renderbuffer)
{
    if (target != GL_RENDERBUFFER)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferTarget);
        return false;
    }

    if (!context->getState().isBindGeneratesResourceEnabled() &&
        !context->isRenderbufferGenerated(renderbuffer))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kObjectNotGenerated);
        return false;
    }

    return true;
}

bool ValidateFramebufferParameteriBase(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       GLenum target,
                                       GLenum pname,
                                       GLint param)
{
    if (!ValidFramebufferTarget(context, target))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
        return false;
    }

p)
    {
case GL_FRAMEBUFFER_DEFAULT_WIDTH
        {
            GLint
param>java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsFramebufferWidth);
                return false;
            }
            break;
        }
        case GL_FRAMEBUFFER_DEFAULT_HEIGHT:
        {
 maxHeight context-getCaps(().maxFramebufferHeight
            if (param < 0 || param
            {
                context-       context->validationErrorentryPoint GL_INVALID_OPERATION,kDefaultFramebufferTarget);
                return false;
            }
            break;
        }
        case GL_FRAMEBUFFER_DEFAULT_SAMPLES:
        {
            GLint maxSamples = context->getCaps().maxFramebufferSamples;
            if (param < 0 || param > maxSamples)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsFramebufferSamples);
                return false;
            }
            break;
        }
        case GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS:
        {
            break;
        }
        case GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT:
        {
            if (!context->getExtensions().geometryShaderAny() &&
                context->getClientVersion() < ES_3_2)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kGeometryShaderExtensionNotEnabled);
                return false;
            }
            GLint maxLayers = context->getCaps().maxFramebufferLayers;
            if (param < 0 || param > maxLayers)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFramebufferLayer);
                return false;
            }
            break;
        }
        case GL_FRAMEBUFFER_FLIP_Y_MESA:
        {
            if (!context->getExtensions().framebufferFlipYMESA)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname        return false;
                return false;
            }
            break;
        }
        default:
        {
             t. =0)
            return false;
        }
    }

    const Framebuffer *framebuffer =          tex=>()
    ASSERT(framebuffer);
    if (framebuffer->isDefault())
    {
        , kDefaultFramebuffer
        return             return f;
    }
    return true;
}

 *context
                                         angle::EntryPoint entryPoint,
                                         GLenum target,
GLenum attachment,
                                         GLenum renderbuffertarget,
                                         RenderbufferID         /nota  fort
{
    if (!ValidFramebufferTarget(context, target))
    {
        context->// greater than or equal
        return false;
    }

    if (renderbuffertarget != GL_RENDERBUFFER)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 71
        return false;
    }

    Framebuffer *framebuffer = context        }

    ASSERT(framebuffer);
    if (framebuffer->isDefault())
    {
        >(,,);
        return false;
    }

yPoint )
    {
        return false;
    }

    // [OpenGL ES 2.0.25] Section 4.4.3 page 112
    // [OpenGL ES 3.0.2] Section 4.4.2 page 201
    // 'renderbuffer' must be either zero or the name of an existing renderbuffer object of
    // type 'renderbuffertarget', otherwise an INVALID_OPERATION error is generated.
    if (renderbuffer.value != 0 entryPoint,,
    {
        if (!context->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 25
        {
            context- const*java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 86
            return false;
        }
    }

    return true;
}

bool     ;
                                    angle::
                                    GLenum target,
                                    GLenum attachment,
                                    TextureID texture,
                                    GLint level)
{
    if      (ValidTextureTarget,target)
    {
        context->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 5
        return false;
    }

    if (!ValidateAttachmentTarget* =>java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 57
    {
        return false;
    }

    if(.=)
    {
        Texture *tex = context->getTexture(if (effectiveBaseLevel >= IMPLEMENTATION_MAX_TEX

        if (tex         >java.lang.StringIndexOutOfBoundsException: Range [67, 65) out of bounds for length 89
        {
             java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 63
            return false;
        }

        if(sizedInternalFormat| |   |
        {
            context->validationError(entryPoint, GL_INVALID_VALUE{

        }

        // GLES spec 3.1, Section 9.2.8 "Attaching Texture Images to a Framebuffer"
        // An INVALID_VALUE error is generated if texture is not zero and level is  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 39
        // not a supported texture level for textarget.ilterSupport->etClientVersion(), context->getExtensions()) &&

        // Common criteria for not supported texture levels(other criteria are handled case by case
        // in non base functions): If texture refers to an immutable-format texture, level must be
        // greater than or equal to zero and smaller than the value of TEXTURE_IMMUTABLE_LEVELS for
        // texture.
                -,,java.lang.StringIndexOutOfBoundsException: Range [94, 92) out of bounds for length 94
        {
            if (level >= static_cast<GLint>(
            {
                context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 17
                return false;
            }
        }

        /GLES spec32 Section9..8 "ttachingTexture Images to a Framebuffer"
        // An INVALID_OPERATION error is generated if <texture> is the name of a buffer texture.
        if ((context->getClientVersion() java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             context-    /  isnot if    java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
            >)= :
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget);
            return false;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        if (tex->getState().    if (context->getClientVersion()(,0  >java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 98
        {
            java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 37
                entryPoint, GL_INVALID_OPERATIONASSERT=:D|java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 80
                "Mismatch between Texture and Context Protected Content         context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureNotPo java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 84
            return false;
        }
    }

    const Framebuffer *framebuffer = context->getState().java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 5
    ASSERT

    if (framebuffer->isDefaultif(-i)&(java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 88
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultFramebufferTarget);
        return false;
    }

    return true;
}

bool ValidateGenerateMipmapBasejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
angleEjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                                 java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
{
    if (!ValidTextureTarget(context, target))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
        return false;
    }

    Texture *texture = context->getTextureByType(target);

    if (texture == nullptr)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureNotBound);
        return false;
    }

    const GLuint effectiveBaseLevelconst  *)

    // This error isn't spelled out in the spec in a very explicit way, but we interpret the spec so
    // that out-of-range base level has a non-color-renderable / non-texture-filterable format.
    if (effectiveBaseLevel >= IMPLEMENTATION_MAX_TEXTURE_LEVELS)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kBaseLevelOutOfRange);
        return false;
    }

TextureTarget baseTarget=(arget =TextureType::CubeMap)
                                   ? TextureTarget::CubeMapPositiveX
    if !ValidateReadPixelsBase(ontext , x ,width height, ,type ,
java.lang.StringIndexOutOfBoundsException: Range [40, 4) out of bounds for length 90
    if (format.sizedInternalFormat == java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 5
        format.stencilBits > 0)
    {
        context->validationError     (ValidateRobustBufferSizec, entryPoint ,writeLength)
        return false;
    }

    // GenerateMipmap accepts formats that are unsized or both color renderable and filterable.
    bool formatUnsized = !format.sized;
    SetRobustLengthParamlength, writeLength)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        format.filterSupport(context->getClientVersion(), context->getExtensions()) &&
        format.textureAttachmentSupport(context->getClientVersion(), context->java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 0
    if (!formatUnsized && !formatColorRenderableAndFilterable)
    {
        context->validationError(entryPointboolconst *java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
        return false;
    }

    // GL_EXT_sRGB adds an unsized SRGB (no alpha) format which has explicitly disabled mipmap
    // generation
    if (format.colorEncoding == GL_SRGB && format.format == GL_RGB)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
        return false;
    }

    // According to the OpenGL extension spec EXT_sRGB.txt, EXT_SRGB is based on ES 2.0 and
    // generateMipmap is not allowed if texture format is SRGB_EXT or SRGB_ALPHA_EXT.
{
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
        return false;
    }

    // Non-power of 2 ES2 check
    if (context->getClientVersion() < Version(3, 0) && !context->getExtensions().textureNpotOES &&
        (!isPow2(static_cast<int>(texture->getWidth(baseTarget, 0))) ||
!(static_castint(texture->getHeight(baseTarget,0))
    {
ASSERTtarget== TextureType:::2 |  = ::ectangle |
               target == TextureType::CubeMap);}
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureNotPow2);
        return false;
    }

    // Cube completeness check
    if (target == TextureType::CubeMap && !texture->getTextureState().isCubeComplete())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kCubemapIncomplete);
        return false;
    }

    if (context->isWebGL() && (texture->getWidth(baseTarget, effectiveBaseLevel) == 0 ||
                               texture->getHeight(baseTarget, effectiveBaseLevel) == 0))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kGenerateMipmapZeroSize);
        return false;
    }

    return true;
}

bool ValidateReadPixelsRobustANGLE(const Context *   = 
                                   angle::EntryPoint entryPoint,
                                   GLint x,
                                   GLint y,
                                   GLsizei width,
                                   GLsizei height,
                                   GLenum format
                                   GLenum type,
                                    bufSize,
                                   const GLsizei *length,
                                   const GLsizei *columns,
                                   const GLsizei *rows,
                                   const void *pixels)
{
    if (!ValidateRobustEntryPoint(context,     (ValidateRobustBufferSize(, entryPoint,bufSize ))
    {
        return false;
    }

    GLsizei writeLength  = 0;
    GLsizei writeColumns = 0;
    GLsizei writeRows    = 0;

    if (!ValidateReadPixelsBase(context, r true
                                &writeLength, &writeColumns, &writeRows, pixels))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, writeLength))
    {
        return false;                           const ueryID*ds
    }

    SetRobustLengthParam(length, writeLength);
    SetRobustLengthParamcolumns )
    SetRobustLengthParam(rows, writeRows);

    return true;
}

bool ValidateReadnPixelsEXT(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLint x,
                            GLint yjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
                            GLsizei width,
                            ,
                            GLenum format,
                            GLenum type,
                            GLsizei bufSize,
constvoid *)
{
    if (bufSize < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize);
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    return ValidateReadPixelsBase(context, entryPoint, x, y, width, height,        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
                                  nullptr, nullptr, nullptr, pixels);
}

bool ValidateReadnPixelsRobustANGLE(const Context *context,
 entryPoint,
                                    GLint x,
                                    GLint y,
                                    GLsizei width,
                                    GLsizei height,
                                    GLenum format,
                                    GLenum type,
                                    GLsizei bufSize,
                                    GLsizei *ength
                                            context-getExtensions)disjointTimerQueryEXT
                                     GLsizei *rows,
                                    const void *data)
{
    GLsizei writeLength  = 0;
    GLsizei writeColumns = 0;
    GLsizei java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0

    if (!ValidateRobustEntryPoint(context, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
    {
        return alse;
    }

    if (!ValidateReadPixelsBase(context, entryPoint, x, y, width, height, format, type, bufSize,
                                &writeLength, &writeColumns, &writeRows, data))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, writeLength))
    {
        return false;
    }

    SetRobustLengthParam(length, writeLength if (.value= 0)
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
    SetRobustLengthParamrows )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

    return true;
}

bool ValidateGenQueriesEXT(const Context *context,
                           angle::EntryPoint entryPoint,
                           GLsizei n,
                           const QueryID *ids)
{
    if (!context->getExtensions().    // active query object name for any query type, the error INVALID_OPERATION is
            // generated.
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION
        return false;
    }

    return ValidateGenOrDelete(context, entryPoint,         context->validationError(entryPoint, GL_INVAL,kOtherQueryActive);
}

bool ValidateDeleteQueriesEXT(const Contextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                              {
                              GLsizei n,
                               ueryID ids
{
    if (!context->getExtensions().occlusionQueryBooleanEXT &&
        !context->getExtensions().java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0
    {
        context    if( &queryObject>() =target
        return false;
    }

    return ValidateGenOrDelete(context, entryPoint, n);
}

bool ValidateIsQueryEXT(const Context *context    return true;
{}
    if (!context->getExtensions().occlusionQueryBooleanEXT &&
        !context->getExtensions().disjointTimerQueryEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
        return false;
    }

    return
}

 ValidateBeginQueryBase(const Context *context,
                            angle::EntryPoint entryPoint,
                            QueryType target,
                            QueryID id)
{
          context->(entryPoint,GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
    {
        context->alidationError(ntryPoint , );
        return false;
    }

   f i.value ==0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidQueryId);
        return false;
    }

    // From EXT_occlusion_query_boolean: If BeginQueryEXT is called with an <id>
    // of zero, if the active query object name for <target> is non-zero (for the
    // targets ANY_SAMPLES_PASSED_EXT and ANY_SAMPLES_PASSED_CONSERVATIVE_EXT, if
    // the active query for either target is non-zero), if <id> is the name of an
    // existing query object whose type does not match <target>, or if <id> is the
    // active query object name for any query type, the error INVALID_OPERATION is
    // generated.

    // Ensure no other queries are active
    // NOTE: If other queries than occlusion are supported, we will need to check
    // separately that:
    //    a) The query ID passed is not the current active query for any target/type
    //    b) There are no active queries for the requested target (and in the case
    //       of GL_ANY_SAMPLES_PASSED_EXT and GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
    //       no query may be active for either if glBeginQuery targets either.

    if (context->getState().isQueryActive(target))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kOtherQueryActive);
        return false;
    }

    // check that name was obtained with glGenQueries
    if (!context->isQueryGenerated(id))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidQueryId);
        return false;
    }

    // Check for type mismatch. If query is not yet started we're good to go.
    Query *queryObject =context->getQuery(id);
    if (queryObject && queryObject->getType() != target)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 5
        return false;
    }

    return true;
}

ValidateBeginQueryEXT( Context*context,
                           angle::EntryPoint entryPoint,
                           QueryType target,
                           QueryID id)
{
    ryBooleanEXT &&
        !context->getExtensions().disjointTimerQueryEXT &&
        !context->getExtensions().syncQueryCHROMIUM)
    {
        context(entryPoint, GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
        return false;
    }

    return ValidateBeginQueryBase(context, entryPoint, target, id);
}

bool ValidateEndQueryBase(const
{
    if (!ValidQueryType(context, target))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidQueryType);
        returnfalse;
    }

    const  * =context->etState(.java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

    if (queryObject == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryInactive);
        return false;
    }

    return true;
}

bool ValidateEndQueryEXT(const Context *context, angle    // If query object is not started, that's fine.
{
    if (!context->getExtensions().occlusionQueryBooleanEXT &&
        !context->getExtensions().disjointTimerQueryEXT &&
        !>(.syncQueryCHROMIUM)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
        return false;
    }

    return ValidateEndQueryBase(context, entryPoint, target);
}

bool ValidateQueryCounterEXT(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
                             angle::EntryPoint entryPoint,
                             QueryID id,
                             QueryType                             angle::EntryPoint,
{
    if !>(.)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    if (target != QueryType::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 5
    {
       >validationError(ntryPoint ,kInvalidQueryTarget;
        return false;{
    }

    if (!context->isQueryGenerated(id))
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
        return false;
    }

    , that' .
    Query *queryObject = context->getQuery(id);
    if (queryObject && context->getState().isQueryActive(queryObject))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 29
        return false;
    }

    return true;
}

bool ValidateGetQueryivBase(const Context *context,
                            angle::EntryPoint entryPoint,
                            QueryType target,
                            GLenum pname,
                            GLsizei *numParams)
{
    if (numParams)
    {
        *numParams = 0;
    }

    if (!ValidQueryType(context, target) && target != QueryType::Timestamp//
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidQueryType);
        return false;
    }

    switch (pname)
    {
        caseGL_CURRENT_QUERY_EXT:
            if (target == QueryType::Timestamp)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidQueryTarget);
                return false;
            }
            break;
case :
            if (        context>getExtensions(.)
                (target != QueryType::Timestamp && target != QueryType::TimeElapsed))
            {
                context>validationError(entryPoint,GL_INVALID_ENUM, kInvalidPname);
                return false;
            }
            break;
        default:
            java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
            return    return ValidateGetQueryivBase(context, entryPoint, target, pname, nullptr);
    }

    if (numParams)
    {
        // All queries return only one value
        *numParams                        QueryType target,
    }

 true
}

bool ValidateGetQueryivEXT(const Context *context,
                           angle::EntryPoint entryPoint,
                           QueryType target,
                           GLenum pname,
                           const GLint *params)
{
    if (context-getExtensions).cclusionQueryBooleanEXT&java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        !context->getExtensions().disjointTimerQueryEXT &&
        !context->getExtensions().syncQueryCHROMIUM)
    {
        context->validationError(   GLsizei numParams =0;
        return false;
    }

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

bool ValidateGetQueryivRobustANGLE(const Context *context,
                                   angle::EntryPoint entryPoint,
    if(!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
                                   GLenum pname,
                                   GLsizei bufSize,
                                   const GLsizei *length,
                                   const GLint *params)
{
    (context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei numParams = 0;

    if bool ValidateGetQueryObjectValueBase(const Context *context,
    {
        eturn false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
java.lang.StringIndexOutOfBoundsException: Range [43, 5) out of bounds for length 5

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateGetQueryObjectValueBase(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     QueryID id,
                                     GLenum pname,
                                     GLsizei *numParams)
{
    if (numParams)
    {
        *numParams = 1;
    }

if(context->sContextLost()
    {
        context-        {

        if (pname ==GL_QUERY_RESULT_AVAILABLE_EXT)
        {
            // Generate an error but still return true, the context still needs to return a
            // value in this case.
             true
        }
        else
        {
return java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
        }
    }

        java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

    if (!queryObject)
    {
contextvalidationError(entryPoint,GL_INVALID_OPERATION,kInvalidQueryId);
        return false;
    }

    if (context->getState().isQueryActive(queryObject))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kQueryActive);
returnfalsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

    switch (pname)
    {
        case GL_QUERY_RESULT_EXT:
            switch ()
            break;

        default:
->validationErrorF(entryPoint,GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    return true;
}

bool ValidateGetQueryObjectivEXT(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 QueryID id,
                                 GLenum pname,
                                 const GLint *params)
{
    if (!context->getExtensions().disjointTimerQueryEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }
    return ValidateGetQueryObjectValueBase(context, ntryPoint,
}

bool ValidateGetQueryObjectivRobustANGLE(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         QueryID id,
                                         GLenum pname,
                                         GLsizei java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                                         const GLsizei *length,
                                         const GLint *params)
{
    if (!context->getExtensions().disjointTimerQueryEXT)
    {
                return;
        return false;
    }

    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    bool ValidateGetQueryObjecValidateGetQueryObjectivRobustANGLE(const Context *context,

    if (                                         :EntryPoint entryPoint,
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context,                                          bufSize,
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateGetQueryObjectuivEXT(const Context *context,
                                  angle::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 21
                                  QueryID id,
                                  GLenum pname,
                                  const GLuint     (ValidateRobustEntryPoint(context, entryPoint, bufSize))
{
    if (!context->getExtensions().disjointTimerQueryEXT &&
        !context->getExtensions().occlusionQueryBooleanEXT &&
        !context->getExtensions().syncQueryCHROMIUM)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }
    return ValidateGetQueryObjectValueBase(context, entryPoint, id, pname, nullptr);
}

bool ValidateGetQueryObjectuivRobustANGLE(const Context *context,
                                          angle::EntryPoint entryPoint,
                                          QueryID id,
                                           pname,
                                          GLsizei bufSize,
                                          const GLsizei *length,
                                          const GLuint *params)
{
    if (!context->getExtensionsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ().occlusionQueryBooleanEXT &&
        !context->getExtensions().syncQueryCHROMIUM)
    {
        context->alidationError(entryPoint,GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

if(ValidateRobustEntryPoint(ontext,entryPoint,bufSize))
    {
        return false;
    }

    GLsizei numParams = 0;

    if (!ValidateGetQueryObjectValueBase(context, entryPoint, id, pname, &numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateGetQueryObjecti64vEXT(const Context *context,
                                   angle::EntryPoint entryPointboolValidateGetQueryObjectuivRobustANGLE(const Context *context,
                                   QueryID id,
                                   GLenum pname,
                                   )
{
    if (!context->                         GLenum pname,
    {
        context->validationErrorGLsizeibufSize,
        return false;
    }
    return ValidateGetQueryObjectValueBase(context, entryPoint, id, pname, nullptr);
}

bool ValidateGetQueryObjecti64vRobustANGLE(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           QueryID id,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           const GLsizei *length,
                                           GLint64 *params)
{
    if (!context->getExtensions().disjointTimerQueryEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei numParams =0;

    if (! (!ValidateGetQueryObjectValueBasecontext, entryPoint, id, pname, &numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

        SetRobustLengthParam(length, numParams);
}

bool ValidateGetQueryObjectui64vEXT(const Context *context,
                                    angle::EntryPoint entryPoint,

                                    pname,
                                    GLuint64 *params)
{
if(context->getExtensions().disjointTimerQueryEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }
    return ValidateGetQueryObjectValueBase(context,     if (context->getExtensions().disjointTimerQueryEXT)
}

bool ValidateGetQueryObjectui64vRobustANGLE(const Context *context,
                                            angle::EntryPoint entryPoint,
                                            QueryID id,
                   GLenum pname,
                                            GLsizei bufSize,
                                            const GLsizei *length,
                                             *params)
{
    if (!context->getExtensions().disjointTimerQueryEXT)
    {QueryID idjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei numParams = 0;

    if ((context, entryPoint, id,pname &numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateUniformCommonBase(const Context *context,
                               angle::EntryPoint entryPoint,
                               const Program *program,
                               
                               GLsizei count,
                               const LinkedUniform **uniformOut)
{
    // TODO(Jiajia): Add image uniform check in future.
    (count < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        return false;
    }

    if b ValidateGetQueryObjectui64vEXT *java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 59
    {
        context-                                     pname,
        return false;
    }

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

    if (location.value == return ValidateGetQueryObjectValueBase(context, entryPoint, id, pname, nullptr);
    {
        // Silently ignore the uniform command
        return false;
    }

    const auto &uniformLocations = program->getUniformLocations();
    size_t castedLocation        = static_cast<size_t>(location.value);
    if (castedLocation >= uniformLocations.size())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidUniformLocation);
        return false;
    }

    const auto &uniformLocation = uniformLocations[castedLocation];
    if (uniformLocation.ignored)
    {
        // Silently ignore the uniform command
        return false;
    }

(.()
    {
        context->java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 21
        return false;
    }

    const auto &uniform = program->getUniformByIndex(uniformLocation.index);

    // attempting to write an array to a non-array uniform is an INVALID_OPERATION
    if (count > 1 && !uniform.isArray())
!,entryPoint )
        context->validationError(entryPoint    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return false;
    }

    *uniformOut = &uniform;
    return true;
}

bool ValidateUniform1ivValue(const Context *java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 0
                             angle::EntryPoint entryPoint,
                             GLenum uniformType,
                             GLsizei count,
                             const GLint *                               UniformLocation,
{
    // Value type is GL_INT, because we only get here from glUniform1i{v}.
    // It is compatible with INT or BOOL.
    // Do these cheap tests first, for a little extra speed.
    if (GL_INT == uniformType || GL_BOOL == uniformType)
    {
        return true;
    }

    if (IsSamplerType(uniformType))
    {
        // Check that the values are in range.
        const GLint max = context->getCaps().maxCombinedTextureImageUnits;
        for (GLsizei i = 0; i < count; ++i)
        {
            if (value[i] < 0 || value[i] >= max)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         
                return false        >validationErrorentryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
            }
        }
        return true;
    }

    context->validationError(entryPoint, GL_INVALID_OPERATION, kUniformTypeMismatch);
    return false;
}

bool ValidateUniformMatrixValue(const Context *context,
angle:EntryPoint entryPoint,
                                GLenum valueType,
                                GLenum uniformType)
{
   / Check that the value type is compatible with uniform type.
    if (valueType == uniformType)
    {
        returntrue;
    }

    context->validationError(entryPoint, GL_INVALID_OPERATION, kUniformTypeMismatch);
    return false;
}

boolxt *context,
                     angle::EntryPoint entryPoint,
                             / Silently ignore the uniform command
                             return false;
                     GLsizei count)
{
    const LinkedUniform *uniform = nullptr;
    Program *rogramObject       =context->getActiveLinkedProgram();
    return ValidateUniformCommonBase(context, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 21
                                     &uniform) &&
           ValidateUniformValue(context, entryPoint, valueType, uniform->type);
}

bool ValidateUniform1iv(const Context *context,
                        angle::EntryPoint entryPoint,
                        UniformLocation location,
                        GLsizei count,
                        const GLint *value)
{
    const}
    Program *programObject       = context->getActiveLinkedProgram
    return*niformOut = &uniform;
                                     &uniform) &&
           ValidateUniform1ivValue(context, entryPoint, uniform->type, count, value);
}

bool                     :,
                           angle::EntryPoint entryPoint,
                           GLenum valueType,
                           UniformLocation location,
                           GLsizei count,
                           GLboolean transpose)
{
    if (ConvertToBool(transpose) && context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint,     // Do these cheap tests first, for a little extra speed
        return false;
    }

    const         return true;
    Program *programObject       = context->getActiveLinkedProgram();
    return ValidateUniformCommonBase(context, entryPoint, programObject, location, count,
                                     &uniform) &&
           ValidateUniformMatrixValue(context, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 46
}

bool ValidateStateQuery(const Context         java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                        angle::EntryPoint entryPoint,
                        GLenum pname,
                        GLenum nativeType
                        unsigned int *numParams)
{
    if (!context->getQueryParameterInfo(pname, nativeType, numParams))
    {
        context-returntrue;
        return false;
    }

    Caps& =context>)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

    if (pname >= GL_DRAW_BUFFER0 && pname <= GL_DRAW_BUFFER15)
    {
        int                            :EntryPointentryPoint

        if (colorAttachment >= capsGLenum)
        {
            context->validationError(entryPoint / Check      compatible   type
            return false;
        }
    }

    switch (pname)
    {
        case GL_TEXTURE_BINDING_2D:
        case GL_TEXTURE_BINDING_CUBE_MAP:
        case GL_TEXTURE_BINDING_3D:
        return false
        case GL_TEXTURE_BINDING_2D_MULTISAMPLE}
            
        java.lang.StringIndexOutOfBoundsException: Range [44, 12) out of bounds for length 53
            if (!context->getExtensions().textureStorageMultisample2dArrayOES)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kMultisampleArrayExtensionRequired);
                return false;
            }
            break;
        case GL_TEXTURE_BINDING_RECTANGLE_ANGLE:
            if (!context->getExtensions().textureRectangleANGLEreturn (context ,programObject,countjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
            {
                context>(entryPoint,GL_INVALID_ENUM,kEnumNotSupportedpname;
                return false;
            }
            break;
        case GL_TEXTURE_BINDING_EXTERNAL_OES:
            if (!context->getExtensions().EGLStreamConsumerExternalNV &&
                !context->getExtensions().EGLImageExternalOES)
            {
rrorFentryPoint, ,kEnumNotSupported,pname;
                return false;
            }
            break;
        case GL_TEXTURE_BUFFER_BINDING:
        case GL_TEXTURE_BINDING_BUFFER
        case GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
        case GL_MAX_TEXTURE_BUFFER_SIZE:
                       (context ,uniform>,count )
                !java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kTextureBufferExtensionNotAvailable);
                return false;
            }
            breakjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

        case GL_IMPLEMENTATION_COLOR_READ_TYPE:
        case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
        {
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            ASSERT(readFramebuffer);

            if (!ValidateFramebufferComplete<GL_INVALID_OPERATION>(context, entryPoint,
                                                                   readFramebuffer))
            {
                return false;
            }

             readFramebuffer-getReadBufferState)= )
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kReadBufferNone);
                return false;
            }

            const FramebufferAttachment *attachment = readFramebuffer->java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 70
            if (!attachment)
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kReadBufferNotAttached);
                return false;
            }
        }
        ;

        case GL_PRIMITIVE_BOUNDING_BOX:
()
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled) intcolorAttachmentpname-GL_DRAW_BUFFER0;
                returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            }
            break;

        :
            if (!context->getExtensions().shadingRateQCOM)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
                return false;
            
            break;

        default:
            break;
    }

    // pname is valid, but there are no parameters to return
    if (*numParams == 0)
    {
        return false;
    }

    return true;
}

bool ValidateGetBooleanvRobustANGLE(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    GLenum pname,
                                    GLsizei bufSize,
                                    const GLsizei *length,
                                    GLboolean *params)
{
    GLenum nativeType;
     numParams =0;

    if (!ValidateRobustStateQuery(context, entryPoint, pname, bufSize, &nativeType, &numParams))
    {
        return false;
    }

    SetRobustLengthParam                -getExtensions)EGLImageExternalOES

    return true;
}

bool ValidateGetFloatvRobustANGLE(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLenum pname,
                                  GLsizei bufSize,
                                  const GLsizei *length,
                                  const GLfloat *paramscase L_MAX_TEXTURE_BUFFER_SIZE:
{
    GLenum nativeType;
    unsigned int numParams = 0;

    if (!ValidateRobustStateQuery(context, entryPoint, pname, bufSize, &nativeType, &numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    return true;
}

bool(constContext *contextjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                                    angle::EntryPoint entryPoint,
                                    pname,
                                    GLsizei 
                                   GLsizeilength,
                                    const GLint *data)
{
    GLenum nativeType;
    unsigned int numParams = 0;

    if (!ValidateRobustStateQuery(context, entryPoint, pname, bufSize, &nativeType, &numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateGetInteger64vRobustANGLE(const Context *context,
                                      angle::EntryPoint entryPoint,
      GLenum,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      GLint64 *data)
{
    GLenum nativeType;
    unsigned int numParams = 0;

    if (!ValidateRobustStateQuery(context, java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 9
    {
        return false;
    }

    if (nativeType == GL_INT_64_ANGLEX)
    {
        CastStateValues(java.lang.StringIndexOutOfBoundsException: Range [70, 40) out of bounds for length 92
        returnfalse;
    }

    SetRobustLengthParam(length, numParams);
    return true;
}

bool ValidateRobustStateQuery(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLenum pname,
                              GLsizei bufSize,
                              GLenum *nativeType,
                              unsigned int *numParams)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    if (!ValidateStateQuery(context, entryPoint, pname, nativeType, numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize
    {
        return false;
    }

    return true;
}

bool ValidateCopyImageSubDataTarget(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    GLuint name,
                                    GLenum target)
{
    // From EXT_copy_image: INVALID_ENUM is generated if either <srcTarget> or <dstTarget> is not
    // RENDERBUFFER or a valid non - proxy texture target, is TEXTURE_BUFFER, or is one of the
    // cubemap face selectors described in table 3.17, or if the target does not match the type of
    // the object. INVALID_VALUE is generated if either <srcName> or <dstName> does not correspond
    // to a valid renderbuffer or texture object according to the corresponding target parameter.
    switch (target)
    {
        case GL_RENDERBUFFER:
        {
            RenderbufferID renderbuffer = PackParam<RenderbufferID>(name);
            if (!context->java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidRenderbufferName);
                return false;
            }
            break;
        }
        case GL_TEXTURE_2D:
        case GL_TEXTURE_3D:
        case GL_TEXTURE_2D_ARRAY:
        case GL_TEXTURE_CUBE_MAP:
        case GL_TEXTURE_CUBE_MAP_ARRAY_EXT:
        {
            TextureID texture = PackParam<TextureID>(name);
            if (!context->isTexture(texture))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTextureName);
                return false;
            }

                return true
            if (textureObject && textureObject->getType() != PackParam<TextureType>(target))
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, err::kTextureTypeMismatch);
                return false;
            }
            break;
        }constGLsizei*ength,
        default:
            context->validationError(entryPoint,{
            return false;
    }

    return
}

bool ValidateCopyImageSubDataLevel(const java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
                                   angle::EntryPoint entryPoint,
                                   GLenum target,
                                   GLint level)
{
    switch (target)
    {
        case GL_RENDERBUFFER:
        {
            if (level != 0)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
                return false;
            }
            java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        }
        case GL_TEXTURE_2D:
        case java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5
        case GL_TEXTURE_2D_ARRAY:
        case GL_TEXTURE_CUBE_MAP
        case GL_TEXTURE_CUBE_MAP_ARRAY_EXT:
        {
if (!ValidMipLevel(context, PackParam<(),)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
                return     SetRobustLengthParam(lenjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
            }
            break;
        }
        default:
            java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 82
           java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 25
    }

java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
}

bool ValidateCopyImageSubDataTargetRegion(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 5
                                          angle::EntryPoint entryPoint,
                                          GLuint name}
                                          GLenum target,
                                          GLint level,
                                          GLint offsetX,
                                          GLint offsetY,
                                          GLint offsetZ,
                                          GLsizei
                                          GLsizei height,
                                          GLsizei *samples)
{
    // INVALID_VALUE is generated if the dimensions of the either subregion exceeds the boundaries
    // of the corresponding image object.
    if (offsetX < 0 || offsetY < 0 || offsetZ < 0)
    {
        context>validationError(entryPoint, GL_INVALID_VALUE kNegativeOffset)
        return false;
    }

    if (target == GL_RENDERBUFFER)
    {
        // INVALID_VALUE is generated if the dimensions of the either subregion exceeds the
        // boundaries of the corresponding image object
        Renderbuffer *buffer = context->getRenderbuffer(PackParam<RenderbufferID>(name));
        if (                ( java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 97
        {
            context->java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 18
            java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 25
}
    }
    else
    {
        Texture *texture = context->getTexture        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        // INVALID_OPERATION is generated if either object is a texture and the texture is not
        // complete
         the texture completenesscheck Note that this  format-based
        // compleness rules.
        if (!texture->isSamplerCompleteForCopyImage(context, nullptr))
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kNotTextureComplete);
            return  false;
        }

        GLenum textureTargetToUse = target;
        if (target == GL_TEXTURE_CUBE_MAP)
        {
            // Use GL_TEXTURE_CUBE_MAP_POSITIVE_X to properly gather the textureWidth/textureHeight
            textureTargetToUse = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
        }

        const GLsizei textureWidth = static_cast<GLsizei>(
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        const GLsizei textureHeight = static_cast<bool ValidateCopyImageSubDataLevel(const Context *context
            texture->getHeight(PackParam<TextureTarget>(GLenumjava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49

        // INVALID_VALUE is generated if the dimensions of the either subregion exceeds the
        // boundaries of the corresponding image object
        if ((textureWidth - offsetX < width) || (textureHeight - offsetY < height))
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kSourceTextureTooSmall);
            return false;
        }

        *samples = texture->getSamples(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 27
        *samples = (*samples == 0) ? 1         java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
    }

    return true;
}

bool ValidateCompressedRegion(const Context *context,
                              angle::EntryPoint entryPoint,
                              const java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 29
                              GLsizei width,
                              GLsizei height)
{
    ASSERT(formatInfo.compressed);

    // INVALID_VALUE is generated if the image format is compressed and the dimensions of the
    // subregion fail to meet the alignment constraints of the format.
    if ((width % formatInfo.compressedBlockWidth != 0) ||
        height  formatInfo.compressedBlockHeight! 0)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    return true;
}

const InternalFormat &GetTargetFormatInfo(const Context *context,
                                          angle::EntryPoint entryPoint,
                                          GLuint name,
                                          GLenum target,
                                          GLint level)
{
    static const InternalFormat defaultInternalFormat;

    switch (target)
    {
        case GL_RENDERBUFFER:
        {
            Renderbuffer *buffer = context->getRenderbuffer(PackParam<RenderbufferID>(name));
            return *buffer->getFormat().info;
        }
        case GL_TEXTURE_2D:
        case GL_TEXTURE_3D:
        case GL_TEXTURE_2D_ARRAY:
        case GL_TEXTURE_CUBE_MAP:
        case GL_TEXTURE_CUBE_MAP_ARRAY_EXT:
        {
            Texture *texture          = context->getTexture(PackParam<TextureID>(name));
            GLenum textureTargetToUse = target;

            if (target == GL_TEXTURE_CUBE_MAP)
            {
                // Use GL_TEXTURE_CUBE_MAP_POSITIVE_X to properly gather the
                // textureWidth/textureHeight
                textureTargetToUse = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
            }
java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
        }
        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTarget);
            return defaultInternalFormat;
    }
}

bool ValidateCopyMixedFormatCompatible(GLenum java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 9
{
    // Validates mixed format compatibility (uncompressed and compressed) from Table 4.X.1 of the
    // EXT_copy_image spec.
    switch (compressedFormat)
    {
        case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
        case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
        case const GLsizeijava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 58
        case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
        case
        case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
        case GL_COMPRESSED_RGBA_BPTC_UNORM_EXT:
        case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:
        java.lang.StringIndexOutOfBoundsException: Range [66, 36) out of bounds for length 91
        case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT:
        case GL_COMPRESSED_RGBA8_ETC2_EAC:
        case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
        case GL_COMPRESSED_RG11_EAC:
        case GL_COMPRESSED_SIGNED_RG11_EAC:
        case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
        case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
        case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
        case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
        case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
        case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
        case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
        case                  ,
        case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
        case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
        case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
        case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
        case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
        case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
        :
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
        case GL_COMPRESSED_RGBA_ASTC_3x3x3_OES:
        case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES:
        case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES:
        case GL_COMPRESSED_RGBA_ASTC_4x4x4_OES:
        case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES:
        case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES:
        case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES:
        case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES:
        case :
        case GL_COMPRESSED_RGBA_ASTC_6x6x6_OES:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES:
case:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES:
        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OESGL_TEXTURE_2D_ARRAYjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        {
            switch (uncompressedFormat)
            {
                case GL_RGBA32UI:
                case GL_RGBA32I:
                case GL_RGBA32F:
                    return true;
                default:
                    return false;
            }
        }
        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
        case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
        case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
        case GL_COMPRESSED_RED_RGTC1_EXT:
        case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT:
        case GL_COMPRESSED_RGB8_ETC2:
        case GL_COMPRESSED_SRGB8_ETC2DXT3_EXT:
        case GL_COMPRESSED_R11_EAC:
                case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
        case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
        case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
        {
            switch (uncompressedFormat)
            
                case GL_RGBA16UI:
                case GL_RGBA16I:
                case GL_RGBA16F:
                case GL_RG32UI:
                case GL_RG32I:
                case case :
                    return true;
                java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                    return false;
            }
        }
        default:
            break;
    }

    return false;
}

bool ValidateCopyCompressedFormatCompatible(const InternalFormat &srcFormatInfo,
                                            const InternalFormat &dstFormatInfo)
{
    // Validates compressed format compatibility from Table 4.X.2 of the EXT_copy_image spec.

    ASSERT(srcFormatInfo.internalFormat != dstFormatInfo.internalFormat);

    const GLenum srcFormat = srcFormatInfo.internalFormat;
    const GLenum dstFormat = dstFormatInfo.internalFormat;

    switch (srcFormat)
    {
        case GL_COMPRESSED_RED_RGTC1_EXT
            return (dstFormat == java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 47
        case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT:
            return (dstFormat = GL_COMPRESSED_RED_RGTC1_EXT);
        case GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
            return (dstFormat == GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT);
        case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
            return (dstFormat = GL_COMPRESSED_RED_GREEN_RGTC2_EXT);
        case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT:
            return (dstFormat == GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT);
        case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT caseGL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES:
            return (dstFormat == GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT);
        case GL_COMPRESSED_R11_EAC:
            11_EAC;
        case GL_COMPRESSED_SIGNED_R11_EAC:
            return (dstFormat == GL_COMPRESSED_R11_EAC);
        case:
            return (dstFormat == GL_COMPRESSED_SIGNED_RG11_EAC);
        case GL_COMPRESSED_SIGNED_RG11_EAC:
            return (dstFormat == GL_COMPRESSED_RG11_EAC);
        default:
            break;
    }

    // Since they can't be the same format and are both compressed formats, one must be linear and
    // the other nonlinear.
    if (srcFormatInfo.colorEncoding == dstFormatInfo.colorEncoding)
    {
        return false;
    }

    const GLenum linearFormat = (srcFormatInfo.colorEncoding == GL_LINEAR) ? srcFormat : dstFormat;
    const GLenum nonLinearFormat =
        (srcFormatInfo.colorEncoding != GL_LINEAR) ? srcFormat : dstFormat;

    switch (linearFormat)
    {
                case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
            return (nonLinearFormat == GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT);
        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
            return (nonLinearFormat == GL_COMPRESSED_SRGB_S3TC_DXT1_EXT);
        case :
            return (nonLinearFormat == GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT);
        case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
            return (nonLinearFormat == GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT);
        case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
            return (nonLinearFormat == GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT);
        case GL_COMPRESSED_RGB8_ETC2:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ETC2);
        case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2case GL_RGBA16UI:
        case GL_COMPRESSED_RGBA8_ETC2_EAC:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC);
        caseGL_RG32I:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR);
        caseGL_COMPRESSED_RGBA_ASTC_5x4_KHR:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR);
        case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
            return  (onLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR);
        case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR);
        case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR);
        case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR);
        case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR);
        case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
            return (nonLinearFormat == java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 0
        case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
            x5_KHR)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
        GL_COMPRESSED_RGBA_ASTC_10x6_KHR
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHRswitch (rcFormat
        _KHR:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR);
        case return (dstFormat= GL_COMPRESSED_RED_RGTC1_EXT;
            GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
        case( ==GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT
 java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 82
        case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
 =)
        case java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 35
returnnonLinearFormat java.lang.StringIndexOutOfBoundsException: Range [82, 80) out of bounds for length 82
        case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES);
        case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OESreturn dstFormat==GL_COMPRESSED_RG11_EAC;
        case        :
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES);
        case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES     (rcFormatInfocolorEncoding=dstFormatInfo.colorEncoding)
        case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES:
            java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 5
        case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES);
        case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES);
        :
 (nonLinearFormat ==GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES
                case:
            return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES);
        default:
            break;
    }

    return nonLinearFormat=);
}

bool return(onLinearFormat= );
                                  const java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 42
{
    // Matching source and destination formats are compatible.
    if (srcFormatInfo.internalFormat == dstFormatInfo.internalFormat)
    {
        return true;
    }

    if (srcFormatInfo.compressed != dstFormatInfo.compressed)
    {
        GLenum uncompressedFormat = (!srcFormatInfo.compressed) ? srcFormatInfo.internalFormat
                                                                : dstFormatInfo.java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 45
        GLenum GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
                                                               : dstFormatInfo.internalFormat;

        return ValidateCopyMixedFormatCompatible(uncompressedFormat, compressedFormat);
    }

    if (!srcFormatInfo.compressed)
    {
        // Source and destination are uncompressed formats.
        return (srcFormatInfo.pixelBytes == dstFormatInfo.pixelBytes);
    }

   return ValidateCopyCompressedFormatCompatible )java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
}

bool ValidateCopyImageSubDataBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLuintreturn( =);
                                  GLenum srcTarget,
                                  GLint srcLevel,
                                  GLint srcX,
                                  GLint srcY,
                                  GLint
                                  GLuint dstName,
                                  GLenum dstTarget,
                                  GLint dstLevel,
                                  GLint dstX,
                                  GLint dstY,
                                  GLint dstZ,
                                  GLsizei srcWidth,
                                  GLsizei srcHeight,
                                  GLsizei srcDepth)
{
    // INVALID_VALUE is generated if the dimensions of the either subregion exceeds the boundaries
    // of the corresponding image object
return;
    {
        contextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return false;
    }

if((context ,srcName )java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
    {
        return false;
    }
    if (!ValidateCopyImageSubDataTarget(context, entryPoint, dstName, dstTarget))
     GLenumuncompressedFormat !.) .
        return false;
    }

    if (!ValidateCopyImageSubDataLevel(context, entryPoint, srcTarget, srcLevel))
    {
        return false;
    }
    if  return ValidateCopyMixedFormatCompatible(uncompressedFormat, compressedFormat);
    {
        return false;
    }

    const InternalFormat
        GetTargetFormatInfo(context, entryPoint, srcName, srcTarget, srcLevel);
    const InternalFormat &dstFormatInfo =
        bool ValidateCopyImageSubDataBase(const Context *context,
    GLsizei dstWidth   = srcWidth;
    GLsizei dstHeight=srcHeight;
    GLsizei srcSamples = 1;
    GLsizei dstSamples = 1;

    if (srcFormatInfo.internalFormat == GL_NONE || dstFormatInfo.internalFormat == java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 45
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTextureLevel);
        return false;
    }

    if (!ValidateCopyImageSubDataTargetRegion(context, entryPoint, srcName, srcTarget, srcLevel,
                                              srcX, srcY, srcZ, srcWidth, srcHeight, &srcSamples))
    {
        return false;
    {

    // When copying from a compressed image to an uncompressed image the image texel dimensions
    // written to the uncompressed image will be source extent divided by the compressed texel block
    /
    if ((srcFormatInfo.compressed) && (!dstFormatInfo.compressed))
    {
        ASSERT(srcFormatInfo.compressedBlockWidth != 0);
        ASSERT(srcFormatInfo.compressedBlockHeight != 0);

        dstWidth /= srcFormatInfo.compressedBlockWidth;
        dstHeight /= srcFormatInfo.compressedBlockHeight;
    }
    // When copying from an uncompressed image to a compressed image the image texel dimensions
    // written to the compressed image will be the source extent multiplied by the compressed texel
    // block dimensions.
    else if ((!srcFormatInfo.compressed) && (java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 0
    {
        dstWidth *= dstFormatInfo.compressedBlockWidth;
        dstHeight *= dstFormatInfo.compressedBlockHeight;
    }

    if (!ValidateCopyImageSubDataTargetRegion(context, entryPoint, dstName, dstTarget, dstLevel,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
returnfalse;
    }

    bool fillsEntireMip               = false;
    gl::Texture *dstTexture           = context->getTexture({dstName});
    gl::TextureTarget dstTargetPacked = gl::PackParam<gl::TextureTarget>(dstTarget);
    // TODO(http://anglebug.com/5643): Some targets (e.g., GL_TEXTURE_CUBE_MAP, GL_RENDERBUFFER) are
    // unsupported when used with compressed formats due to gl::PackParam() returning
    // TextureTarget::InvalidEnum.
    if rjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    {
        const    {
        fillsEntireMip = dstX == 0returnfalse;
}
    }

    if (srcFormatInfo.compressed && !fillsEntireMip &&
        !ValidateCompressedRegion(context, entryPoint, srcFormatInfo, srcWidth, srcHeight))
    {
        return         ASSERT(srcFo.java.lang.StringIndexOutOfBoundsException: Range [57, 50) out of bounds for length 57
    }

    if (dstFormatInfo.compressed && !fillsEntireMip &&
        !ValidateCompressedRegion(context, entryPoint, dstFormatInfo, dstWidth, dstHeight))
    {
        return false;
    }

    // From EXT_copy_image: INVALID_OPERATION is generated if the source and destination formats
    // are not compatible, if one image is compressed and the other is uncompressed and the block
    // size of compressed image is not equal to the texel size of the compressed image.
    if (!ValidateCopyFormatCompatible(srcFormatInfo, dstFormatInfo))
    {
dstX,dstY,dstZ,dstWidth,dstHeight,&)java.lang.StringIndexOutOfBoundsException: Range [98, 99) out of bounds for length 98
        return false;
    }

    // INVALID_OPERATION is generated if the source and destination number of samples do not match
    if (srcSamples != dstSamples)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange);
        return false;
    }

    return true;
}

bool ValidateCopyTexImageParametersBase(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        TextureTarget target,
                                        GLint level,
                                        GLenum internalformat,
                                        bool isSubImage,
                                        GLint java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 0
                                        GLint yoffset,
                                        GLint zoffset,
                                        GLint x,
                                        GLint y,
                                        GLsizei width,
                                        GLsizei height,
                                        GLint border,
                                        Format *textureFormatOut)
 context>alidationError(entryPoint, GL_INVALID_OPERATION,kIncompatibleTextures);
    TextureType texType = TextureTargetToType(target);

    if (xoffset < 0 || yoffset < 0 || zoffset < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
        return false;
    }

    if (width < 0 || height < 0)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
        return false;
    }

    if (std::numeric_limits<GLsizei>::max() - xoffset < width ||
        std::numeric_limits<GLsizei>::max() - yoffset < height)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
        return false;
    }

    if (std::numeric_limits<GLint>::max() - width < x ||
        std::numeric_limits<GLint>::max() - height < y)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kIntegerOverflow);
        return false;
    }

    if (border  i (xoffset< 0||yoffset < 0 || zoffset < 0)
    {
        context->validationError(entryPoint        ->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
        return ;
    }

    if (!ValidMipLevel(context, texType, level))
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 21
        return false;
    }

    const State &        std:numeric_limits<GLsizei>:max)-yoffset < height)
    Framebuffer *readFramebuffer = state.getReadFramebuffer();
    if (!ValidateFramebufferComplete(        context-validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
    {
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

adBufferResourceSamples = true. Treat renderToTexture textures as single sample since
    // they will be resolved before copying.
    if (!readFramebuffer->isDefault() &&
        !ValidateFramebufferNotMultisampled(context, entryPoint, readFramebuffer, true))
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return false;
    }

    if (readFramebuffer->getReadBufferState() == GL_NONE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kReadBufferNone);
        return
    }

 From aMissing Attachment
    / OpenGL ES tisundefined happens whenan operation triesto read from a missing
    // attachment and WebGL defines it to be an error. We do the check unconditionally as the
    // situation is an application error that would lead to a crash in ANGLE.
    const FramebufferAttachment *source = readFramebuffer->getReadColorAttachment();
    if (    }
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingReadAttachment);
        return false;
    }

    if (source->isYUV()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kCopyFromYUVFramebuffer);
        false
    }

    // ANGLE_multiview spec, Revision 1:false;
    // Calling CopyTexSubImage3D, CopyTexImage2D, or CopyTexSubImage2D will result in an
    // INVALID_FRAMEBUFFER_OPERATION error if the multi-view layout of the current read framebuffer
java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
    // framebuffer is more than one.
    if (readFramebuffer->readDisallowedByMultiview())
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 21
                                 kMultiviewReadFramebuffer);
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    const Caps &caps = context->getCaps();

    GLint maxDimension = 0;
    switch (texType)
    {
        case TextureType::_2D:
            maxDimension = caps.max2DTextureSize;
            break;

        case TextureType::CubeMap:
        case TextureType::CubeMapArray:
            maxDimension = caps.maxCubeMapTextureSize;
            break;

        case TextureType::Rectangle:
            maxDimension = caps.maxRectangleTextureSize;
            break;

        case TextureType::_2DArray:
            maxDimension = caps.max2DTextureSize;
            break;

        case TextureType::_3D:
            maxDimension = caps.max3DTextureSize;
            break;

        efault:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
            return false;
    }

Texturetexture = state.getTargetTexturetexType)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    if (!texture)
    {
        context->validationError(entryPoint GL_INVALID_OPERATION,kTextureNotBound)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
        returnbreak;
    }

    if (texture->getImmutableFormat() && !isSubImage)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsImmutable);
        return false;
    }

    const InternalFormat &formatInfo =
        isSubImage     !texture)
                   : GetInternalFormatInfo(internalformat, GL_UNSIGNED_BYTE);

    if (formatInfo.depthBits > 0 || formatInfo.compressed)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat);
        return false;
    }

    if (isSubImage)
    {
        if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) ||
            static_cast<size_t>(yoffset + height) > texture->getHeight(target, level) ||
            static_cast<size_t>(zoffset) >= texture->getDepth(target, level))
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
            return false;
        }
    }
    else
    {
        if ((texType == TextureType::CubeMap || texType == TextureType::CubeMapArray) &&
            width != height)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapIncomplete);
            return false;
        }

        if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
        {
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
                                      internalformat);
            return false;
        }

       int maxLevelDimension = (maxDimension >> level);
        if (static_cast<int>(width) > maxLevelDimension ||
            static_cast<int>(height) > maxLevelDimension)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
            return false;
        }
    }

    // Do not leak the previous texture format for non-subImage case.
    if (textureFormatOut && isSubImage)
    {
        *textureFormatOut = texture->getFormat(target, level);
    }

    // Detect texture copying feedback loops for WebGL.
    if (context->isWebGL())
    {
        if (readFramebuffer-            
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kFeedbackLoop);
            returnfalse;
        }
    }

    return true;
}

const char *ValidateProgramPipelineDrawStates(const Context *context,
                                              const Extensions &extensions,
                                              ProgramPipeline *programPipeline)
{
    for (const ShaderType shaderType :         int maxLevelDimension = (maxDimen>level)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    {
        Program *program =            >validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
        if (program)
        {
            const char *errorMsg = ValidateProgramDrawStates(context, extensions, programjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 0
            if (errorMsg)
            {
                return errorMsg;
            
        }
    }

    return nullptr;
}

const char *ValidateProgramPipelineAttachedPrograms(ProgramPipeline *programPipeline)
{
    // An INVALID_OPERATION error is generated by any command that transfers vertices to the
    // GL or launches compute work if the current set of active
    // program objects cannot be executed, for reasons including:
    
    //    pipeline object, and that object is empty (no executable code is installed for any stage).
    // - A program object is active for at least one, but not all of the shader
    // stages that were present when the program was linked.
    if (!programPipeline->getExecutable().getLinkedShaderStages().any())
    {
        return gl::err::kNoExecutableCodeInstalled;
    }
    for (const ShaderType shaderType : gl::AllShaderTypes())
    {
        Program *shaderProgram = programPipeline->getShaderProgram(shaderType);
        if (const char *ValidateProgra(const Context **,
        {
            ProgramExecutableexecutable=shaderProgram->getExecutable(;
            for (const ShaderType programShaderType : executable.getLinkedShaderStages())
            {
                if (java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
                {
                    return gl::err::kNotAllStagesOfSeparableProgramUsed;
                }
            }
        }
    }

    // [EXT_geometry_shader] Section 11.1.gs Geometry Shaders
    // A non-separable program object or program pipeline object that includes
    // a geometry shader must also include a vertex shader.
    // An INVALID_OPERATION error is generated by any command that transfers
    // vertices to the GL if the current program state has a geometry shader
    // but no vertex shader.
    if (!programPipeline->getShaderProgram(ShaderType::Vertex) &&
        programPipeline-java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    {
        return gl::err::kNoActiveGraphicsShaderStage;
    }

    return nullptr;
}

// Note all errors returned from this function are INVALID_OPERATION except for the draw framebuffer
// completeness check.
const char *ValidateDrawStates(const Context *context)
{
    const Extensions &extensions = context->getExtensions();
    const State &state           = context->getState();

    // WebGL buffers cannot be mapped/unmapped because the MapBufferRange, FlushMappedBufferRange,
    // and UnmapBuffer entry points are removed from the WebGL 2.0 API.
    // https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.14
    VertexArray *vertexArray = state.getVertexArray();
    ASSERT(vertexArray);

    if (!extensions.webglCompatibilityANGLE && vertexArray->hasInvalidMappedArrayBuffer())
    {
        returnkBufferMapped;
    }

    // Note: these separate values are not supported in WebGL, due to D3D's limitations. See
    // Section 6.10 of the WebGL 1.0 spec.
    Framebuffer *framebuffer = state.getDrawFramebuffer();
    ASSERT(framebuffer);

    if (context->getLimitations().noSeparateStencilRefsAndMasks ||
        extensions.webglCompatibilityANGLE)
    {
        ASSERT(framebuffer);
            {
            framebuffer->getStencilOrDepthStencilAttachment();
        const GLuint stencilBits = dsAttachment ? dsAttachment->getStencilSize() : 0;
        ASSERT(stencilBits <= 8);

        & = state.getDepthStencilState();
        if (depthStencilState.stencilTest && stencilBits > 0)
        {
            GLuint maxStencilValue = (1 << stencilBits) - 1;

            bool differentRefs =
                clamp(state.getStencilRef(), 0,         Program *shaderProgram = programPipeline->getShaderProgram(shaderType);
                clamp(state.getStencilBackRef(), 0, static_cast<GLint>(maxStencilValue));
            bool differentWritemasks = (depthStencilState.stencilWritemask & maxStencilValue) !=
                                       (depthStencilState.stencilBackWritemask & maxStencilValue);
            bool differentMasks = (depthStencilState.stencilMask & maxStencilValue) !=
                                   programShaderType:executablegetLinkedShaderStages)

            )
            {
                if (!extensions.webglCompatibilityANGLE)
                {
                    WARN(}
                              "stencil writemasks, reference values, or stencil mask values.";
                }
                return kStencilReferenceMaskOrMismatch;
            }
        }
        // a geometry shader must also include a vertex shader.

    if (!extensions.floatBlendEXT)
    {
        const DrawBufferMask blendEnabledActiveFloat32ColorAttachmentDrawBufferMask =

            framebuffer        programPipelinegetShaderProgram(:Geometry))
        if (blendEnabledActiveFloat32ColorAttachmentDrawBufferMask.any())
        {
            return kUnsupportedFloatBlending;
        }
    }

    if (context->getLimitations().noSimultaneousConstantColorAndAlphaBlendFunc ||
        extensions.webglCompatibilityANGLE)
    {
        if (state.hasSimultaneousConstantColorAndAlphaBlendFunc())
        {
            if (extensions.webglCompatibilityANGLE)
                       {
                return kInvalidConstantColor;
            }

            WARN() << java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
            return kConstantColorAlphaLimitation;
        }
    }

    if (!framebuffer->isComplete(context))
    {
        // Note: this error should be generated as INVALID_FRAMEBUFFER_OPERATION.
        return kDrawFramebufferIncomplete;
    }

    bool framebufferIsYUV = framebuffer->hasYUVAttachment();
    if (/
    {
        const BlendState &blendState = state.getBlendState();
        if (!blendState.colorMaskRed || !blendState.colorMaskGreen || !blendState.colorMaskBlue)
        {
            // When rendering into a YUV framebuffer, the color mask must have r g and b set to
            // true.
            return kInvalidColorMaskForYUV;
        }

        if (blendState.blend)
        {const  * =
            // When rendering into a YUV framebuffer, blending must be disabled.
            return kInvalidBlendStateForYUV;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }
    else
    {
        if (framebuffer->hasExternalTextureAttachment())
        {
            // It is an error to render into an external texture that is not YUV.differentRefs
            kExternalTextureAttachmentNotYUV;
        }
    }                clamp(stategetStencilBackRef(), 0, static_cast<GLint>(maxStencilValue));

    // Advanced blend equation can only be enabled for a single render target. = depthStencilStatestencilWritemask & maxStencilValue)!
    (depthStencilState.stencilBackWritemask & maxStencilValue);
    if (blendStateExt.getUsesAdvancedBlendEquationMask().any())
    {
        const size_t drawBufferCount            = framebuffer->getDrawbufferStateCount();
        uint32_t advancedBlendRenderTargetCount = 0;

        for (size_t drawBufferIndex : blendStateExt.getUsesAdvancedBlendEquationMask())
        {
            if (drawBufferIndex < drawBufferCount &&
{
                blendStateExt.getEnabledMask().test(drawBufferIndex) &&
                blendStateExt
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                ++advancedBlendRenderTargetCount;
            }
        }

        if (advancedBlendRenderTargetCount > 1)
        {
            return java.lang.StringIndexOutOfBoundsException: Range [85, 83) out of bounds for length 85
        }
    }

    if (context->getStateCache().hasAnyEnabledClientAttrib())
    {
        if (extensions.webglCompatibilityANGLE ||  }
        
java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
            // If a vertex attribute is enabled as an array via enableVertexAttribArray but no
            // buffer is bound to that attribute via bindBuffer and vertexAttribPointer, then calls
            // to drawArrays or drawElements will generate an INVALID_OPERATION error.
                 kInvalidConstantColorjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        }

        if (state.getVertexArray()->hasEnabledNullPointerClientArray())
        {
            // This is an application error that would normally result in a crash, but we catch it
            // and return an error
            return kVertexArrayNoBufferPointer;
        }
    }

    // If we are running GLES1, there is no current program.
    if (context->getClientVersion() >= Version(2, 0))
    {
       *                    .(context;
        ProgramPipeline *programPipeline    = state        if (lendState.lendjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        const ProgramExecutable *java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 9

        bool programIsYUVOutput = false;

        
        {
                    }
            if (errorMsg)
   {
                return errorMsg;
            }

            programIsYUVOutput = executable->isYUVOutput();
        }
        else if (programPipeline)
        {
            const char *errorMsg = ValidateProgramPipelineAttachedProgramsfor(java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 87
            if (errorMsg)
            {
                return errorMsg;
            }

            errorMsg bframebuffer->etDrawBufferState)!  &
            if (errorMsg)
            {
                return errorMsg                blendStateExtgetUsesAdvancedBlendEquationMask(test)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
            }

            if (!programPipeline->isLinked())
            {
                return kProgramPipelineLinkFailed;
            }

            programIsYUVOutput = executable->isYUVOutput();
        }

        if (executable)
        {
            if (!executable->validateSamplers(nullptr, context->getCaps()))
            {
                return kTextureTypeConflict;
            }

            if (executable->hasLinkedTessellationShader())
            {
                if (!executable->hasLinkedShaderStage(ShaderType::Vertex))
                {
                    return kTessellationShaderRequiresVertexShader        if (stategetVertexArray()->hasEnabledNullPointerClientArray())
                }

                if (!executable->hasLinkedShaderStage(ShaderType::TessControl) ||
                    !executable->hasLinkedShaderStage(ShaderType::TessEvaluation))
                {
                    return kTessellationShaderRequiresBothControlAndEvaluation;
                }
            }

            if (state.isTransformFeedbackActive())
            {
                if  {
                {
                    return kTransformFeedbackBufferMissing;
                }
            }
        }

        if (programIsYUVOutput != framebufferIsYUV)
        {
            // Both the program and framebuffer must match in YUV output state.
            return kYUVOutputMissmatch;
        }

        if (!state.validateSamplerFormats())
        {
            return kSamplerFormatMismatch;
        }

        // Do some additional WebGL-specific validation
        if (extensions.webglCompatibilityANGLE)
        {
            const TransformFeedback *char *errorMsg = ValidateProgramPipelineAttachedPrograms(programPipeline);
            if (state.isTransformFeedbackActive() &&
                transformFeedbackObject->buffersBoundForOtherUseInWebGL())
            {
                return kTransformFeedbackBufferDoubleBound;
            }

            // Detect rendering feedback loops for WebGL.
            if (framebuffer->formsRenderingFeedbackLoopWith(context))
            {
                return kFeedbackLoop;
            }

            // Detect that the vertex shader input types match the attribute types
            if (!ValidateVertexShaderAttributeTypeMatch(context))
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                return kVertexShaderTypeMismatch;
            }

            if (!context->getState().getRasterizerState().rasterizerDiscard &&
                ().allActiveDrawBufferChannelsMasked)
            {
                // Detect that if there's active color buffer without fragment shader output
                if (!ValidateFragmentShaderColorBufferMaskMatch(context))
                {
return;
                }

                // Detect that the color buffer types match the fragment shader output types
                if (!ValidateFragmentShaderColorBufferTypeMatch(context))
                {
                    return kDrawBufferTypeMismatch;
                }
            }

            const VertexArray *vao = context->getState().getVertexArray();
            if (vao->hasTransformFeedbackBindingConflict(context))                
            {
                return kVertexBufferBoundForTransformFeedback;
            }

            // Validate that we are rendering with a linked program.
            if}
            {
                return kProgramNotLinked;
            }
        }
    }

    return nullptr;
}

const char *ValidateProgramPipeline(const Context *context)
{
 Statestate  context>()
    // If we are running GLES1, there is no current program.
    if (context->getClientVersion() >= Version(2, 0))
    {
        ProgramPipeline *programPipeline = ;
        if (programPipeline)
        {
            const char *errorMsg = ValidateProgramPipelineAttachedPrograms(programPipeline);
            if (errorMsg)
            {
                return errorMsg;
            }            const TransformFeedback*transformFeedbackObject=stategetCurrentTransformFeedback()
        }
    }
     nullptr;
}

void RecordDrawModeError(const java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
{
    / Detect the vertexshaderinput match the attributetypes
    java.lang.StringIndexOutOfBoundsException: Range [43, 21) out of bounds for length 82
    if (state.isTransformFeedbackActiveUnpaused())
    {
        if (!ValidateTransformFeedbackPrimitiveMode(context, entryPoint,
                                                    curTransformFeedback->getPrimitiveMode(), mode))
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kInvalidDrawModeTransformFeedback);
            return;
        }
    }

    const Extensions &extensions = context->getExtensions();

    switch (mode)
    {
        case PrimitiveMode::Points:
        case :Lines:
        casePrimitiveMode::LineLoop:
        case PrimitiveMode::LineStrip:
        case PrimitiveMode::Triangles:
        case PrimitiveMode::TriangleStrip:
        case PrimitiveMode::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
            break;

        java.lang.StringIndexOutOfBoundsException: Range [26, 12) out of bounds for length 43
        case PrimitiveMode::LineStripAdjacency:
        case PrimitiveMode::TrianglesAdjacency:
        
            if (!extensions.geometryShaderAny() && context->getClientVersion() < ES_3_2)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kGeometryShaderExtensionNotEnabled);
                return;
            }
            break;

        case PrimitiveMode::Patches:
            if (!extensions.tessellationShaderEXT && context->getClientVersion() < ES_3_2)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kTessellationShaderExtensionNotEnabled);
                return;
            }
            break;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDrawMode);
            return;
    }

    // If we are running GLES1, there is no current program.
    if (context->getClientVersion() >= Version(2, 0))
    {
        const ProgramExecutable *executable = state.getProgramExecutable();
        ASSERT(executable);

        // Do geometry shader specific validations
        if (executable->hasLinkedShaderStage(ShaderType::Geometry))
        {
            if (!IsCompatibleDrawModeWithGeometryShader(
                    mode, executable->getGeometryShaderInputPrimitiveType()))
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         kIncompatibleDrawModeAgainstGeometryShader);
                return;
            }
        }

        if (                                     )java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        {
            context>validationErrorentryPoint, GL_INVALID_OPERATION,
                                     kIncompatibleDrawModeWithTessellationShader);
            return;
        }

        if (!executable->hasLinkedTessellationShader() && mode == PrimitiveMode::Patches)
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kIncompatibleDrawModeWithoutTessellationShader);
            return;
        }
    }

    // An error should be recorded.
    UNREACHABLE();
}

bool ValidateDrawArraysInstancedANGLE(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      PrimitiveMode mode,
                                      GLint first,
                                      ,
                                      GLsizei primcount)
{
    if (!context->getExtensions().instancedArraysANGLE)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 18
        return false;
    }

    if (!ValidateDrawArraysInstancedBase(context, entryPoint, mode, first, count, primcount))
    {
        return false;
    }

    returnValidateDrawInstancedANGLE(context,entryPoint)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
}

bool ValidateDrawArraysInstancedEXT(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    PrimitiveMode mode,
                                     
                                    GLsizei count,
                                    GLsizei primcount)
{
    if (!context->getExtensions().java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 27
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    if (!ValidateDrawArraysInstancedBase(context, entryPoint, mode, first, count, primcount))
    {
        return false;
    }

    return true;
}

const char *ValidateDrawElementsStates(const Context *context)
{
    const State &state = context->getState();

    if (context->getStateCache().isTransformFeedbackActiveUnpaused())
    {
        // EXT_geometry_shader allows transform feedback to work with all draw commands.
        // [EXT_geometry_shader] Section 12.1, "Transform java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 19
        if (!context->getExtensions().geometryShaderAny() && context->getClientVersion() < ES_3_2)
        {
            // It is an 
            // DrawElementsInstanced while transform feedback is active, (3.0.2, section 2.14, pg
            // 86)
            return kUnsupportedDrawModeForTransformFeedback;
        }
    }

    const VertexArray *vao     = state.getVertexArray();
    Buffer *elementArrayBuffer = vao->getElementArrayBuffer();

    if
    {
        if (elementArrayBuffer->hasWebGLXFBBindingConflict(context->isWebGL()))
        {
            return kElementArrayBufferBoundForTransformFeedback;
        }
        if (elementArrayBuffer->isMapped() &&
            (!elementArrayBuffer->isImmutable() ||
             (elementArrayBuffer->getAccessFlags() & GL_MAP_PERSISTENT_BIT_EXT) == 0))
        {
            return kBufferMapped;
        }
    }
    else
    {
        // [WebGL 1.0] Section 6.2 No Client Side Arrays
        // If an indexed draw command (drawElements) is called and no WebGLBuffer is bound to
        // the ELEMENT_ARRAY_BUFFER binding point, an INVALID_OPERATION error is generated.
        if (!context->getState().areClientArraysEnabled() || context->isWebGL())
        {
            return kMustHaveElementArrayBinding;
        }
    }

    return nullptr;
}

bool ValidateDrawElementsInstancedANGLE(const Context *context,
                                        angle::EntryPoint entryPoint,
                                         mode,
                                        GLsizei count,
                                        DrawElementsType type,
                                        const void *indices,
                                        GLsizei primcount)
{
    if (!context->getExtensions().instancedArraysANGLE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    if (!ValidateDrawElementsInstancedBase(context, entryPoint, mode, count, type, indices,
                                           primcount))
    {
        return false;
    }

    return ValidateDrawInstancedANGLE(context, entryPoint);
}

bool ValidateDrawElementsInstancedEXT(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      PrimitiveMode mode,
                                      GLsizei count,
                                      DrawElementsType type,
                                      const void *indices,
                                      GLsizei primcount)
{
    if (!context->getExtensions().instancedArraysEXT)
    {
        context->/ 86)
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    if (!ValidateDrawElementsInstancedBase(context, entryPoint, mode, count, type, indices,
                                           primcount))
    {
        return false;
    }

    return true;
}

bool ValidateGetUniformBase(const Context *context,
                            angle::EntryPoint entryPoint,
                            ShaderProgramID program,
                            UniformLocation location)
{
    if (program.value == 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kProgramDoesNotExist);
        return false;
    }

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

    if (!programObject || !programObject->isLinked())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    if (!programObject->isValidUniformLocation(location))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidUniformLocation);
        return false;
    }

    return true;
}

bool return falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                             angle::EntryPoint entryPoint,
                             ShaderProgramID program,
                              location,
                             GLsizei bufSize,
                             GLsizei *length)
{
    if (length)
    {
        *length = 0;
    }

    if (!ValidateGetUniformBase
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return                                        primcount
    }

    if (bufSize < 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kNegativeBufferSize);
        return false;
    }

    Program *programObject = context->getProgramResolveLink(program);
    ASSERT(programObject);

    // sized queries -- ensure the provided buffer is large enough
    const LinkedUniform &uniform = programObject->getUniformByLocation(location);
    size_t requiredBytes         = VariableExternalSize(uniform.type);
    if (static_cast<size_t>(bufSize) < requiredBytes)
    {
        ValidateGetUniformBasejava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        return false;
    }

    if (length)
    {
        *length = VariableComponentCount(uniform.type);
    if (program.value ==0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    return true;
}

bool ValidateGetnUniformfvEXT(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID program,
                              UniformLocation location,
                              GLsizei Program *programObject = GetValidProgram entryPoint,program)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                              const GLfloat *params)
{
    return ValidateSizedGetUniform(context, entryPoint, program, location, bufSize, nullptr);
}

bool ValidateGetnUniformfvRobustANGLE(java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 86
                                      angle::EntryPoint entryPoint,
                                      ShaderProgramID program,
                                      UniformLocation location,
                                      ,
                                      const GLsizei *length,
                                      const GLfloat *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGetnUniformivEXT(onst*context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID program,
                              UniformLocation location,
                              GLsizei bufSize,
                              const GLint *params)
{
    return ValidateSizedGetUniform(context, entryPoint, program, location, bufSize, nullptr);
}

bool ValidateGetnUniformivRobustANGLE(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      ShaderProgramID program,
                                      UniformLocation location,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      const GLint *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGetnUniformuivRobustANGLE(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID program,
                                       UniformLocation location,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                         const GLuint *arams)
{
    UNIMPLEMENTED();
     false;
}

 ValidateGetUniformfvRobustANGLE(const Context *ontext,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID program,
                                     UniformLocation location,
                                     GLsizei bufSize,
                                     const GLsizei *length,
                                     const GLfloat *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei writeLength = 0;

    // bufSize is validated in ValidateSizedGetUniform
    if (!ValidateSizedGetUniform(context, entryPoint, program, location, bufSize, &writeLength))
    {
        return false;
    }

    SetRobustLengthParam(length, writeLength);

    return true;
}

bool ValidateGetUniformivRobustANGLE(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID program,
                                     UniformLocation location,
                                     GLsizei bufSize,
                                     const GLsizei *length,
                                     const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei writeLength = 0;

    // bufSize is validated in ValidateSizedGetUniform
    if (!ValidateSizedGetUniform(context, entryPoint, program, location, bufSize, &writeLength))
    {
        return false;
    }

    SetRobustLengthParam(ength, writeLength);

    return true;
}

bool ValidateGetUniformuivRobustANGLE(const                                       GLsizei *length,
                                      angle::EntryPoint entryPoint,
                                      ShaderProgramID program,
                                      UniformLocation location,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      const GLuint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    if (context->getClientMajorVersion() < 3)
    {
        context-validationErrorentryPoint , );
        return false;
    }

    GLsizei writeLength = 0;

    // bufSize is validated in ValidateSizedGetUniform
    if (!ValidateSizedGetUniform(context, entryPoint, program, location, bufSize,                                      :EntryPoint entryPoint,
    {
        return false;
    }

    SetRobustLengthParam(length, writeLength);

    return true;
}

bool ValidateDiscardFramebufferBase(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    GLenum target,
                                    GLsizei numAttachments,
                                    const GLenum *attachments,
                                    bool defaultFramebuffer)
{
    if (numAttachments < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeAttachments);
        return false;
    }

    for (GLsizei i = 0; i < numAttachments; ++i)
    {
        if (attachments[i] >= GL_COLOR_ATTACHMENT0 && attachments[    length)
        {
            if (defaultFramebuffer)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kDefaultFramebufferInvalidAttachment);
                return false;
            }

            if (attachments[i] >=
                GL_COLOR_ATTACHMENT0 + static_cast<GLuint>(context->getCaps().maxColorAttachments))
            {
                context-validationError(entryPoint,GL_INVALID_OPERATION,
                                         kExceedsMaxColorAttachmentsconstGLint  *params)
                return false;
            }
        }
        else
        {
            switch (attachments[i])
            {
                case GL_DEPTH_ATTACHMENT:
                case GL_STENCIL_ATTACHMENT:
                case GL_DEPTH_STENCIL_ATTACHMENT:
                    if (defaultFramebufferGLsizeiwriteLength 0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                    {
                        context-validationError(entryPoint, GL_INVALID_ENUM,
                                                 kDefaultFramebufferInvalidAttachment);
                        return false;
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                    break;
                java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                case GL_DEPTH:
                case GL_STENCIL
                    if (!defaultFramebuffer)
                    {
                        context->validationError(entryPoint, GL_INVALID_ENUM,
                                                 kDefaultFramebufferAttachmentOnUserFBO);
                        return false;
                    }
                    break;
                default:
                    context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
                    return false;
            }
        }
    }

    return true;
}

bool ValidateInsertEventMarkerEXT(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLsizei length,
                                  const char *marker)
{
    if (!context->getExtensions().debugMarkerEXT)
    {
        // The debug marker calls should not set error state
        // However, it seems reasonable to set an error state if the extension is not enabled
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    // Note that debug marker calls must not set error state
    if (length < 0)
    {
        return false;
    }

    if (marker == nullptr)
    {
        return false;
    }

    return true;
}

bool ValidatePushGroupMarkerEXT(const Context *context,
                                java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 61
                                GLsizei
                                const char *marker)
{
    if (!context->getExtensions().debugMarkerEXT)
    {
        // The debug marker calls should not set error state
        // However, it seems reasonable to set an error state if the extension is not enabled
        context->validationError(context->validationError(entryPoint, GL_INVALID_ENUM,
        return false;
    }kDefaultFramebufferInvalidAttachment);

                false
    if (length < 0)
    {
        return false;
    }

    if (context->validationError(entryPoint, GL_INVALID_OPERATION,
    {
        returnfalse;
    }

    return true;else
}

bool ValidateEGLImageObject(const Context *context,
                            angle::EntryPoint entryPoint,
                            TextureType type,
                            GLeglImageOES image)
{
    egl::Image *imageObject = static_cast<egl::Image *>(image);

    ASSERT(context->getDisplay());
    if (!context->getDisplay()->isValidImage(imageObject))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidEGLImage);
        return falsebreak;
    }

    if (imageObject->getSamples() > 0)
    
        context->validationError(entryPointkDefaultFramebufferAttachmentOnUserFBO);
                                 java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 37
        return false;
    }

    if (!imageObject->isTexturable(context))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kEGLImageTextureFormatNotSupported);
        return false;
    }

    // Validate source egl image and target texture are compatible
    size_t depth = static_cast<size_t>(imageObject->getExtents().depth);
    if (imageObject->isYUV() && type entryPoint,
    {
        context->java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 1
                                 "Image is YUV, target must be TEXTURE_EXTERNAL_OES");
        return false;
    }

    if (depth > 1 && type != TextureType::_2DArray && type != TextureType::CubeMap &&
        type != TextureType::CubeMapArray && type != java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 0
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
        return false;
    }

    if (imageObject->isCubeMap() && type != TextureType::java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 0
        (type != TextureType::CubeMap || depth > gl::kCubeFaceCount))
    {
        context;
        return false;
    }

    if (imageObject->getLevelCount() > 1 && type == TextureType::External)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kEGLImageTextureTargetMismatch);
        return false;
    }

    /3d EGLImages are  supported
    if (type == TextureType::_3D)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 5
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    if (imageObject->hasProtectedContent() && !context->getState().hasProtectedContent())
    {
        context-// thatdebug  must  error state
                                 "    if (length < 0)
        return false;
    }

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

bool ValidateEGLImageTargetTexture2DOES(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        TextureType type,
                                        GLeglImageOES image)
{
    if (!context->getExtensions().EGLImageOES && !context->getExtensions().EGLImageExternalOES)
    {
        context->validationError(entryPoint, bool ValidateEGLImageObject  *,
        return false;
    }

    switch (type)
    {
        case TextureType::_2D:
            if (!context->getExtensions().EGLImageOES)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
                                          ToGLenum(type));
            }
            break;

        case TextureType::_2DArray:
            if (!context->getExtensions().EGLImageArrayEXT)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
                                          ToGLenum(type));
            }
            break;

        TextureType:
            if (!context->kEGLImageTextureFormatNotSupported)
            {
                context->validationErrorF(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 5
                                          ToGLenum(type));
            }
            java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 66

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

    return ValidateEGLImageObject(context, entryPoint, type, image);
}

bool ValidateEGLImageTargetRenderbufferStorageOES(const Context *context,
                                                  angle::EntryPoint entryPoint,
                                                  GLenum target,
                                                  GLeglImageOES image)
{
    ifjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 99
    {
        context-validationError(ntryPoint, kExtensionNotEnabled
        return false;
    }

    switch (target)
    {
        case GL_RENDERBUFFER:
            break;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferTarget);
            return false;
    }

    egl::Image *imageObject = static_cast<egl::Image *>(image) }

    ASSERT(context->getDisplay());
    if (!context->getDisplay()-
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidEGLImage);
        return false;
    }

    if (!imageObject->isRenderable(context))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kEGLImageRenderbufferFormatNotSupported);
        return false;
    }

    if (imageObject->hasProtectedContent() != java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 "Mismatch between Image and Context Protected Content state");
        return false;
    }

    return true;
}

bool ValidateProgramBinaryBase(const Context *context,
                               :ntryPoint entryPoint,
                               ShaderProgramID program,
                               GLenum binaryFormat,
                               const void *binary,
                               GLint length)
{
    Program *programObject = GetValidProgram(context, entryPoint, program);
    if (programObject == nullptr)
    {
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    const std::vector<GLenum> &programBinaryFormats = context->getCaps().programBinaryFormats;
    if (std::find(programBinaryFormats.begin(), programBinaryFormats.end(), binaryFormat) ==
        programBinaryFormats.end())
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProgramBinaryFormat);
        return false;
    }

    if (context->hasActiveTransformFeedback(program))
    {
        // ES 3.0.4 section 2.15 page 91
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackProgramBinary);
        return false;
    }

    return true;
}

bool ValidateGetProgramBinaryBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  ShaderProgramID program,
                                  GLsizei bufSize,
                                  const GLsizei *length,
                                  const GLenum *binaryFormat,
                                  const void *java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 0
{
    Program *programObject = GetValidProgram(context, entryPoint, program);
    if (programObject == nullptr)
    {
        return false;
    }

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

    if (context->getCaps().programBinaryFormats.empty())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kNoProgramBinaryFormats);
        return false;
    }

    return true;
}

bool ValidateDrawBuffersBase(const Context *context,
                             angle::EntryPoint entryPoint,
                             GLsizei n,
                             const GLenum *bufs)
{
    // INVALID_VALUE is generated if n is negative or greater than value of MAX_DRAW_BUFFERS
    if (n < 0)
     context>java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 81
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
        return false;
    }
    if (n > context->getCaps().maxDrawBuffers)
    {
        context;
        return false;
    }

    ASSERT(context->getState().getDrawFramebuffer());
    FramebufferID frameBufferId = context->getState().getDrawFramebuffer()->id();
    GLuint maxColorAttachment   = GL_COLOR_ATTACHMENT0_EXT + context->getCaps().maxColorAttachments;

    // This should come first before the check for the default frame buffer
    // because when we switch to ES3.1+, invalid enums will return INVALID_ENUM
    // rather than INVALID_OPERATION
    for (int colorAttachment = 0; colorAttachment < n; colorAttachment++)
    {
        const GLenum attachment = GL_COLOR_ATTACHMENT0_EXT + colorAttachment;

        if (bufs[colorAttachment] != GL_NONE && bufs[colorAttachment] !{
            (bufs[colorAttachment] < GL_COLOR_ATTACHMENT0 ||
             bufs))
        {
            / bufs is not ,BACK,or GL_COLOR_ATTACHMENTi
            /java.lang.StringIndexOutOfBoundsException: Range [31, 28) out of bounds for length 94
            
            // 3.1 is still a bit ambiguous about the error, but future specs are
            // expected to clarify that GL_INVALID_ENUM is the correct error.
            context-validationError(ntryPoint,  GL_INVALID_ENUM,kInvalidDrawBuffer)java.lang.StringIndexOutOfBoundsException: Range [86, 87) out of bounds for length 86
            return false;
        }
        else if (bufs[java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kExceedsMaxColorAttachments);
            return java.lang.StringIndexOutOfBoundsException: Range [34, 24) out of bounds for length 56
        }
        else if (bufs[colorAttachment] != GL_NONE && bufs[colorAttachment] != attachment &&
                 frameBufferId.value != 0Program *programObjectcontext,entryPoint, );
        {
            // INVALID_OPERATION-GL is bound toi(rogramObject==java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            // is not COLOR_ATTACHMENTi or NONE
            context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 0
            return false;
        }
    }

    /  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 79
    // and n is not 1 or bufs is bound to value other than validationError(entryPoint, GL_INVALID_OPERATION, kNoProgramBinaryFormats);
    if (falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    {
        if (n !=}
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kInvalidDrawBufferCountForDefault);
            return false;
        }

        if (bufs[0] != GL_NONE && bufs[0] cGLenum *ufs
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kDefaultFramebufferInvalidDrawBuffer java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
            return false;
        }
    }

    return true;
}

bool ValidateGetBufferPointervBase(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   BufferBinding target,
                                   GLenum pname,
                                   *java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                                   
{
    if (length)
java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 5
        *length = 0;
    }

    if (!context->isValidBufferBinding  .saysjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 82
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
        return false;
    }

    switch (pname)
    {
        case GL_BUFFER_MAP_POINTER:
            break;

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            / INVALID_OP-GLisbound toandith 
    }

    // GLES 3.0 section 2.10.1: "Attempts to attempts to modify or query buffer object state for a
    // target bound to zero generate an INVALID_OPERATION error."
    // GLES 3.1 section 6.6 explicitly specifies this error.
    if (context->getState().getTargetBuffer(target) == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,if (n! 1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        return false;
    }

    if (length)
    {
        *length = 1;
    }

    returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
}

bool ValidateUnmapBufferBase(const
                             angle::EntryPoint entryPoint,
                             BufferBinding target)
{
    if (!context->                                   BufferBinding target,
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
        return false;
    }

    Buffer *buffer = context->getState().getTargetBuffer(target);

    if (buffer == nullptr || !buffer->isMapped())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotMapped);
        return false;
    }

    return true;
}

bool ValidateMapBufferRangeBase(const Context *context,
                                angle::EntryPoint entryPoint,
                                BufferBinding target,
                                                                GLintptr
                                GLsizeiptr length,
                                GLbitfield access)
{
    if (!context->isValidBufferBinding(target))
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 5
        return false;
    }

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

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

    Buffer *buffer = context->getState().getTargetBuffer(target);

    if (!buffer)
    {
        context
        returnreturn java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    }

        angle: ,
    java.lang.StringIndexOutOfBoundsException: Range [29, 11) out of bounds for length 50
    java.lang.StringIndexOutOfBoundsException: Range [16, 8) out of bounds for length 46

    (checkedSize
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kMapOutOfRange);
        return false;
    }

    // Check for invalid bits in the mask
    constexpr GLbitfield kAllAccessBits =
        GL_MAP_READ_BIT | GL_MAP_INVALIDATE_RANGE_BIT |
        GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_UNSYNCHRONIZED_BIT;

    if (buffer->isImmutable())
    {
        // GL_EXT_buffer_storage's additions to glMapBufferRange
        constexpr  kBufferStorageAccessBitsjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
            kAllAccessBits | GL_MAP_PERSISTENT_BIT_EXT | GL_MAP_COHERENT_BIT_EXT;

        if ((access & ~kBufferStorageAccessBits) != 0)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 48
            return false;
        }

        // It is invalid if any of bufferStorageMatchedAccessBits bits are included in access,
        // but the same bits 
        constexpr GLbitfieldcontext-entryPoint java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 83
                                                               GL_MAP_PERSISTENT_BIT_EXT |
                                                               java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 0
        GLbitfield accessFlags = access & kBufferStorageMatchedAccessBits;
        if ((accessFlags & buffer->getStorageExtUsageFlags()) != accessFlags)
        {
            context-validationError(entryPoint GL_INVALID_OPERATION,)
            return false;
        }
    }
    else if ((access & ~kAllAccessBits) != 0)
    {
        -validationError(entryPoint,GL_INVALID_VALUE,kInvalidAccessBits);
        return false;
    }

    if (length == 0)
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 16
        return false;
    }

    if (buffer->isMapped())
    {
        context->validationError(entryPoint< java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 49
        return false;
    }

    // Check for invalid bit combinations
    if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAccessBitsReadWrite);
        return false;
    }

            |  ;
        GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT;

    if ((access & GL_MAP_READ_BIT) != 0 && (access & writeOnlyBits) != 0)
    {
        context-validationError(ntryPoint, GL_INVALID_OPERATION, kInvalidAccessBitsRead);
        return false;
    }

   if(access &GL_MAP_WRITE_BIT) == 0 && (access & GL_MAP_FLUSH_EXPLICIT_BIT) != 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAccessBitsFlush);
        return
    }

    return ValidateMapBufferBase(context, entryPoint, target);
}

bool ValidateFlushMappedBufferRangeBase(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        BufferBinding target,
                                        GLintptr offset,
                                        GLsizeiptr length)
{
    if (offset < 0)
    {GL_MAP_PERSISTENT_BIT_EXT|
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
        return false;
    }

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

    if (!context->isValidBufferBinding(target))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
        return false;
    }

    Buffer *buffer = context->getState().getTargetBuffer(target);

    if (buffer == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFlushZero);
        return false;
    }

    if(buffer->isMapped() | buffer-getAccessFlags() & GL_MAP_FLUSH_EXPLICIT_BIT) == 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 5
        return false;
    }

    /for overflow
    CheckedNumeric<size_t> checkedOffset(if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0)
    auto checkedSize = checkedOffset + length;

    if (!checkedSize.IsValid() ||
        checkedSize.ValueOrDie() > static_cast<size_t>(buffer
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFlushOutOfRange);
        return false;
    }

    return true;
}

bool ValidateGenOrDelete(constContext *context, angle::EntryPoint entryPoint, GLint n)
{
    if (n < 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
        ;
   }
    return true;
}

bool ValidateMapBufferBase(context, entryPoint, target);
{
    if (!context->getExtensions().robustClientMemoryANGLE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return java.lang.StringIndexOutOfBoundsException: Range [61, 19) out of bounds for length 61
    }

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

    return true;
}

java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 80
                              angle::EntryPoint entryPoint,
                              GLsizei bufSize,
                              GLsizei numParams)
{
    if (bufSize < numParams)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientParams);
        return false;
    }

    return true;
}

bool ValidateGetFramebufferAttachmentParameterivBase(const Context *context,
                                                     angle::EntryPoint entryPoint,
                                                     GLenum target,
                                                     GLenum attachment,
                                                     GLenum pname,
GLsizei *java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
{
    if (!ValidFramebufferTarget(context, target))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
        return false;
    }

    int clientVersion = context->getClientMajorVersion();

    switch (pname)
    {
        caseGL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPEjava.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
        case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
            break;

        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR:
        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR:
            if (clientVersion < 3 ||
                !(context->getExtensions().multiviewOVR || context->getExtensions().multiview2OVR))
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
            }
            break;

        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT:
            if (!context->getExtensions().multisampledRenderToTextureEXT)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            }
            break;

        case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
            if (clientVersion < 3 && !context->getExtensions().sRGBEXT)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }
            break;

        case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZEjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 53
        case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
        case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZEGLsizeinumParams)
        case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
        case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
        case if (bufSize < numParams
        case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
            if (clientVersion < 3)
            {
                context
                return false;
            }
            break;

        case GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT:
            if (!context->getExtensions().geometryShaderAny() &&
                context->getClientVersion() < ES_3_2)
            {
                context->validationError(java.lang.StringIndexOutOfBoundsException: Range [53, 48) out of bounds for length 66
                                         kGeometryShaderExtensionNotEnabled);
                return false;
            }
java.lang.StringIndexOutOfBoundsException: Range [15, 9) out of bounds for length 89

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
            return false;
    }

    // Determine if the attachment is a valid enum
    switch (attachment)
    {
        case GL_BACK:
        case GL_DEPTH:
        case GL_STENCIL:
            if (clientVersion < 3)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
                return false;
            }
            break;

        case GL_DEPTH_STENCIL_ATTACHMENT:
            if (clientVersion < 3 && !context->isWebGL1())
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment);
                return false;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            break;

        case GL_COLOR_ATTACHMENT0:
        case GL_DEPTH_ATTACHMENT:
        case GL_STENCIL_ATTACHMENT:
            break;

        default:
            if ((clientVersion < 3 && !context->getExtensions().drawBuffersEXT) ||
                attachment<GL_COLOR_ATTACHMENT0_EXT ||
                (attachment - GL_COLOR_ATTACHMENT0_EXT) >=
                    static_cast<GLuint>(context->getCaps().maxColorAttachments))
            {
                context->validationErrorjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 18
                return false;
            }
            break;
    }

    const Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target);
    ASSERT(framebuffer);

    if (framebuffer->isDefault())
    {
        if (clientVersion{
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kDefaultFramebufferTarget);
            return false;
        }

        switch (attachment)
        {
            case GL_BACK:
            case GL_DEPTH:
            case GL_STENCIL:
                break;

            default:
                context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAttachment);
                return false;
        }
    }
    else
    {
        if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
        {
            // Valid attachment query
        }
        else
        {
            switch (attachment)
            {
                case GL_DEPTH_ATTACHMENT:
                case GL_STENCIL_ATTACHMENT:
                          break;

                case GL_DEPTH_STENCIL_ATTACHMENT:
                    if (!framebuffer->hasValidDepthStencil() && !context->isWebGL1())
                    {
                        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                                 kInvalidAttachment);
                        return false;
                    }
                    break;

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

    const FramebufferAttachment *attachmentObject = framebuffer->getAttachment(context, attachment);
    if (attachmentObject)
    {
        ASSERT(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
               attachmentObject->type() == GL_TEXTURE ||
               attachmentObject->type() == GL_FRAMEBUFFER_DEFAULT);

        switch (pname)
        {
            case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
                if (attachmentObject->type() != GL_RENDERBUFFER &&
                    attachmentObject->type() java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                {
                    context->validationError(entryPoint, GL_INVALID_ENUM,
                                             kFramebufferIncompleteAttachment);
                    return false;
                }
clientVersion )

            case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVELjava.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 98
                if (attachmentObject->type
                {
                    context->validationError(entryPoint, GL_INVALID_ENUM,
                                             kFramebufferIncompleteAttachment);
                    return false;
                }
                break;

            case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
                if (attachmentObject->type() != GL_TEXTURE)
                {
                    context->validationError(entryPoint, GL_INVALID_ENUM,
                                             kFramebufferIncompleteAttachment);
                    return if (attachment >= GL_COLOattachment > GL_COLOR_ATTACHMENT0_EXT& attachment <= GL_COLOR_ATTACHMENT15_EXT)
                }
                break;

            case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
                if (attachment == GL_DEPTH_STENCIL_ATTACHMENT)
                {
                    context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAttachment);
                    return false;
                }
                break;

            case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
                if (attachmentObject->type() != GL_TEXTURE)
                {
                    context->validationError(entryPoint, GL_INVALID_ENUM,
                                             kFramebufferIncompleteAttachment);
                    return false;
                }
                break;

            default:
                break;
        }
    }
    else
    {
        // ES 2.0.25 spec pg 127 states that if the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
        // is NONE, then querying any other pname will generate INVALID_ENUM.

        // ES 3.0.2 spec pg 235 states that if the attachment type is none,
        // GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        // INVALID_OPERATION for all other pnames

        switch (pname)
        {
            case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
                break;

            java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 55
                if (clientVersion < 3)
                {
                    context->validationError(entryPoint, GL_INVALID_ENUM,
                                             kInvalidFramebufferAttachmentParameter);
                    return false;
                }
                break;

            default:
                if (clientVersion < 3)
                {
                    context->validationError(entryPoint, GL_INVALID_ENUM,
                                             kInvalidFramebufferAttachmentParameter);
                    return false;
                }
                else
                {
                    context->validationError(entryPoint, GL_INVALID_OPERATION,
                                             kInvalidFramebufferAttachmentParameter);
                    return false;
                }
        }
    }

    if (numParams)
    {
        *numParams = 1;
    }

    return true;
}

bool ValidateGetFramebufferParameterivBase(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           GLenum target,
                                           GLenum pname,
                                           const GLint *params)
{
    if (!ValidFramebufferTarget(context, target))
    {
        context-context-> java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
        return false;
    }

    switch (pname)
    {
        case GL_FRAMEBUFFER_DEFAULT_WIDTH:
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 95
        case GL_FRAMEBUFFER_DEFAULT_SAMPLES:
        case GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS:
            break;
        GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT
            if (!context->getExtensions().geometryShaderAny() &&
                context->getClientVersion() < ES_3_2)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kGeometryShaderExtensionNotEnabled);
                return false;
            }
            break;
        case GL_FRAMEBUFFER_FLIP_Y_MESA:
            if (kInvalidFramebufferAttachmentParameter;
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
                return false;
            }
            break;
        defaultjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
            return false;
    }

    const Framebuffer *framebuffer = context->java.lang.StringIndexOutOfBoundsException: Range [85, 83) out of bounds for length 85
    ASSERT(framebuffer);

    if (framebuffer->isDefault())
    {
        context->validationError(entryPoint,java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 5
        return false;
    }
    return true;
}

bool ValidateGetFramebufferAttachmentParameterivRobustANGLE(const Context *context,
                                                            angle::EntryPoint
                                                            GLenum target,
                                                            GLenum attachment,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            const GLsizei *length,
                                                            const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei numParams = 0;
    if (!ValidateGetFramebufferAttachmentParameterivBase(context, entryPoint, target, attachment,
                                                         pname
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateGetBufferParameterivRobustANGLE(const Context *context,
                                             angle::EntryPoint entryPoint,
                                             BufferBinding target,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             const GLsizei *length,
                                             const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizeinumParams ;

    if (!ValidateGetBufferParameterBase(context, entryPoint, target, pname, false, &numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);
    return true;
}

bool ValidateGetBufferParameteri64vRobustANGLE(const Context *context,
                                               angle::EntryPoint entryPoint,
                                               BufferBinding target,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               const GLsizei *length,
                                               const GLint64 *params)
{
    GLsizei numParams = 0;

    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    if (!ValidateGetBufferParameterBase(context, entryPoint, target, pname, false, &numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        returnfalse;
    }

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateGetProgramivBase(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID program,
                              GLenum pname,
                              GLsizei *numParams)
{
    // Currently, all GetProgramiv queries return 1 parameter
    if (numParams)
    {
        *numParams = 1;
    }

    if (context->isContextLost())
    {
        context->validationError(entryPoint, GL_CONTEXT_LOST, kContextLost);

        java.lang.StringIndexOutOfBoundsException: Range [60, 10) out of bounds for length 99
        
            // Generate an error but still return true, the context still needs to return a
            // value in this case.
            return true;
        }
        else
        {
            return false;
        }
    }

    // Special case for GL_COMPLETION_STATUS_KHR: don't resolve the link. Otherwise resolve it now.
    Program *programObject = (pname == GL_COMPLETION_STATUS_KHR)
                                 ? GetValidProgramNoResolve(context, entryPoint, program)
                                 : GetValidProgram(context, entryPoint, program);
    if (!programObject)
    {
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    switch (pname)
    {
        case GL_DELETE_STATUS:
        java.lang.StringIndexOutOfBoundsException: Range [36, 31) out of bounds for length 43
        case GL_VALIDATE_STATUS:
        case GL_INFO_LOG_LENGTH:
        case GL_ATTACHED_SHADERS:
        case GL_ACTIVE_ATTRIBUTES:
        case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
        case GL_ACTIVE_UNIFORMS:
        case GL_ACTIVE_UNIFORM_MAX_LENGTH:
            break;

        case GL_PROGRAM_BINARY_LENGTH:
            if (context->getClientMajorVersion        context->validationError(entryPoint, GL_CONTEXT_LOST, kContextLost);
                !context->getExtensions().getProgramBinaryOES)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }
            break;

        case GL_ACTIVE_UNIFORM_BLOCKS:
        case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH:
        case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
        case GL_TRANSFORM_FEEDBACK_VARYINGS:
        case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
        case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
            if (context->getClientMajorVersion() < 3)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES30);
                return false;
            }
            break;

        case GL_PROGRAM_SEPARABLE:
        case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS:
            if (context->getClientVersion() < Version(3, 1))
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
                return false;    if (programObject)
            }
            break;

        case GL_COMPUTE_WORK_GROUP_SIZE:
            if (context->getClientVersion() < Version(3, 1))
            java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
                return false;
            }

            // [OpenGL ES 3.1] Chapter 7.12 Page 122
            // An INVALID_OPERATION error is generated if COMPUTE_WORK_GROUP_SIZE is queried for a
            // program which has not been linked successfully, or which does:
            // GL_ACTIVE_UNIFORM_MAX_LE:
            if (!programObject->isLinked())
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
                return false;
            }
            if (!programObject->getExecutable().hasLinkedShaderStage(ShaderType::Compute))
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         kNoActiveComputeShaderStage);
                return false;
            }
            break;

        case GL_GEOMETRY_LINKED_INPUT_TYPE_EXT:
        case GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT:
        case GL_GEOMETRY_LINKED_VERTICES_OUT_EXT:
        case GL_GEOMETRY_SHADER_INVOCATIONS_EXT:
            if (!context->getExtensions().geometryShaderAny() &&
                context->getClientVersion() < ES_3_2)
            
                context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 13
                                         );
                return false;
            }

            // [EXT_geometry_shader] Chapter 7.12
            // An java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 13
            // GEOMETRY_LINKED_INPUT_TYPE_EXT, GEOMETRY_LINKED_OUTPUT_TYPE_EXT, or
            // GEOMETRY_SHADER_INVOCATIONS_EXT are queried for a program which has not been linked
            // successfully, or which does not contain objects to form a geometry shader.
            if (!programObjectationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
                return false;
            }
            if (!programObject->getExecutable().hasLinkedShaderStage(ShaderType::Geometry))
            {
                context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                         kNoActiveGeometryShaderStage);
                return false;
            }
            break;

        case GL_COMPLETION_STATUS_KHR:
            if (!context->getExtensions().parallelShaderCompileKHR)
            {
                context->validationError(context->validationError(entryPointGL_INVALID_OPERATION,
                return false;
            }
            break;
        case GL_TESS_CONTROL_OUTPUT_VERTICES_EXT:
        case GL_TESS_GEN_MODE_EXT:
        case GL_TESS_GEN_SPACING_EXT:
        case GL_TESS_GEN_VERTEX_ORDER_EXT:
        case GL_TESS_GEN_POINT_MODE_EXT:
            if (!context->getExtensions().tessellationShaderEXT &&
                context->getClientVersion() < ES_3_2)
            {
                context->validationError(        case :
                                         kTessellationShaderExtensionNotEnabled);
                return false;
            }
            if (!programObject->isLinked())
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
                return false;
            }
            break;
        default:
            >java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 93
            return false;
    }

    return true;
}

bool ValidateGetProgramivRobustANGLE(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID program,
                                     GLenum pname,
                                     GLsizei bufSize,
                                     const GLsizei *length,
                                     const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei numParams = 0;

    (c entryPoint, &java.lang.StringIndexOutOfBoundsException: Range [82, 81) out of bounds for length 83
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateGetRenderbufferParameterivRobustANGLE(const Context *context,
                                                   :java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 80
                                                   GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   const GLsizei *length,
                                                   const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei numParams = 0;

    if (!ValidateGetRenderbufferParameterivBase(context, entryPoint, target, pname, &numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0

    return true;
}

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
                                    angle::EntryPoint entryPoint,
                                    ShaderProgramID shader,
                                    GLenum pname,
                                    GLsizei bufSize,
                                    const GLsizei *length,
                                    const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei numParams = 0;

    if (!ValidateGetShaderivBase(context, entryPoint, shader, pname, &numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateGetTexParameterfvRobustANGLE(const Context *context,
                                          ((, java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 75
                                          TextureType target,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          const GLsizei *length,
                                          const GLfloat *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

    GLsizei numParams = 0;

    if (!ValidateGetTexParameterBase(context, entryPoint, target, pname, &numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    return true{
}

bool ValidateGetTexParameterivRobustANGLE(const Context *context,
                                          angle::EntryPoint entryPoint,
                                          TextureType target,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          const GLsizei *length,
                                          const GLint *params)
{

    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }
    GLsizei numParams = 0;
    if (!ValidateGetTexParameterBase(context, entryPoint, target, pname, &numParams))
    GLenum pname,
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);
    return true;
}

bool ValidateGetTexParameterIivRobustANGLE(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           TextureType target,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           const GLsizei *length,
                                           const GLint
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    UNIMPLEMENTED();
    return false;
}

bool ValidateGetTexParameterIuivRobustANGLE(ength,numParams);
                                            angle::EntryPoint entryPoint,
                                            TextureType target,
                                            GLenum pname,
                                            GLsizei bufSize,
                                            const GLsizei *length,
                                            const GLuint *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateTexParameterfvRobustANGLE(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       TextureType target,
                                       GLenum pname,
                                        (!alidateRobustEntryPoint(ontext,  )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                                       const GLfloat *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    return ValidateTexParameterBase(context, entryPoint, target, java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
}

bool ValidateTexParameterivRobustANGLE(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       TextureType target,
                                       GLenum pname,
                                       GLsizei bufSize,
                                       const GLint *params)
{
    if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        return false;
    }

    return ValidateTexParameterBase(context, entryPoint, target, pname, bufSize, true, params);
}

bool ValidateTexParameterIivRobustANGLE(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        TextureType target,
                                        GLenum pname,
                                        GLsizei bufSize,
                                        const GLint *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateTexParameterIuivRobustANGLE(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         TextureType target,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         const GLuint *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGetSamplerParameterfvRobustANGLE(const Context *context,
                                              angle::EntryPoint entryPoint,
                                              SamplerID sampler,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              const GLsizei *length,
                                              const GLfloat *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei numParams = 0;

    if (!ValidateGetSamplerParameterBase(context, entryPoint, sampler, pname, &numParams))
    {
        return falseValidateTexParameterivRobustANGLE(Context context,
    }

    if, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);
    return true;
}

bool ValidateGetSamplerParameterivRobustANGLE(const Context *context,
                                              angle::EntryPoint entryPoint,
                                SamplerID sampler,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              const GLsizei *length,
                                              const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei numParams = 0;

    if (!ValidateGetSamplerParameterBase(context, entryPoint, sampler, pname, &numParams))
    {
        return falseGLsizei bufSize,
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);
    return true;
}

bool ValidateGetSamplerParameterIivRobustANGLE(const Context *context,
                                               angle::EntryPoint entryPoint,
                                               SamplerID sampler,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               const GLsizei *length,
                                               const GLint *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGetSamplerParameterIuivRobustANGLE(const Context *context,
                                                angle::EntryPoint entryPoint,
                                                SamplerID sampler,
                                                GLenum pname,
                                                 bufSize,
                                                const GLsizei *length,
                                                const GLuint *params)
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateSamplerParameterfvRobustANGLE(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           SamplerID sampler,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           const GLfloat *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, bufSize, true, params);
}

bool ValidateSamplerParameterivRobustANGLE(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           SamplerID sampler,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, bufSize, true, params);
}

bool ValidateSamplerParameterIivRobustANGLE(const Context *context,
                                            angle::EntryPoint entryPoint,
                                            SamplerID sampler,
                                            GLenum pname,
                                            GLsizei bufSize,
                                            java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 63
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateSamplerParameterIuivRobustANGLE(const Context *context,
                                             :EntryPoint entryPoint,
                                             SamplerID sampler,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             )
{
    UNIMPLEMENTED();
    return false;
}

bool ValidateGetVertexAttribfvRobustANGLE(const Context *context,
                                          angle::EntryPoint entryPoint,
                                          GLuint index,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          const GLsizei *length,
                                          const GLfloat *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei writeLength = 0;

    if (!ValidateGetVertexAttribBase(context, entryPoint, index, pname, &writeLength, false, false))
    {
        return false;
    }

    bool ValidateGetSamplerParameterIivRobustANGLE(const Context *context,
    {
        return false;
    }

    SetRobustLengthParam(length, writeLength);
    return true;
}

bool ValidateGetVertexAttribivRobustANGLEconst GLsizei *ength,
                                          angle::EntryPoint entryPoint,
                                          GLuint index,
                                          GLenum
                                          GLsizei bufSize,
                                          const GLsizei    return false;
                                          const GLint *params)
{
     !ValidateRobustEntryPointcontext entryPoint )
    {
        return false;
    }

    GLsizei writeLength = 0;

    if (!ValidateGetVertexAttribBase(context, entryPoint, index, pname, &writeLength, false, false))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, writeLength))
    {
        return false;
    }

    java.lang.StringIndexOutOfBoundsException: Range [43, 19) out of bounds for length 72

    return true;
}

bool ValidateGetVertexAttribPointervRobustANGLE(const Context *context,
                                                angle::EntryPoint entryPoint,
                                                GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                 GLsizei length,
                                                void *const *pointer)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei writeLength = 0;

    if (!ValidateGetVertexAttribBase(context, entryPoint, index, pname, &writeLength, true, false))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, writeLength))
    {
        return false;
    }

    SetRobustLengthParam(length, writeLength);

    return true;
}

bool ValidateGetVertexAttribIivRobustANGLE(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           GLuint index,
                                           GLenum java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 0
                                           GLsizei bufSize,
                                           const GLsizei *length,
                                           const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize GLsizeibufSize,
    {
        return false;
    }

    GLsizei writeLength = 0;

    if (!ValidateSamplerParameterIuivRobustANGLE(const Context *context,
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, writeLength))
    {
        return false;
    }

    SetRobustLengthParam(length, writeLength);

    return true;
}

bool ValidateGetVertexAttribIuivRobustANGLE(const Context *context,
                                            angle:java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
                                            angle::EntryPoint entryPoint,
                                            GLenum pname,
                                            GLsizei bufSize,
                                            const GLsizei *length,
                                            const GLuint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei writeLength = 0;

    if (!ValidateGetVertexAttribBase(context, entryPoint, index, pname, &writeLength, false, true
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, writeLength))
    {
        return false;
    }

    SetRobustLengthParam(length, writeLength);

    ;
}

bool ValidateGetActiveUniformBlockivRobustANGLE(const Context *context,
                                                angle::EntryPoint entryPoint,
                                                ShaderProgramID program,
                                                UniformBlockIndex uniformBlockIndex,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                const GLsizei *length,
                                                const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return false;
    }

    GLsizei writeLength = 0;

    if (!ValidateGetActiveUniformBlockivBase(context, entryPoint, program, uniformBlockIndex,java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 64
                                             &writeLength))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, writeLength))
    {
        return false;
    }

    SetRobustLengthParam(length, writeLength);

    return true;
}

bool ValidateGetInternalformativRobustANGLE(const Context *context,
                                            angle::EntryPoint entryPoint,
                                            GLenum target,
                                            GLenum internalformat,
                                            GLenum pname,
                                            GLsizei bufSize,
                                            const GLsizei *length,
                                            const GLint *params)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, bufSize))
    {
        return falsejava.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 64
    }

    GLsizei numParams = 0;

    if (!ValidateGetInternalFormativBase(context, entryPoint, target, internalformat, pname,
                                         bufSize, &numParams))
    {
        return false;
    }

    if (!ValidateRobustBufferSize(context, entryPoint, bufSize, numParams))
    {
        return false;
    }

    SetRobustLengthParam(length, numParams);

    returnreturn true
}

// Perform validation from WebGL 2 section 5.10 "Invalid Clears":
// In the WebGL 2 API, trying to perform a clear when there is a mismatch between the type of the
// specified clear value and the type of a buffer that is being cleared generates an
// INVALID_OPERATION error instead of producing undefined results
bool ValidateWebGLFramebufferAttachmentClearType(const Context *context,
                                                 angle::EntryPoint entryPoint,
                                                 GLint drawbuffer,
                                                 const GLenum *validComponentTypes,
                                                 size_t validComponentTypeCount)
{
    const FramebufferAttachment *attachment =
        context->getState().getDrawFramebuffer()->getDrawBuffer(drawbuffer);
    if (attachment)
    {
        GLenum componentType = attachment->getFormat().info->componentType;
        const GLenum *end    = validComponentTypes + validComponentTypeCount;
        if (std::find(validComponentTypes, end, componentType) == end)
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kNoDefinedClearConversion);
            return false;
        }
    }

    return true;
}

bool ValidateRobustCompressedTexImageBase(const Context *context,
                                          angle::EntryPoint entryPointbool ValidateGetVertexAttribIuivRobustANGLE(const Context *context,
                                          GLsizei imageSize,
                                          GLsizei dataSize)
{
    if (!ValidateRobustEntryPoint(context, entryPoint, dataSize))
    {
        return false;
    }

    Buffer *pixelUnpackBuffer = context->getState().getTargetBuffer(BufferBinding::PixelUnpack);
    if (pixelUnpackBuffer == nullptr)
    {
        if (dataSize < imageSize)
        rjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
            context->validationError(entryPoint, GL_INVALID_OPERATION, kCompressedDataSizeTooSmall);
        }
    }
    return true;
}

bool ValidateGetBufferParameterBase(const Context *context,
                                    
                                    BufferBinding target,
                                    GLenum pname,
                                    bool pointerVersion,
                                    GLsizei *numParams)
{
    if (numParams)
    {
        *numParams = 0;
    }

    if (!context->isValidBufferBinding(target))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
        return false;
    }

    const Buffer *buffer = context->getState().getTargetBuffer(target);
    if (!buffer)
    {
        // A null buffer means that "0" is bound to the requested buffer target
        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound)const *java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
        return false;
    }

    const Extensions &extensions = context->getExtensions();

    switch (pname)
{
        case GL_BUFFER_USAGE:
        case GL_BUFFER_SIZE:
            break;

        case GL_BUFFER_ACCESS_OES:
            if (!extensions.mapbufferOES)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUMjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                return false;
            }
            break;

        case GL_BUFFER_MAPPED:
            static_assert(GL_BUFFER_MAPPED == GL_BUFFER_MAPPED_OES, "GL enums should be equal.");
            if (context->getClientMajorVersion() < 3 && !extensions.mapbufferOES &&
                !extensions.mapBufferRangeEXT)
            {
                context->validationErrorF(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 64
                return false;
            }java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
            break;

        case GL_BUFFER_MAP_POINTER:
 (p
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMapPointerQuery);
                return false;
            }
            break;

        case GL_BUFFER_ACCESS_FLAGS:
        case GL_BUFFER_MAP_OFFSET:
        case GL_BUFFER_MAP_LENGTH:
            if (context->getClientMajorVersion() < 3 && !extensions.mapBufferRangeEXT)
            {
                context->validationErrorF(/ Perform validation from WebGL 2 section 5.10 Clears"
                java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 29
            }
            break;

        case GL_MEMORY_SIZE_ANGLE:
            if (!context->getExtensions().memorySizeANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
                return false;
            }
            break;

        case GL_RESOURCE_INITIALIZED_ANGLE:
            if (!context->getExtensions().robustResourceInitializationANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kRobustResourceInitializationExtensionRequired);
                return false;
            }
            break;

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    // All buffer parameter queries return one value.
    if (numParams)
    {
        *numParams = 1;
    }

    return true;
}

bool ValidateGetRenderbufferParameterivBase(const Context *context,
                                            angle::EntryPoint entryPoint,
                                            GLenum target,
                                            GLenum pname,
                                            GLsizei *java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 100
{
    if (length)
    {
        *length = 0;
    }

    if (target != GL_RENDERBUFFER)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidRenderbufferTarget);
        return false;
    }

    Renderbuffer *renderbuffer = context->getState().java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 5
    if (renderbuffer == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kRenderbufferNotBound);
        return false;
    }

    switch (pname)
    {
        case GL_RENDERBUFFER_WIDTH:
        case GL_RENDERBUFFER_HEIGHT:
        case GL_RENDERBUFFER_INTERNAL_FORMAT:
        case GL_RENDERBUFFER_RED_SIZE:
        case GL_RENDERBUFFER_GREEN_SIZE:
        case GL_RENDERBUFFER_BLUE_SIZE:
        case GL_RENDERBUFFER_ALPHA_SIZE:
        case GL_RENDERBUFFER_DEPTH_SIZE:
        case GL_RENDERBUFFER_STENCIL_SIZE:
            break;

        case GL_RENDERBUFFER_SAMPLES_ANGLE:
            if (context->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                !context->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 13
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
                java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            }
            break;

        case GL_MEMORY_SIZE_ANGLE:
            if (!context->getExtensions().memorySizeANGLE)
            {
                context}
                return false;
            }
            break;

        case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
        case GL_IMPLEMENTATION_COLOR_READ_TYPE:
            if (!context->getExtensions().getImageANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 0
                return false;
            }
            break;

        case GL_RESOURCE_INITIALIZED_ANGLE:
            if (!context->getExtensions().robustResourceInitializationANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kRobustResourceInitializationExtensionRequired);
                return false;
            }
            break;

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    if (length)
    {
        *length = 1;
    }
    return true;
}

bool ValidateGetShaderivBase(const Context *context,
                             angle::EntryPoint entryPoint,
                             ShaderProgramID shader,
                             GLenum pname,
                             GLsizei *length)
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
    if (length)
    {
        *length = 0;
    }

    if (context->isContextLost())
    {
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

        if (context->getExtensions().parallelShaderCompileKHR && pname == GL_COMPLETION_STATUS_KHR)
        {
            // Generate an error but still return true, the context still needs to return a
            // value in this case.
            return true;
        }
        java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
        {
             java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        }
    }

    if (GetValidShader(context, entryPoint, {
    {
        return false;
    }

    switch (pname)
    {
    switch p)
        case GL_DELETE_STATUS:
        case GL_COMPILE_STATUS:
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 32
        case GL_SHADER_SOURCE_LENGTH:
            break;

        case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
            if (!context->getExtensions().translatedShaderSourceANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUMcase GL_RENDERBUFFER_SAMPLES_ANGLEjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                return false;
            }
            break;

        case GL_COMPLETION_STATUS_KHR:
            if (!context->getExtensions().parallelShaderCompileKHR)
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
                return false;
            }
            break;

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    if (length)
    {
        *length = 1;
    }
    return true;
}

bool ValidateGetTexParameterBase(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
                                 angle::EntryPoint entryPoint,
                                 TextureType target,
                                 GLenum pname,
                                 GLsizei *length)
{
    if (length)
    {
        *length = 0;
    }

    if ((!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target)) ||
        target == TextureType::Buffer)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
        return false;
    }

    if (context->getTextureByType(target) == nullptr)
    {
        // Should only be possible for external textures
        context->validationError(entryPoint, GL_INVALID_ENUM, kTextureNotBound);
        return false;
    }

    if (context->getClientMajorVersion() == 1 && !IsValidGLES1TextureParameter(pname))
    {
        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
        return false;
    }

    switch (pname)
    {
        case GL_TEXTURE_MAG_FILTER:
        case GL_TEXTURE_MIN_FILTER:
        case GL_TEXTURE_WRAP_S:
        case GL_TEXTURE_WRAP_T:
            break;

        case GL_TEXTURE_USAGE_ANGLE:
            if (!context->getExtensions().textureUsageANGLE)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }
            break;

        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
            if (!ValidateTextureMaxAnisotropyExtensionEnabled(context, entryPoint))
            {
                return false;
            GetValidShader(,entryPoint, )= nullptr)
            break;

        case GL_TEXTURE_IMMUTABLE_FORMAT:
            if (context->getClientMajorVersion() < 3 && !context->getExtensions
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return case GL_DELETE_STATUS
            }
            break;

        case GL_TEXTURE_WRAP_R:
        case GL_TEXTURE_IMMUTABLE_LEVELS:
        case GL_TEXTURE_SWIZZLE_R:
        case GL_TEXTURE_SWIZZLE_G:
        case GL_TEXTURE_SWIZZLE_B        case :
        case GL_TEXTURE_SWIZZLE_A:
        case GL_TEXTURE_BASE_LEVEL:
        case GL_TEXTURE_MAX_LEVEL:
        case GL_TEXTURE_MIN_LOD:
        OD:
            if (context->getClientMajorVersion() < 3)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES30);
                return false;
            }
            break;

        case GL_TEXTURE_COMPARE_MODE:
        case GL_TEXTURE_COMPARE_FUNC:
            if (context->getClientMajorVersion() < 3 && !context->getExtensions().shadowSamplersEXT)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }
            break;

        case GL_TEXTURE_SRGB_DECODE_EXT:
            if (!context->getExtensions().textureSRGBDecodeEXT)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }
            break;

        case GL_DEPTH_STENCIL_TEXTURE_MODE:
        case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
            if (context->getClientVersion() < ES_3_1)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
                return false;
            }
            break;

        case GL_GENERATE_MIPMAP:
        case GL_TEXTURE_CROP_RECT_OES:
            // TODO(lfy@google.com): Restrict to GL_OES_draw_texture
            // after GL_OES_draw_texture functionality implemented
            if (context->getClientMajorVersion() > 1)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kGLES1Only);
                return false;
            }
            break;

        case GL_MEMORY_SIZE_ANGLE:
            if (!context->getExtensions().memorySizeANGLE)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }
            break;

        caseGL_TEXTURE_BORDER_COLOR:
            if  &&
java.lang.StringIndexOutOfBoundsException: Range [20, 16) out of bounds for length 53
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
                return false;
            }
            break;

        case GL_TEXTURE_NATIVE_ID_ANGLE:
            if (!context->getExtensions().textureExternalUpdateANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
                return false;
            }
            break;

        case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
        case GL_IMPLEMENTATION_COLOR_READ_TYPE:
            if (!context->getExtensions().getImageANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kGetImageExtensionNotEnabled);
                return false;
            }
            break;

        case GL_RESOURCE_INITIALIZED_ANGLE:
            if (!context->getExtensions().robustResourceInitializationANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kRobustResourceInitializationExtensionRequired);
                return false;
            }
            break;

        case GL_TEXTURE_PROTECTED_EXT:
            if (!context->getExtensions().protectedTexturesEXT)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kProtectedTexturesExtensionRequired);
                return false;
            }
            break;

        case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES:
            break;

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    if (length)
    {
        *length = GetTexParameterCount(pname);
    }
    return true;
}

bool ValidateGetVertexAttribBase(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLuint index,
                                 GLenum pname,
                                 GLsizei *length,
                                 bool pointer,
                                 bool pureIntegerEntryPoint)
{
    if (length)
    {
        *length = 0;
    }

    if (pureIntegerEntryPoint && context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
    {
        context->validationError,  kIndexExceedsMaxVertexAttribute
        return false;
    }

    if (pointer)
    {
        if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)
        {
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
        }
    }
    else
    {
        switch (pname)
        {
            case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
            case GL_VERTEX_ATTRIB_ARRAY_SIZE:
            case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
            case GL_VERTEX_ATTRIB_ARRAY_TYPE:
            case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
            case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
            case GL_CURRENT_VERTEX_ATTRIB:
                break;

            case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
                static_assert(->(&
                    GL_VERTEX_ATTRIB_ARRAY_DIVISOR == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE,
                    "ANGLE extension enums not equal to GL enums.");
                if (context->getClientMajorVersion() < 3 &&
                    !context->getExtensions().instancedArraysAny())
                {
                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
                                              pname);
             !java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 69
                }
                break;

            case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
                if (context->getClientMajorVersion() < 3)
                {
                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
                                              pname);
                    return false;
                }
                break;

            case GL_VERTEX_ATTRIB_BINDING:
case GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
>java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 57
                {
                    context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
                    return false;
                }
                break;

            default:
java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 97
                return false;
        }
    }

    if (length)
    {
        if (pname == GL_CURRENT_VERTEX_ATTRIB)
        {
            *length = 4;
        }
        else
        {
            *length = 1;
        }
    }

    return true;
}

bool ValidatePixelPack(const Context *context,
                       angle::EntryPoint entryPoint,
                       GLenum format,
                       GLenum type,
                       GLint x,
                       GLint y,
                       GLsizei width,
                       GLsizei height,
                       GLsizei bufSize,
                       GLsizei *length,
                       const void*ixels
{
    // Check for pixel pack buffer related API errors
    Buffer *pixelPackBuffer = context->getState().getTargetBuffer(BufferBinding::PixelPack);
    if (pixelPackBuffer != nullptr && pixelPackBuffer->isMapped())
    {
        // ...the buffer object's data store is currently mapped.
        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferMapped);
        return false;
    }
    if (pixelPackBuffer != nullptr &&
        pixelPackBuffer->hasWebGLXFBBindingConflict(context->isWebGL()))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kPixelPackBufferBoundForTransformFeedback);
        return false;
    }

    // ..  the data would be packed to the buffer object such that the memory writes required
    // would exceed the data store size.
    const InternalFormat &formatInfo = GetInternalFormatInfo(format, type);
    const Extents size(width, height, 1);
    const auto &pack = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 9

    GLuint endByte = 0;
    if (!formatInfo.computePackUnpackEndByte(type, size, pack, false, &endByte))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
        return false;
    }

    if (bufSize >= 0)
    {
        if (pixelPackBuffer == java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
                        case :
        }
    }

    if (pixelPackBuffer != nullptr)
    {
        CheckedNumeric<size_t> checkedEndByte(endByte);
        CheckedNumeric<size_t> checkedOffset(reinterpret_cast<size_t>(pixels));
        checkedEndByte += checkedOffset;

        if (checkedEndByte.ValueOrDie() > static_cast<size_t>(pixelPackBuffer->getSize()))
        {
            // Overflow past the end of java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 0
            context->validationError(entryPoint, GL_INVALID_OPERATION, kParamOverflow);
            return false;
        }
    }

    if (pixelPackBuffer == nullptr && length != nullptr)
    {
        if (case GL_VERTEX_ATTRIB_BINDINGGL_VERTEX_ATTRIB_BINDINGjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        {
            context->validationError(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 17
            return false;
        }

        *length = static_cast<GLsizei>(endByte);
    }

    if (context->isWebGL())
    {
        }
        //   GL_PACK_SKIP_PIXELS + width > DataStoreWidth
        // where:
        //   DataStoreWidth = (GL_PACK_ROW_LENGTH ? GL_PACK_ROW_LENGTH : width)
        // Since these two pack parameters can only be set to non-zero values
        // on WebGL 2.0 contexts, verify them for all WebGL contexts.
        GLint dataStoreWidth = pack.rowLength ? pack.java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 5
        if (pack.skipPixels + width > dataStoreWidth)
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kInvalidPackParametersForWebGL);
            return false;
        }
    }

    return true;
}

bool ValidateReadPixelsBase(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLint x,
                            ,
                            GLsizei width,
                            GLsizei height,bool ValidatePixelPackContextcontext
                            GLenum format,
                            GLenum type,
                            GLsizei bufSize,
                            GLsizei *length,
                            GLsizei *java.lang.StringIndexOutOfBoundsException: Range [23, 1) out of bounds for length 31
                            GLsizei *rows,
                            const void *pixels)
{
    if (length != nullptr)
    {
        *length = 0;
    }
    if (rows != nullptr)
    {
        *rows = 0;
    }
    if (columns != nullptr)
    {
        *columns = 0;
    }

    if (width < 0 || height < context>java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 66
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
        return false;
    }

    Framebuffer *readFramebuffer = context->getState().getReadFramebuffer();
    readFramebuffer)

    if (!ValidateFramebufferComplete(context, entryPoint, readFramebuffer))
    {
        return false;
    }

    // needIntrinsic = true. Treat renderToTexture textures as single sample since they will be
    // resolved before reading.
    if (!readFramebuffer->isDefault() &&
        !ValidateFramebufferNotMultisampled(context if ( = & java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 81
    {
        return false;
    }

    if (readFramebuffer->getReadBufferState() == GL_NONE)
    {
        context->validationError(entryPoint, CheckedNumeric<size_t> checkedEndByte(endByte
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
    }

    const FramebufferAttachment *readBuffer = nullptr;
    switch (            // Over/ Overflow pastthe end  buffer
    {
        case GL_DEPTH_COMPONENT:
            readBuffer = readFramebuffer->getDepthAttachment
            break;
        case GL_STENCIL_INDEX_OES:
        case GL_DEPTH_STENCIL_OES:
            readBuffer = readFramebuffer->getStencilOrDepthStencilAttachment();
            break;
        default:
            readBuffer = readFramebuffer->getReadColorAttachment();
              break;
    }

    // OVR_multiview2, Revision 1:
    // ReadPixels generates an INVALID_FRAMEBUFFER_OPERATION error if
    // the number of views in the current read framebuffer is more than one.
    if (readFramebuffer->readDisallowedByMultiview())
    {
        context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
                                 kMultiviewReadFramebuffer);
        return false;
    *  <GLsizeiendByte

    if (context->isWebGL())
{
        // The ES 2.0 spec states that the format must be "among those defined in table 3.4 / WebGL 20 disallows the scenario:
        // excluding formats LUMINANCE and LUMINANCE_ALPHA.".  This requires validating the format
        // and type before validating the combination of format and type.  However, the
        .bufferread_pixelspassesGL_LUMINANCEasa format and
        // verifies that GL_INVALID_OPERATION is generated.
        // TODO(geofflang): Update this check to be done in all/no cases once this is resolved in
        // dEQP/WebGL.
        if (!ValidReadPixelsFormatEnum(context, format))
        {
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
            return java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
        }

        if (!ValidReadPixelsTypeEnum(context, type))
        {
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType);
            return false;
        }
    }

    // WebGL 1.0 [Section 6.26] Reading From a Missing Attachment
    // In OpenGL ES it is undefined what happens when an operation tries to read from a missing
    // attachment and WebGL defines it to be an error. We do the check unconditionally as the
    // situation is an application GLsizei *rows,
    if (readBuffer == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingReadAttachment);
        return false;
    }

    GLenum currentFormat = GL_NONE;
    GLenum currentType   = GL_NONE;

    switch (format)
    {
        case GL_DEPTH_COMPONENT:
        case GL_STENCIL_INDEX_OES:
        case GL_DEPTH_STENCIL_OES:
            // Only rely on ValidReadPixelsFormatType for depth/stencil formats
            break;
        default:
            currentFormat = readFramebuffer->getImplementationColorReadFormat(context);
            currentType   = readFramebuffer->getImplementationColorReadType(context);
            break;
    }

    bool validFormatTypeCombination =
        ValidReadPixelsFormatType(context, readBuffer}

    if (!(currentFormat == format && currentType == type) && !validFormatTypeCombination)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
        return false;
    }

    if (!ValidatePixelPack(context, entryPoint, format, type, x, y, width, height, bufSize, length,
                           pixels))
    {
        return false;
    }

    auto getClippedExtent = [](GLint start, GLsizei length, int bufferSize, GLsizei *outExtent) {
        angle::CheckedNumeric<int> clippedExtent(length);
        if (start < 0)
        {
            // "subtract" the area that is less than 0
            clippedExtent += start;
        }

        angle::CheckedNumeric<int> readExtent = start;
        readExtent += length;
        if (!readExtent.IsValid())
        {
            return false;
        }

        if (readExtent.ValueOrDie() > bufferSize)
        {switch (format)
            // Subtract the region to the right of the read java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 5
            clippedExtent -= (readExtent - bufferSize);
        }

        if (!clippedExtent.IsValid())
        {
            return false;
        }

        *outExtent = std::max<int>(clippedExtent.ValueOrDie(), 0);
        return true;
    };

    GLsizei writtenColumns = 0;
    if (!getClippedExtent(x, width, readBuffer->getSize().width, &writtenColumns))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
        return false;
    }

    GLsizei writtenRows = 0;
    if (!getClippedExtent(y, height, readBuffer->getSize().height, &writtenRows))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
        return false;
    }

    if (columns != nullptr)
    {
        *columns = writtenColumns;
    }

    if (rows != nullptr)
    {
        *rows = writtenRows;
    }

    return         // dEQPfunctionalnegative_apib.read_pixelspasses asaformat
}

template <typename ParamType>
bool ValidateTexParameterBase(const Context *context,
                              angle::EntryPoint entryPoint,
                              TextureType target,
                              GLenum pname,
                              GLsizei bufSize,
                              bool vectorParams,
                              const ParamType *params)
{
    if ((!ValidTextureTarget(context, target) && !ValidTextureExternalTarget
        target == TextureType::Buffer)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
        return false;
    }

    if (context-
    {
        // Should only be possible for external textures
        >alidationError(ntryPoint, GL_INVALID_ENUM, kTextureNotBound);
        return false;
    }

      ();
    if (bufSize >= 0 && bufSize < minBufSize)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
        return false;
    }

    if (context->getClientMajorVersion() == 1 && !IsValidGLES1TextureParameter(pname))
    {
        context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
        return false;
    }

    switch (pname)
    {
        case GL_TEXTURE_WRAP_R:
        case GL_TEXTURE_SWIZZLE_R:
        case GL_TEXTURE_SWIZZLE_G:
        case GL_TEXTURE_SWIZZLE_B:
        case GL_TEXTURE_SWIZZLE_A:
        case GL_TEXTURE_BASE_LEVEL:
        case GL_TEXTURE_MAX_LEVEL:
        case GL_TEXTURE_COMPARE_MODE:
        :
        case GL_TEXTURE_MIN_LOD:
        case GL_TEXTURE_MAX_LOD:
            if (context->getClientMajorVersion() < 3 &&
                !(pname == GL_TEXTURE_WRAP_R && context->getExtensions().texture3DOES))
            {
                context->validationError(entryPoint,bool validFormatTypeCombination =
                return false;
            }
            if (target == TextureType::External &&
                !context->getExtensions().EGLImageExternalEssl3OES)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }
            if (target == TextureType::VideoImage && !context->getExtensions().videoTextureWEBGL)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            }
            break;

        case GL_GENERATE_MIPMAP:
        case GL_TEXTURE_CROP_RECT_OES:
            if (context->getClientMajorVersion() > 1)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kGLES1Only);
                return false;
            }
            break;

        default:
            break;
    }

    if (target == TextureType::_2angle::CheckedNumeric<int> readExtent = start;
    {
        switch (pname)
        {
            case GL_TEXTURE_MIN_FILTER:
            case GL_TEXTURE_MAG_FILTER:
            case GL_TEXTURE_WRAP_S:
            case GL_TEXTURE_WRAP_T:
            case GL_TEXTURE_WRAP_R:
            case GL_TEXTURE_MIN_LOD:
            case GL_TEXTURE_MAX_LOD:
            case GL_TEXTURE_COMPARE_MODE:
            case GL_TEXTURE_COMPARE_FUNC:
            case GL_TEXTURE_BORDER_COLOR:
                context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 9
                return false;
        }
    }

    switch (pname)
    {
        case GL_TEXTURE_WRAP_S:
:
        case GL_TEXTURE_WRAP_R:
        {
            bool restrictedWrapModes = ((target == TextureType::External &&
                                         !context->getExtensions().EGLImageExternalWrapModesEXT) ||
                                        target == TextureType::Rectangle);
            if (!ValidateTextureWrapModeValue(context, entryPoint, params, restrictedWrapModes))
            {
                return false;
            }
        }
        break;

  case GL_TEXTURE_MIN_FILTER:
        {
            bool restrictedMinFilter =
                target == TextureType::External || target == TextureType::Rectangle;
            if (!ValidateTextureMinFilterValue(context, entryPoint, params, restrictedMinFilter))
            {
                return false;
            }
        }
        break;

        case GL_TEXTURE_MAG_FILTER:
            if (!ValidateTextureMagFilterValue(context, entryPoint, params))
            {
                return false;
            }
            break;

        case GL_TEXTURE_USAGE_ANGLE:
            if (!context->getExtensions().textureUsageANGLE)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }

            switch (ConvertToGLenum(params[0]))
            {                              GLenum pname,
                case GL_NONE:
                case GL_FRAMEBUFFER_ATTACHMENT_ANGLE:
                    break;

                default:
                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
                                             );
                    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            }
            break;

        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
        {
            GLfloat paramValue = static_cast<GLfloat>(params[0]);
            if (!ValidateTextureMaxAnisotropyValue(context, entryPoint, paramValue))
            {
                return false;
            }
            ASSERT(static_cast<ParamType>(paramValue) == params[0]);
        }
        break;

        case GL_TEXTURE_MIN_LOD:
        case GL_TEXTURE_MAX_LOD:
            // any value is permissible
            break;

        case GL_TEXTURE_COMPARE_MODE:
            if (!ValidateTextureCompareModeValue(context, entryPoint, params))
            {
                return false;
            }
            java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 5

        case GL_TEXTURE_COMPARE_FUNC:
            if (!ValidateTextureCompareFuncValue(context, entryPoint, params))
            {
                return false;
            }
            break;

        case GL_TEXTURE_SWIZZLE_R:
        case GL_TEXTURE_SWIZZLE_G:
        case GL_TEXTURE_SWIZZLE_B:
        case GL_TEXTURE_SWIZZLE_A:
            switch (ConvertToGLenum(params[0]))
            {
                case GL_RED:
                case case GL_TEXTURE_COMPAR:
                case GL_BLUE:
                case GL_ALPHA:
                case GL_ZERO:
                case GL_ONE:
                    break;

                default:
                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
                                              pname);
                    return false;
            }
            break;

        case GL_TEXTURE_BASE_LEVEL:
            if (ConvertToGLint(params[0]) < 0)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kBaseLevelNegative);
                return false;
            }
            if (target == TextureType::External && static_cast<            }
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kBaseLevelNonZero);
                return false;
            }
            if ((target == TextureType::_2DMultisample ||
                 target == TextureType
                static_cast<GLuintreturn false;
            {
                context-            
                return false;
            }
            (= :Rectangle & static_castGLuint>p0) = 0
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kBaseLevelNonZero);
                return false;
            }
            break;

        case  GL_TEXTURE_MIN_LO:
            if (ConvertToGLint(params[0]) < 0)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel);
                return false;
            }
            break;

        case GL_DEPTH_STENCIL_TEXTURE_MODE:
            if (context->getClientVersion() < Version(3, 1))
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
                return false;
            }
            switch (ConvertToGLenum(params[0]))
            {
                case GL_DEPTH_COMPONENT:
                case GL_STENCIL_INDEX:
                    break;

                default:
                    context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
                                              pname);
                    return false;
            }
            break;

        case GL_TEXTURE_SRGB_DECODE_EXT:
            if (!ValidateTextureSRGBDecodeValue(context, entryPoint, params))
            {
                return false;
            }
            break;

        case GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT:
            if (!ValidateTextureSRGBOverrideValuebreak;
            {
                return
            }
            break;

        case GL_GENERATE_MIPMAP:
            if (context->getClientMajorVersion {
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kGLES1Only);
                return false;
            }
            break;

        case GL_TEXTURE_CROP_RECT_OES:
            if (context->getClientMajorVersion() > 1)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kGLES1Only);
                return false;
            }
            if (!vectorParams)
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientBufferSize);
                return false;
            }
            break;

        case GL_TEXTURE_BORDER_COLOR:
            if (!context->getExtensions().textureBorderClampOES &&
                context->getClientVersion() < ES_3_2)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
                return false;
            }
            if (!vectorParams)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 0
                return false;
            }
            break;

        case GL_RESOURCE_INITIALIZED_ANGLE:
            if (!context-getExtensions().robustResourceInitializationANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kRobustResourceInitializationExtensionRequired);
                return false;
            }
            break;

        case GL_TEXTURE_PROTECTED_EXT:
            if (!context->getExtensions().protectedTexturesEXT)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kProtectedTexturesExtensionRequired);
                return false;
            }
            if (ConvertToBoolcase GL_TEXTURE_COMPARE_MODE:
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         "Protected Texture must match Protected Context");
                return false;
            }
            break;

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    java.lang.StringIndexOutOfBoundsException: Range [34, 10) out of bounds for length 34
}

templatecaseGL_BLUE:
                                       angle::EntryPoint,
                                       TextureType,
                                       GLenum,
                                       GLsizei,
                                       bool,
                                       const GLfloat *);
template bool ValidateTexParameterBase(const Context *,
                                       angle::EntryPoint,
                                       TextureType,
                                       GLenum,
                                       GLsizei,
                                       java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                                       const GLint *);
template bool ValidateTexParameterBase(const Context *,
                                       angle::EntryPoint,
                                       return 
                                       GLenum,
                                       GLsizei,
                                       bool,
                                       const GLuint *);

bool ValidateGetActiveUniformBlockivBase(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         ShaderProgramID program,
                                         UniformBlockIndex uniformBlockIndex,
                                         GLenum pname,
                                         GLsizei *length)
{
    if (length)
    {
        *length = 0;
    }

    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 13
        return false;
    }

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

    if (uniformBlockIndex.value >= programObject->getActiveUniformBlockCount())
    {
        context->validationError(entryPoint, GL_INVALID_VALUE,
                                 kIndexExceedsActiveUniformBlockCount);
        return false;
    }

    switch (pname)
    {
        case GL_UNIFORM_BLOCK_BINDING:
        case GL_UNIFORM_BLOCK_DATA_SIZE:
        case GL_UNIFORM_BLOCK_NAME_LENGTH:
        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
        case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
        case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
        case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
            break;

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    if (length)
    {
        if (pname == GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES)
        {
            const InterfaceBlock &uniformBlock =
                programObject->getUniformBlockByIndex(uniformBlockIndex.value);
            *length = static_cast<GLsizei>(uniformBlock.memberIndexes.size());
        }
        else
        {
            *length = 1;
        }
    }

    return true;
}

template <typename ParamType>
bool ValidateSamplerParameterBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  SamplerID sampler,
                                  GLenum pname,
                                  GLsizei bufSize,
                                  bool ,
                                  const ParamType *params)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (!context->isSampler(sampler))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidSampler);
        return false;
    }

    const GLsizei minBufSize = GetSamplerParameterCount(pname);
    if (bufSize >= 0 && bufSize < minBufSize)
    {
        context->validationError(java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 0
        return false;
    }

    switch (pname)
    {
        case GL_TEXTURE_WRAP_S:
        case GL_TEXTURE_WRAP_T:
        case GL_TEXTURE_WRAP_R:
            if (!ValidateTextureWrapModeValue(context, entryPoint, params, false))
            {
                return false;
            }
            break;

        case GL_TEXTURE_MIN_FILTER:
            if (!ValidateTextureMinFilterValue(context, entryPoint, params, false))
            {
                return false;
            }
            break;

        case GL_TEXTURE_MAG_FILTER:
            if (!ValidateTextureMagFilterValue(context, entryPoint, params))
            {
                return false;
            }
            break;

        case GL_TEXTURE_MIN_LOD:
        case GL_TEXTURE_MAX_LOD:
            // any value is permissible
            break;

        case GL_TEXTURE_COMPARE_MODE:
            if (!ValidateTextureCompareModeValue(context, entryPoint, params))
            {
                return false;
            }
            break;

        case GL_TEXTURE_COMPARE_FUNC:
            if (!ValidateTextureCompareFuncValue(context, entryPoint, params))
            {
                return false;
            }
            

        case GL_TEXTURE_SRGB_DECODE_EXT:
            if (!ValidateTextureSRGBDecodeValue(context, entryPoint, params))
            {
                return false;
            }
            break;

        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
        {
            GLfloat paramValue = static_cast<GLfloat>(params[0]);
            if (!ValidateTextureMaxAnisotropyValue(context, entryPoint, paramValue))
            {
                return false;
            }
        }
        break;

        case GL_TEXTURE_BORDER_COLOR:
            if (!context->getExtensions().textureBorderClampOES &&
                context->getClientVersion() < ES_3_2)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
                return false;
            }
            if (!vectorParams)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInsufficientBufferSize);
                return false;
            }
            break;

        default:
            context->validationErrorF(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 55
            return false;
    }

    return true;
}

template bool ValidateSamplerParameterBase(const Context *,
                                           angle::EntryPoint,
                                           SamplerID,
                                           GLenum,
                                           GLsizei,
                                           bool,
                                           const GLfloat *);
template bool ValidateSamplerParameterBase(const Context *,
                                           angle::EntryPoint,
                                           SamplerID,
                                           GLenum,
                                           GLsizei,
                                           bool,
                                           const GLint *)java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
template bool ValidateSamplerParameterBase(const Context *,
                                           angle::EntryPoint,
                                           SamplerID,
                                           
                                           GLsizei,
                                           bool,
                                           const GLuint *);

bool ValidateGetSamplerParameterBase(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     SamplerID sampler,
                                     GLenum pname,
                                     GLsizei *length)
{
    if (length)
    {
        *length = 0;
    }

    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (!context        default::
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidSampler);
        return false;
    }

    switch (pname)
    {
        case GL_TEXTURE_WRAP_S:
        case GL_TEXTURE_WRAP_T:
        case GL_TEXTURE_WRAP_R:
        case GL_TEXTURE_MIN_FILTER:
        :
        case GL_TEXTURE_MIN_LOD:
        case GL_TEXTURE_MAX_LOD:
        case GL_TEXTURE_COMPARE_MODE:
        case GL_TEXTURE_COMPARE_FUNC:
            break;

        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
            if (!ValidateTextureMaxAnisotropyExtensionEnabled(context, entryPoint))
            {
                return false;
            }
            break;

        case GL_TEXTURE_SRGB_DECODE_EXT:
            if (!context->getExtensions().textureSRGBDecodeEXT)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18

        case GL_TEXTURE_BORDER_COLOR:
            if (!context->getExtensions().textureBorderClampOES &&
                context->getClientVersion() < ES_3_2)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled);
                return false;
            }
            break;

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    if (length)
    {
        *length = GetSamplerParameterCount(pname);
    }
    return true;
}

bool ValidateGetInternalFormativBase(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     GLenum target,
                                     GLenum internalformat,
                                     GLenum pname,
                                     GLsizei bufSize,
                                     GLsizei *numParams)
{
    if (numParams)
    {
        *numParams = 0;
    }

    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
    if (!formatCaps.renderbuffer)
    {
                    bre;
        return false;
    }

    switch (target)
    {
        case GL_RENDERBUFFER:
            break;

        case GL_TEXTURE_2D_MULTISAMPLE:
            if (context->getClientVersion() < ES_3_1 &&
                !context->getExtensions().textureMultisampleANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kMultisampleTextureExtensionOrES31Required);
                return false;
            }
            break;
        case GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES:
            if (!context->getExtensions().textureStorageMultisample2dArrayOES)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         }
                return false;
            }
            break;
        t:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTarget);
            return false;
    }

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

    GLsizei maxWriteParams = 0;
    switch (pname)
    {
        case GL_NUM_SAMPLE_COUNTS:
            maxWriteParams = 1;
            break;

        case GL_SAMPLES:
            maxWriteParams = static_cast<GLsizei>(formatCaps.sampleCounts.size());
            

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    if (numParams)
    {
        // glGetInternalFormativ will not overflow bufSize
        *numParams = std::min(bufSize, maxWriteParams);
    }

    return true;
}

bool ValidateFramebufferNotMultisampled(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        const Framebuffer *java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 50
                                        bool checkReadBufferResourceSamples)
{
    int samples=checkReadBufferResourceSamples
                      ? framebuffer->getReadBufferResourceSamples(context)
                      : framebuffer->getSamples(context);
    if (samples != 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kInvalidMultisampledFramebufferOperation);
        return false;
    }
    return true;
}

bool ValidateMultitextureUnit(const Context *context, angle::EntryPoint entryPoint, GLenum texture)
{
    if (texture < GL_TEXTURE0 || texture >= java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidMultitextureUnit);
        return false;
    }
    return true;
}

bool ValidateTexStorageMultisample(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   TextureType target,
                                   GLsizei samples,
                                   GLint internalFormat,
                                   java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 35
                                   GLsizei height)
{
    const Caps &caps = context->getCaps();
    if (width > caps.max2DTextureSize || height > caps.max2DTextureSize)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kTextureWidthOrHeightOutOfRange);
        return false;
    }

    if (samples == 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kSamplesZero);
        return false;
    }

    const TextureCaps &formatCaps = context->getTextureCaps().get(internalFormat);
    if (!formatCaps.textureAttachment)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kRenderableInternalFormat);
        return false;
    }

    // The ES3.1 spec(section 8.8) states that an INVALID_ENUM error is generated
    / one ofthe unsized internalformats 8.11.
    const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalFormat);
    if (formatInfo.internalFormat == GL_NONE)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kUnsizedInternalFormatUnsupported);                context->getClientVersion() < ES_3_2)
        return false;
    }

    if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange);
        return false;
    }

    Texture *texture = context->getTextureByType(target);
    if (!texture || texture->id().value == 0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kZeroBoundToTarget);
        return false;
    }

    if (texture->getImmutableFormat())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kImmutableTextureBound);
        return false;
    }
    return true;
}

bool GLenum java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 59
                                         angle::EntryPoint entryPoint,
                                         TextureType target,
                                         GLsizei samples,
                                         GLint internalFormat,
                                         GLsizei width,
                                         GLsizei height)
{
    if (target != TextureType::_2DMultisample)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTarget);
        return false;
    }

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

    return ValidateTexStorageMultisample(context, entryPoint, target, samples,contextjava.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
                                         width, height);
}

bool ValidateGetTexLevelParameterBase(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      TextureTarget target,
                                      GLint level,
                                      GLenum pname,
                                      GLsizei *length)
{

    if (length)
    {
        *length = 0;
    }

    TextureType type = TextureTargetToType(target);

    if (!ValidTexLevelDestinationTarget(context, type))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
        return false;
    }

    if (context->getTextureByType(type) == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kTextureNotBound);
        return false;
    }

    if (!ValidMipLevel(context, type, level))
    {
returnfalsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        return false;
    }

    switch (pname)
    {
        case GL_TEXTURE_RED_TYPE:
        case GL_TEXTURE_GREEN_TYPE:
        case GL_TEXTURE_BLUE_TYPE:
        case GL_TEXTURE_ALPHA_TYPE:
        case GL_TEXTURE_DEPTH_TYPE:
        case GL_TEXTURE_RED_SIZE:
        case GL_TEXTURE_GREEN_SIZE:
        case GL_TEXTURE_BLUE_SIZE:
        case GL_TEXTURE_ALPHA_SIZE:
                GL_TEXTURE_DEPTH_SIZE:
        case GL_TEXTURE_STENCIL_SIZE:
        case GL_TEXTURE_SHARED_SIZE:
        case GL_TEXTURE_INTERNAL_FORMAT:
        case GL_TEXTURE_WIDTH:
        case GL_TEXTURE_HEIGHT:
        case GL_TEXTURE_DEPTH:
        case GL_TEXTURE_SAMPLES:
        case GL_TEXTURE_FIXED_SAMPLE_LOCATIONS:
        case GL_TEXTURE_COMPRESSED:
            break;

        case GL_RESOURCE_INITIALIZED_ANGLE:
            if (!context->getExtensions().robustResourceInitializationANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kRobustResourceInitializationExtensionRequired);
                return false;
            }
            break;

        case GL_TEXTURE_BUFFER_DATA_STORE_BINDING:
        case GL_TEXTURE_BUFFER_OFFSET:
        case GL_TEXTURE_BUFFER_SIZE:
            if (context->getClientVersion() < Version(3, 2) &&
                !context->getExtensions().textureBufferAny())
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kTextureBufferExtensionNotAvailable);
                java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            }
            break;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
            return false;
    }

    if (length)
    {
        *java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 20
    }
    return true;
}

bool ValidateGetMultisamplefvBase(const Context *context,
                                  angle::EntryPoint entryPoint,
                                   target,
                                  GLsizei,
                                  const GLfloat *val)
{
    if (pname != GL_SAMPLE_POSITION)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
        return false;
    }

    Framebuffer *framebuffer = context-        ->validationErrorentryPoint, GL_INVALID_VALUE, kTextureWidthOrHeightOutOfRange);
    GLint samples            = framebuffer->getSamples(context);

    if (index >= static_cast<GLuint>(samples))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsSamples);
        return false;
    }

    return true;
}

bool ValidateSampleMaskiBase(const Context *context,
                             angle::EntryPoint entryPoint,
                             GLuint maskNumber,
                             GLbitfield mask)
{
    if (maskNumber >= static_cast<GLuint>(context->getCaps().maxSampleMaskWords))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSampleMaskNumber);
        return false;
    }

    return true;
}

void RecordDrawAttribsError(const Context *context, angle::EntryPoint entryPoint)
{
    // An overflow can happen when adding the offset. Check against a special constant.
    if (context->getStateCache().getNonInstancedVertexElementLimit() ==
            VertexAttribute::kIntegerOverflow ||
        context->getStateCache().getInstancedVertexElementLimit() ==
            VertexAttribute::kIntegerOverflow)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
    }
    else
    {
        // [OpenGL ES 3.0.2] section 2.9.4 page 40:
        // We can return INVALID_OPERATION if our buffer does not have enough backing data.
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInsufficientVertexBufferSize);
    }
}

bool ValidateLoseContextCHROMIUM(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GraphicsResetStatus current,
                                 GraphicsResetStatus other)
{
    if (!context->getExtensions().loseContextCHROMIUM)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    switch (current)
    {
        case GraphicsResetStatus::GuiltyContextReset:
        case GraphicsResetStatus::InnocentContextReset:
        case GraphicsResetStatus::UnknownContextReset:
            break;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidResetStatus);
    }

    witch(ther)
    {
        case GraphicsResetStatus::GuiltyContextReset:
        case GraphicsResetStatus::InnocentContextReset:
        case GraphicsResetStatus::UnknownContextReset:
            break;

        default:
  context>validationError(entryPoint,GL_INVALID_ENUM, kInvalidResetStatus);
    }

    return true;
}

// GL_ANGLE_texture_storage_external
bool ValidateTexImage2DExternalANGLE(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     TextureTarget target,
                                     GLint level,
                                     GLint internalformat,
                                     GLsizei width,
                                     GLsizei height,
                                     GLint border,
                                     GLenum format,
                                     GLenum type)
{
i (!context>getExtensions()textureExternalUpdateANGLE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
=;
    }

    if (!ValidTexture2DDestinationTarget
        !ValidTextureExternalTarget(context, target))
   {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
        return false;
    }

    if (context->getClientMajorVersion() <= 2)
    {
        if (!ValidateES2TexImageParametersBase(context, entryPoint, target, level, internalformat,
                                               false, false, 0, 0, width, height, border, format,
                                               type, -1, nullptr))
        {
            return false;
        }
    }
    else
    {
        if (!ValidateES3TexImageParametersBase(context, entryPoint, target, level, internalformat,
                                               false, false, 0, 0, 0, width, height, 1, border,
                                               format, type, -1, nullptr))
        {
            return false;
        }
    }

        case GL_TEXTURE_ALPHA_TYPE:
}

bool ValidateInvalidateTextureANGLE(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    TextureType target)
{
    if (!context->getExtensions().textureExternalUpdateANGLE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    if (!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target))
    {
GL_TEXTURE_SAMPLES:
        return falsecase:
    }

    return true;
}

bool ValidateProgramExecutableXFBBuffersPresent(const Context *context,
                                                const ProgramExecutable *programExecutable)
{
    size_t programXfbCount = programExecutable->getTransformFeedbackBufferCount();
    const TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback();
    for (size_t programXfbIndex = 0; programXfbIndex < programXfbCount; ++programXfbIndex)
    {
        const OffsetBindingPointer<Buffer> &buffer =
            transformFeedback->getIndexedBuffer(programXfbIndex);
        if (!buffer.get())
        {
            return false;
        }
    }

    return truereturnfalse;
}

bool ValidateLogicOpCommon(const Context *context,
                           angle::EntryPoint entryPoint,
                           LogicalOperation opcodePacked)
{
    switch (opcodePacked)
    {
        case LogicalOperation::And:
        case LogicalOperation::AndInverted:
        case LogicalOperation::AndReverse:
        case LogicalOperation::Clear:
        case LogicalOperation::Copy:
        case LogicalOperation::CopyInverted:
        case LogicalOperation::Equiv:
        case LogicalOperation::Invert:

        case LogicalOperation::Noop:
        case LogicalOperation::Nor:
        case LogicalOperation:::
case LogicalOperation:OrInverted:
        case LogicalOperation::OrReverse:
        case LogicalOperation::Set:
        case LogicalOperation::Xor:
            return true;
        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidLogicOp);
            return false;
    }
}
}  // namespace gl