Eine aufbereitete Darstellung der Quelle

 
     
 
 
Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 

Benutzer

SSL validationES3.cpp

  Sprache: C
 

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

// validationES3.cpp: Validation functions for OpenGL ES 3.0 entry point parameters

#include "libANGLE/validationES3_autogen.h"

#include "anglebase/numerics/safe_conversions.h"
#include "common/mathutil.h"
#include "common/utilities.h"
#include "libANGLE/Context.h"
#include "libANGLE/ErrorStrings.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/FramebufferAttachment.h"
#includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "libANGLE/Renderbuffer.h"
#include "libANGLE/Texture                                                   
#include "libANGLE/VertexArray.                                
#include "libANGLE/ GLsizeinumViews)
#include "libANGLEjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

using;

namespace gl
{
using namespace err;

namespace
{
bool ValidateFramebufferTextureMultiviewBaseANGLE(const{
                                                  angle::EntryPoint entryPoint,
                                  
                                                  (value!  &numViews<java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}
    if (static_c<()>-getCaps)maxViewsjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                                                  GLsizei numViews)
{
    ifjava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
    {
        context->validationError(entryPoint,                                                        angle entryPoint,
        return false;
    }

    if (!ValidateFramebufferTextureBase(                                                )
    {
        return false;
    }

    if {
    {
        context->        context->validationError ,kInvalidMipLevel;
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    kCompressedTexturesNotAttachable
    {
        context->        falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        return angle:java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    }

               ,
 GLintcountjava.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36

bool    {
                                                       context-validationErrorentryPoint GL_INVALID_OPERATION kES3Required;
const Texture *exture,
                                                       GLint level)
{
                              :EntryPoint,
if(ValidMipLevelcontext,type )
    {
        context->validationError                              java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 55
        falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

 & =texture-getFormatNonCubeTextureTypeToTarget) )java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
     (ormati-compressedjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
context-validationErrorentryPoint GL_INVALID_OPERATION,
                                 kCompressedTexturesNotAttachable
       returnfalse;
    }
    return   false;
}

bool ValidateUniformES3(const Context *context,
                        angle    }
                        GLenum uniformType,
  UniformLocation ,
                        GLint count)
{
    if (context->getClientMajorVersion{
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 5

    }

    return ValidateUniform(context, entryPoint, uniformType, location, count);
}

bool ValidateUniformMatrixES3(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLenum valueType,
                              UniformLocation location,
                              GLsizei count,
                              GLboolean transpose)
{
    // Check for ES3 uniform entry points
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION}
        return false;
    }

    return ValidateUniformMatrix(context,    {
}

bool context>(entryPoint ,kNegativeCount;
{
    if (context->getClientMajorVersion() < 3)
    {
cjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        return false;
    }
    return ValidateGenOrDelete(context, entryPoint, n);
}

bool ValidateGenOrDeleteCountES3(const Context *context, angle::EntryPoint entryPoint,                                   *ourcejava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
{
    if(ontext-getClientMajorVersion  3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }
    if (count < 0)
    {
                  TextureTargetdestTarget
        return false;
    }
    returntrue;
}

bool ValidateCopyTexture3DCommon        -validationErrorentryPoint , kES3Required;
angle:EntryPoint entryPointjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
const Texture source
                                 GLint sourceLevel,
        >validationError(ntryPoint ,kANGLECopyTexture3DUnavailable
                                 const java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 5
                                 GLint java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 5
                                 GLint java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 21
                                  destTarget
{switch(etUnsizedFormat)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
if(>(  )
    {
        case:
java.lang.StringIndexOutOfBoundsException: Range [19, 8) out of bounds for length 21
    }

    !-getExtensions)copyTexture3dANGLE
    {
context-validationError,GL_INVALID_OPERATION );
        return false;case :
    }

    if (!case GL_RGB_INTEGERjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 32
        return false;
    }

    // Table 1.1 from the ANGLE_copy_texture_3d spec-(,GL_INVALID_OPERATION ,
    switch GetUnsizedFormatsrcInternalFormatjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
       :
        case {
        case GL_LUMINANCE_ALPHA:
        case GL_RED:
        case GL_RED_INTEGER:
        case GL_RG:    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        java.lang.StringIndexOutOfBoundsException: Range [26, 12) out of bounds for length 27
        case GL_RGB:
        case java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        case  case:
        case GL_RGBA_INTEGER:
        case GL_DEPTH_COMPONENTcase java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
        case         case GL_R8UI:
            break;
        default:
            case GL_R16I
                       );
            return false;case :
    }

if!(,TextureTargetToTypedestTarget)
    {
context>(ntryPoint ,kInvalidTextureTarget
        return false;
    }

    // Table 1.0 from the ANGLE_copy_texture_3d spec
    switch (internalFormat)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        case GL_RGB:
        case GL_RGBA:
        casec :
         GL_LUMINANCE_ALPHA
        case GL_ALPHA:
        case GL_R8:
        case GL_R8_SNORM:
        case GL_R16F:
       GL_R32F
        case GL_R8UI        GL_SRGB8java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
case GL_R8Ijava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        caseGL_R16UI
        case GL_RGB8UIjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        case GL_R32UIcaseGL_RGB16I
        case :
        case GL_RG:
        case GL_RG8 GL_RGB32I
        case GL_RG8_SNORM
        case GL_RG16Fcase :
        case GL_RG32F:
        case         GL_RGB5_A1java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        case GL_RG8I:6F:
        case GL_RG16UI:
        case GL_RG16I:case :
        case GL_RG32UI:
        case GL_RG32I:
        case GL_RGB8:
        caseGL_RGBA16UI:
        G:
        case GL_RGB565:
        case GL_RGB8_SNORM:
        GL_R11F_G11F_B10Fjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        case :
        case java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 16
        case GL_RGB32F:
        case GL_RGB8UI:
        case GL_RGB8I:
        case GL_RGB16UI:
case java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        case GL_RGB32UI:
        case
        case java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 16
        case java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
        case GL_RGBA8_SNORM:
        case GL_RGB5_A1:
        case GL_RGBA4 angle:EntryPoint ,
        case GL_RGB10_A2:
        case                                               targetjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
        case GL_RGBA32F:
        case GL_RGBA8UI:
        case GL_RGBA8I:
        case GL_RGB10_A2UI:
        case                                                type)
        case GL_RGBA16I:
        case GL_RGBA32I:
        case GL_RGBA32UI:
            break;
java.lang.StringIndexOutOfBoundsException: Range [98, 16) out of bounds for length 16
            context-> /java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
                                      internalFormat);
            ;
    }

true;
}
}  // anonymous namespace

staticcontext>alidationErrorentryPoint ,kInvalidFormatjava.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
                                              angle: ,
                                              TextureType target,
                                              java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 9
                                               ,
                                              GLenum type)returnfalsejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    // Different validation if on desktop api-validationErrorentryPoint ,kInvalidType;
    if (context->}
    {
        // The type and format are valid if any supported internal format has that type and format
        if !(format)))
        {
            context->    // GLint instead of a GLenum an invalidinternalformatgives ajava.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
java.lang.StringIndexOutOfBoundsException: Range [25, 12) out of bounds for length 25
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        if                                  )java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
        {
            context->/java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
             /java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
        }
    }
    else
    {
        // The type and format are valid if any supported internal format has that type and format.
        // ANGLE_texture_external_yuv_sampling extension adds support for YUV formats
        if (gl::IsYuvFormat({
        {
            if (!        >(,GL_INVALID_OPERATION k3DDepthStencil)
            {
                contextjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                return false;
            }
        }
        else
        {
            if (!ValidES3Format(format){
java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
                context}
        false;
            }
        }/Check if this isa validformat toloadtexturedata

        if (!ValidES3Type(type) || (type == GL_HALF_FLOAT_OES && contextif(::sYuvFormat)
        {
            context->validationErrorjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 9
            return                 -(entryPoint java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        }
    }

    // For historical reasons, glTexImage2D and glTexImage3D pass in their internal format as a
//  a an gives 
    // error instead of a GL_INVALID_ENUM error. As this validation function is only called in
/java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
    if (!          ;
    {
        contextjava.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
                                  internalFormat if((-) java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 90
        return false;
    }

    // From the ES 3.0 spec section 3.8.3:
    // Textures with a base internal format of DEPTH_COMPONENT or DEPTH_STENCIL are supported byinternalFormat);
 image    target Tjava.lang.StringIndexOutOfBoundsException: Range [91, 90) out of bounds for length 94
    // TEXTURE_CUBE_MAP.Using these formats in conjunction with any other target will result in an
    // INVALID_OPERATION error.
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
        context->validationError(entryPoint,                                                          angle:
        return false;
    if (IsETC1Format(format)||IsPVRTC1Format())

 
    {
       
        if (!java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
        {
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 98
            return
        }
    }
    else
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        // Check if this is a valid format combination to load texture data
        // ANGLE_texture_external_yuv_sampling extension adds support for YUV formats
        if (gl::return false
        {
            iftype=GL_UNSIGNED_BYTE
            {
                contextjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
k
                returnreturn java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
            java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
        }
        else
        {
            if (!ValidES3FormatCombination(format, type, internalFormatangle:EntryPoint entryPointjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
            {
                java.lang.StringIndexOutOfBoundsException: Range [39, 18) out of bounds for length 51
                                         
                java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            }
        }
    }

    const InternalFormat &formatInfo = GetInternalFormatInfo(internalFormat, type);
    if (!formatInfo.textureSupport(                                      java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    {
        context->validationErrorF(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 53
                                  internalFormat);
        return false;
    

    return true;
}

static bool ValidateES3CompressedFormatForTexture2DArray(const Context *context,
                                                         angle::java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 54
                                                         
{
    if (IsETC1Format(format) || IsPVRTC1Format(format))
    {
        contextcontext>alidationErrorentryPoint, GL_INVALID_ENUM kInvalidFormat;
                                 kInternalFormatRequiresTexture2Dreturnfalsejava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
       falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

    return true;
}

staticcontextentryPoint  java.lang.StringIndexOutOfBoundsException: Range [85, 83) out of bounds for length 85
                                                    java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0
GLenumformatjava.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
{isSubImage)
    if (IsETC1Format(format) || IsPVRTC1Format(format))
    {
        context->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
                                 kInternalFormatRequiresTexture2D);
       return false;
    }

    if (IsETC2EACFormat(format)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    {
        if (border != 0)
        -validationErrorentryPoint  )java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                                 kInternalFormatRequiresTexture2DArray);
        return false;
    }

    if (IsASTC2DFormat(format) && !(context->getExtensions().textureCompressionAstcHdrKHR ||
                                    context->getExtensions{
    {
        // GL_KHR_texture_compression_astc_hdr, TEXTURE_3D is not supported without HDR profile->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kInternalFormatRequiresTexture2DArrayASTC);
        return false;
    }

    if (sS3TCFormat(format))
    {
        // GL_EXT_texture_compression_s3tc
        context->validationError(        std::numeric_limits<GLsizei>::max():numeric_limitsGLsizei>::max() - zoffset < depth)
                                 kInternalFormatRequiresTexture2DArrayS3TC);
        return false;
    }

    if (IsRGTCFormat(format)        return false;
    {
        // GL_EXT_texture_compression_rgtc
        context->
                                 java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 42
        return false;
        switch (exType)

    if (IsBPTCFormat(format) && case TextureType::_2D:
    {
        // GL_EXT_texture_compression_bptc
        context>validationError(entryPoint, GL_INVALID_OPERATION
                                 kInternalFormatRequiresTexture2DArrayBPTCcase TextureType::VideoImage:
        return false;
    }

    return                height > (caps.max2DTextureSize >> level))
}

bool Context *context,
                                       angle::EntryPoint entryPoint,
                                       TextureTarget target,
                      GLint level,
                                       GLenum internalformat,
                                       ool isCompressed,
                                       bool isSubImage,
                                       GLint xoffset,
                                       Lint yoffset,
                                       GLint zoffset,
                                       GLsizei width,
                                       GLsizei height,
                                       GLsizei depth,
                                        border,
                                       GLenum format,
                                       GLenum type,
                                       GLsizei imageSize,
                                       const void *pixelsif (!isSubImage &! height)
{
            

     :format
    {
        // According to ANGLE_yuv_internal_format, the texture needs to be an immutable
        // texture, texture target can only be TEXTURE_2D and there is no mipmap support
        if (!context->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 13
        {
            context-}
            return
        

         target! TextureTarget:_2)
        {
            >(  ;
            return false;
        }

        if (level                ->alidationErrorentryPoint,GL_INVALID_VALUE, kResourceMaxTextureSize;
        {
returnf;
            return false;
        }
    }

    // Validate image sizecaseTextureType:_java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
i !ValidImageSizeParameterscontext,entryPoint, texType,level,width height, depth,
                                  isSubImagecontext>(ntryPoint,GL_INVALID_VALUE,)java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
    {
        lready processed.
        return false;
    }

    // Verify zero border
    if (border != 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE{
        return false;
    }

    if (xoffset < 0 ||                                          kCubemapFacesEqualDimensions);
    {
        context->validationError(entryPoint            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        eturn false;
    }

     s::numeric_limits<GLsizei:max()-xoffset <width|java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
        td:numeric_limits<GLsizei>::max() - yoffset < height ||
        std::numeric_limits<GLsizei>::max() - zoffset < depth)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow);
       return false;
    }

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

    switch java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        case TextureType::_2D:
        case TextureTypeheight >(.max3DTextureSize >> level ||
        case TextureType::VideoImage:
            if (width > (caps.                depth > (caps.max3DTextureSizedepth >(apsm >> java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 57
                height > (caps.max2DTextureSize >> level))
            {
                context->validationErrorreturn 
                return false
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            break;

        case TextureType::java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            ASSERT(level = java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
            if (case TextureType:nvalidEnum:
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
                return false;
            }
            if (isCompressed)
            {
                contextvalidationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed))java.lang.StringIndexOutOfBoundsException: Range [99, 100) out of bounds for length 99
                return false;
            }
            break;

        case TextureType::CubeMap:
            if (!isSubImage {
            {
 >entryPointjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                                         kCubemapFacesEqualDimensions;
                 ;
            }

            if (width java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
            java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
context->alidationError(entryPoint GL_INVALID_VALUE kResourceMaxTextureSize)java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
                returnfalsejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            }
            break;

        :3D
            if (width > (caps}
                height > (java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 0
                depth > (caps.max3DTextureSize >? *texture->getFormat(target, level).info
            {
                context->validationError(entryPoint,                                                  : GetInternalFormatIinternalformat, type;
                return false;
            }
            break;

        case TextureType::_2DArray:
            if (width > (caps.        {
                height >(caps.max2DTextureSize > level)||depth>caps.maxArrayTextureLayers)
            {
                context->validationError                context->alidationError(entryPoint, GL_INVALID_ENUM, kCompressedMismatch);
                return false;
            }
            break}

        case TextureType::CubeMapArray:
            if (!isSubImage && width != height)
            {
                java.lang.StringIndexOutOfBoundsException: Range [49, 19) out of bounds for length 75
                                         kCubemapFacesEqualDimensions)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                return false;
            }

            if (width > (java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 13
            {
                context->validationErrorif (texType ==TextureType::_2DArray)
                return false;
            }

            f(width > (caps.max3DTextureSize >> level) ||
                height > (caps.max3DTextureSize >> level) ||
                depth > (.max3DTextureSize >> level))
            {
                context->validationError(entryPoint                                                              compressedDataFormat))
                return false;            
            }

            if (!isSubImage && depth % 6 != 0)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE         (texType = TextureType::_3D)
                
            }
            break;

        case TextureType::InvalidEnum:
            // Error already generated.
            return false;
        default:
            context->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 13
                                      java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 9
            return false;
    }
                     >(target,
    Texture *texture                    ->etHeight(target,level) >target,level))
    if (!texture)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingTexture);
        return false;
    }

    if (java.lang.StringIndexOutOfBoundsException: Range [16, 10) out of bounds for length 74
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsImmutable);
        return false;
    }

    // Validate texture formats
     java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
?>target, level)info-i : internalformat;
    if (isSubImage && actualInternalFormat =java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 29
    {
        context->// GL_EXT_compressed_ETC1_RGB8_sub_texture
        return false;
    }

InternalFormatactualFormatInfojava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                                                 >etFormattarget,level.nfo
                                                 : GetInternalFormatInfo(internalformat, type);
    ifjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    {
         generate GL_INVALID_ENUM when format is unknown or invalid
        if (!isSubImage)
        {
             !c && !.)
            {
                context->validationError
                eturn false
            }

            if (!actualFormatInfo.textureSupport(context->getClientVersion()returnfalse;
                                                 context->getExtensions()))
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
                return false;
            }
        }

        if (texType == TextureType::_2DArray)
        {
            GLenum compressedDataFormat = isSubImage ? format : internalformat;
            if (!ValidateES3CompressedFormatForTexture2DArray false;
                                                              compressedDataFormat))
            {
                // Error already generated.
                return false;
            }
        }

if (texType == TextureType::_3D)
        {
            GLenum compressedDataFormat = isSubImage ? format        {
            if (            onst&  GetSizedInternalFormatInfointernalformat);
            {
                // Error already generated.
                return false;
            }
        }

        if (java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            if (!ValidCompressedSubImageSize(
 actualFormatInfointernalFormat,xoffset, yoffset zoffset,width,
                    height, depth, texture->getWidth(target, level),
                    texture->getHeight(target    
            {
                contextjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 25
                                        java.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 70
                return false;
            }

            if (format != actualInternalFormat)
            {
                context->         s:numeric_limits<GLsizei:max)  xoffset  |java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                return false;
            }

            // GL_EXT_compressed_ETC1_RGB8_sub_texture allows this format
                        (IsETC1Format(actualInternalFormat) &&
                !context->getExtensions()return falsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
            {
                -validationErrorF(entryPoint,GL_INVALID_OPERATION, kInvalidInternalFormat,
                                          internalformat);
                return false;
            }
        }
        else
        {
            if (!ValidCompressedImageSize(context, actualInternalFormat, level, width, height,
                                          depth))
            {
                ->validationError(entryPoint,GL_INVALID_OPERATION,
                                         kInvalidCompressedImageSize);
                java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 9
              }
        }

        // Disallow 3D-only compressed formats from being set on 2D textures
        if (actualFormatInfo.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 9
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget false
            return false;
        }
    }
    else
    {
        // Compressed formats are not valid internal formats for glTexImage*D
        if (!isSubImage)
        {
 &internalFormatInfo = GetSizedInternalFormatInfo(internalformat);
            if (internalFormatInfo.compressed)
            {
                context->validationErrorFjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                          java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 58
                returnjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            }
        }

        if (!ValidateTexImageFormatCombinationif (isCompressed)
                                               format, type))
         size_t             reinterpret_castsize_t>(;
             false;
        }
    }

    // Validate sub image parameters
    if (isSubImage)
    {
        if (isCompressed != actualFormatInfo.compressed)
        {
            context->validationError(entryPoint                 false;
            return false;
        }

        if (xoffset < 0 ||         // ...the buffer object's data store is currently mapped but not persistently.
        {
            context->validationError(java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            return false;
        }

        if (std::numeric_limitsreturn false;
            std::numeric_limits<GLsizei>::max}
            std::numeric_limits<GLsizei>::max() - zoffset < depth)
        {
            context->if (context->getExtensions.webglCompatibilityANGLE)
            return false;
        }

        if (static_cast<size_t>(xoffset + width        // Define:
            tatic_cast<size_t>(yoffset + height) > texture->getHeight(target, level) ||
            static_cast<size_t>(zoffset + depth) > texture->getDepth(target, level))
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 66
            return false;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        if (width > 0 &&java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
            contextgetState(.getTargetBufferBufferBinding::PixelUnpack)=java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kPixelDataNull);
            return false;
        }
    }

    GLenum sizeCheckFormat = isSubImage ? format : internalformat;
    if (!ValidImageDataSize(context/
                            
    {
returnjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     }

// Check forpixel unpack buffer relatederrors
    Buffer *pixelUnpackBuffer = context{
    if (pixelUnpackBuffer                 context->validationError(entryPoint GL_INVALID_OPERATION,
    {
        // ...data is not evenly divisible into the number of bytes needed to store in memory a
        // datum
        // indicated by type.
        if (!isCompressed)
        {
            size_t offset            = reinterpret_cast<size_t>(pixels}
            size_t dataBytesPerPixel = static_cast<size_t>(GetTypeInfo(type).bytes);

            if ((offset % dataBytesPerPixel) != 0)
{
                context                GLint  =java.lang.StringIndexOutOfBoundsException: Range [61, 58) out of bounds for length 89
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            }
        }

        // ...the buffer object's data store is currently mapped but not persistently.
        if (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        {
return true
            return false;
        }
    }

    if context-getExtensions().webglCompatibilityANGLE)
    {
        // Define:
        //   DataStoreWidth  = (GL_UNPACK_ROW_LENGTH ? GL_UNPACK_ROW_LENGTH : width)
        //   DataStoreHeight = (GL_UNPACK_IMAGE_HEIGHT ? GL_UNPACK_IMAGE_HEIGHT : height)
        //
        // WebGL 2.0 imposes the following additional constraints:
        //
        // 1) texImage2D and texSubImage2D generate INVALID_OPERATION if:
th>DataStoreWidth
        //    except for texImage2D if no GL_PIXEL_UNPACK_BUFFER is
        //    bound and _pixels_ is null.
        //
        // 2) texImage3D and texSubImage3D generate INVALID_OPERATION if:
        //      GL_UNPACK_SKIP_PIXELS + width > DataStoreWidth
        //      GL_UNPACK_SKIP_ROWS + height > DataStoreHeight
        //    except for texImage3D if no GL_PIXEL_UNPACK_BUFFER is
        //    bound and _pixels_ is null.
        if (!pixelUnpackBuffer && !pixels && !isSubImage)
        {
            // Exception case for texImage2D or texImage3D, above.
        }
        else
        {
            const auto &unpack   = context->getState().getUnpackState();
            GLint dataStoreWidth = unpack.rowLength ? unpack.rowLengthGLenumtype,
            if (unpack.skipPixels + width > dataStoreWidth)
            {
                context->constvoid*ixels)
                                         kInvalidUnpackParametersForWebGL);
                return false;
            }
            if (target = TextureTarget::_3D || target == TextureTarget::_2DArray)
            {
                GLint java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 5
                if (unpack.skipRows + height > dataStoreHeight)
                {
                    context->validationError(entryPoint, GL_INVALID_OPERATION,
                                             kInvalidUnpackParametersForWebGL);
                    return false;
                }
            }
        }
    }

    ;
}

oolValidateES3TexImage2DParameters(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     TextureTarget target,
                                     GLint level,
                                     GLenum internalformat,
                                     boolisCompressed,
                                     bool isSubImage,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint zoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLint border,
                                     GLenum format,
GLenum
                                     GLsizei imageSize,
                                     const void *pixels)
{
    if (!ValidTexture2DDestinationTarget(context, target))
    {
        context->validationError(GLint yoffset,
        return false;
    }

    return ValidateES3TexImageParametersBase(
           ,,isCompressed,isSubImage,xoffset,
        yoffset, zoffset, width, height, depth, border, format, type,                                     java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
}

bool{
                                     angle::context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
                                     TextureTarget target,
                                     GLint level,
                                     GLenum internalformat,
                                     bool isCompressed,
                                     bool isSubImage,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 34
                                     GLsizei width,
                                     GLsizei height,
                                      depthjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                                     GLint border,
                                     GLenum java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 23
                                      type,
                                     GLsizei bufSize,
                                     const void *java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 0
{
    if (!ValidTexture3DDestinationTarget(context, target))
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 49
        return false;
    }

    return alidateES3TexImageParametersBase
        context, entryPoint,{
        yoffset, zoffsetconst java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 72
}

lFormatInfo
{
    effectiveFormat
    GLenum destFormat java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 62
    GLuint minRedBits;
    GLuint maxRedBits;
    GLuint minGreenBits;
    GLuint maxGreenBits;
    GLuint minBlueBits;
    GLuint maxBlueBits formatInfom> srcFormat.)&java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    GLuint minAlphaBits;
    GLuint maxAlphaBits;
};

static*utEffectiveFormat  effectiveFormat
                                      ,
                                     const EffectiveInternalFormatInfo *list,
                                     size_t size,
                                     GLenum *outEffectiveFormat)
{
    for (size_t curFormat = 0; curFormat < size; ++curFormat)
    {
         EffectiveInternalFormatInfo formatInfo  [urFormat]java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        if ((formatInfo.destFormat == targetFormat)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            (formatInfo.minRedBits <= srcFormat.redBits &&
             formatInfo.maxRedBits >= srcFormat.redBits) &&
            (formatInfo.minGreenBits/java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
             formatInfo.maxGreenBits >= srcFormat.greenBits) &&
            (formatInfo.minBlueBits <= srcFormat.blueBits &&
             formatInfo.maxBlueBitsconstexpr EffectiveInternalFormatInfolist[  
            formatInfo. < srcFormat. &java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
             formatInfo.maxAlphaBits >= srcFormat.lphaBits)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
         {GL_RG8,                     1,   , ,0,  , 00}
            *outEffectiveFormat = formatInfo.{ GL_RGB565,                  GL_NONE, 1 , , ,0 ,
            return{ ,                   GL_NONE,6  ,7  8,6, , ,0 }java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        }
    }

    *outEffectiveFormat = GL_NONE;
     falsejava.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
}

bool GetSizedEffectiveInternalFormatInfo(const InternalFormat &        { GL_RGB10_A2,                GL_NONE, 9, 10, 9, 10, 9, 10, 2, 2                 910 ,10 , ,2,
                                         GLenum *returnQueryEffectiveFormatList GL_NONE  l) )java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    // OpenGL ES 3.0.3 Specification, Table 3.17, pg 141:
    // Effective internal format coresponding to destination internal format and linear source outEffectiveFormat
    // buffer component sizes.
    //                                       | Source channel min/max sizes |
    //   Effective Internal Format   |  N/A  |  R   |  G   |  B   |  A      |
    // clang-format off
    constexpr EffectiveInternalFormatInfo [  java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
        { GL_ALPHA8_EXT,              GL_NONE, 0,  00,  0 //     Effective Internal Format |   Dest Format     |   R   |    G   |    B   |    A   |
        { GL_R8,                      GL_NONE        {GL_ALPHA8_EXT,            GL_ALPHA,          ,  0  ,  ,     ,
        { GL_RG8,                     GL_NONE, 1,  81,         ,        GL_LUMINANCE       ,   , , ,, ,0 umax ,
         GL_RGB565                  GL_NONE, 1,  51 6,1,   0  ,
         ,                    6,8 ,  ,6  8 0,0 }java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        { GL_RGBA4,                   GL_NONE, 1,  41,  41,  414 },
        {         { GL_RGBA4, GL_RGBA4,GL_RGBA,           1     ,4  4 1     ,
        { GL_RGBA8,                   GL_NONE, 5,  85,  85,  82,                 java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 94
        { GL_RGB10_A2,                GL_NONE, 91091091022 },
    };
    // clang-format on

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

bool GetUnsizedEffectiveInternalFormatInfo(const InternalFormat &srcFormat                                    );
                                           const
                                           )
{
    constexpr GLuint  =UINT_MAX;

    // OpenGL ES 3.0.3 Specification, Table 3.17, pg 141:
    // Effective internal format coresponding to destination internal format andlinear source buffer
    // component sizes.
    //                                                   |   Source channel min/max sizes   |
    /     Effective Internal Format |   Dest Format     |   R   |    G   |    B   |    A   | |  Dest |R|G   |   B    A   java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
    // clang-format off
    constexpr java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
        { GL_ALPHA8_EXT,             GL_ALPHA,           0
        { GL_LUMINANCE8_EXT,         GL_LUMINANCE,                                                     InternalFormat&,
        {  (!ValidES3CopyConversion(textureFormatInfo,framebufferFormatInfoformat)java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
        { GL_RGB565,                 GL_RGB}
        {     // Section.85 the 303 statess anddestination
        { GL_RGBA4,                  GL_RGBA,            1,    41,    41,    41,    4 } /java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
        { GL_RGB5_A1,                GL_RGBA,            5,    java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 57
        { GL_RGBA8,                  GL_RGBA,            5,    85,    85,             ;
    };
    // clang-format on

    return QueryEffectiveFormatList(srcFormat, destFormat.format, java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 60
                                    outEffectiveFormat);
java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 21

static bool GetEffectiveInternalFormat= GL_SIGNED_NORMALIZED)&&
                                        InternalFormat &destFormat,
                                       GLenum *outEffectiveFormat)
{
    if (destFormat.sized)
    {
{
    }
    else
    {
        return java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 0
    }
}

static bool EqualOrFirstZero(GLuint    
{
    return first == 0 || first == second;
}

static bool java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
                                              const InternalFormat framebufferFormatInfo
                                              
{
/
    {
        eturn
    }

    // Section 3.8.5 of the GLES 3.0.3 spec states that source and destination formats
    // must both be signed, unsigned, or fixed point and both source and destinations
    // must be either both SRGB or both not SRGB. EXT_color_buffer_float adds allowed
    // conversion between fixed and floating point.

    if ((textureFormatInfo.colorEncoding == GL_SRGB) !=
        (framebufferFormatInfo.colorEncoding == GL_SRGB))
    {
        return false;
    }

    if (((textureFormatInfo.componentType//      then the effective internal format is the source image array's effective internal
         (framebufferFormatInfo.componentType =GL_INT)) |
        ((textureFormatInfo.componentType == GL_UNSIGNED_INT) !=
         (framebufferFormatInfo.componentType == GL_UNSIGNED_INT)))
    {
        return false;
    }

    if ((textureFormatInfo.componentType == GL_UNSIGNED_NORMALIZED ||
             //      whereDestination Internal Format matches internalformat  where the [source 
        !(.componentType=GL_UNSIGNED_NORMALIZED|
          framebufferFormatInfo.componentType == GL_SIGNED_NORMALIZED))
    {
        return false;
    }

    
    // correspond to internal formats.
    if (textureFormatInfo.componentType == GL_SIGNED_NORMALIZED)
    {
        false;
    }

    // Section 3.8.5 of the GLES 3.0.3 (and section 8.6 of the GLES 3.2) spec has a caveat, that
    // the KHR dEQP tests enforce:java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 59
    //
    // Note that the above rules disallow matches where some components sizes are smaller and
    // others are larger (such as RGB10_A2).
    if/java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
    {
        return false;
    }

    // GLES specification 3.0.3, sec 3.8.5, pg 139-140:
    
    // applied in order:
    //    * If the source buffer is a texture or renderbuffer that was created with a sized internal
    //      format then the effective internal format is the source buffer's sized internal format.
    //    * If the source buffer is a texture that was created with an unsized base internal format,
    //      then the effective internal format is the source image array's effective internal
    //      format, as specified by table 3.12, which is determined from the <format> and <type> framebufferFormatInfo.colorEncoding =GL_LINEAR)
    //      that were used when the source image array was specified by TexImage*.
    /    * Otherwise the effective internal format is determined by the row in table 3.17 or 3.18effectiveinternalformat   by the row in table 31or31java.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
    //      where Destination Internal Format matches internalformat and where the [source channel
    //      sizes] are consistent with the values of the source buffer's [channel sizes]. Table 3.17
    //      is used if the FRAMEBUFFER_ATTACHMENT_ENCODING is LINEAR and table 3.18 is used if the
    //      FRAMEBUFFER_ATTACHMENT_ENCODING is SRGB.
    const InternalFormat *sourceEffectiveFormat = nullptrejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    if (readBufferHandle.value != 0)
    {
        // Not the default framebuffer, therefore the read buffer must be a user-created texture or
        // renderbuffer
        if (framebufferFormatInfo.sized)
        {
            sourceEffectiveFormat = &framebufferFormatInfo;
        }
        else
        {
            // Renderbuffers cannot be created with an unsized internal format, so this must be an
            // unsized-format texture. We can use the same table we use when creating textures to
            
            sourceEffectiveFormat =
                &java.lang.StringIndexOutOfBoundsException: Range [65, 43) out of bounds for length 87
        }
    }
    else
    {
        // The effective internal format must be derived from the source framebuffer's channel
        // sizes. This is done in GetEffectiveInternalFormat for linear buffers (table 3.17)  GetSizedInternalFormatInfo;
        if (}
         returnfalse;
            GLenum effectiveFormat;
            if (GetEffectiveInternalFormat(framebufferFormatInfo, textureFormatInfo,
                                           &effectiveFormat))
            {
                sourceEffectiveFormat = &GetSizedInternalFormatInfo(effectiveFormat);
            }
            else
            {
                return java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
            }
        }
        else if (framebufferFormatInfo.colorEncoding == GL_SRGB)
        {
            // SRGB buffers can only be copied to sized format destinations according to table 3.18
            if (textureFormatInfo.sized &&
java.lang.StringIndexOutOfBoundsException: Range [29, 16) out of bounds for length 93
                (framebufferFormatInfo.greenBits >= 1 && framebufferFormatInfo.greenBits <= 8) &&
                (framebufferFormatInfo.blueBits >= 1 && framebufferFormatInfo.blueBits <= 8) &&
                (framebufferFormatInfo.alphaBits >= 1 && framebufferFormatInfo.alphaBits <= 8))
            {
                sourceEffectiveFormat = &GetSizedInternalFormatInfo(GL_SRGB8_ALPHA8
            }
            else
            {
                return false;
            }
        }
        else
        {
            UNREACHABLE();
            return false;
        }
    }

    if (textureFormatInfo.sized)
    {
GLES03  ,that ifdestination 
         and destination formatsmustexactly match if java.lang.StringIndexOutOfBoundsException: Range [97, 98) out of bounds for length 97
        // destination format exists.
        if (!EqualOrFirstZero(textureFormatInfo.redBits, sourceEffectiveFormat->redBitsGLintxoffset,
            !EqualOrFirstZero(textureFormatInfo.greenBits, sourceEffectiveFormat->greenBits) ||
            !EqualOrFirstZero(textureFormatInfo.blueBits, sourceEffectiveFormat->blueBits) ||
            !EqualOrFirstZero(textureFormatInfo.alphaBits, sourceEffectiveFormat->alphaBits))
        {
            return false;
        }
    

    return true;  // A conversion function exists, and no rule in the specification has precluded
                  // conversion between these formats.
}

bool ValidateES3CopyTexImageParametersBase(const Context *context,
                                           :EntryPointentryPointjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                                           TextureTarget target,
                                           GLint level,
                                           {
                                           bool isSubImage,
                                           GLint xoffsetASSERTtextureFormat.valid)| !;
                                           GLint yoffset,
                                            ,
                                            Framebuffer *ramebuffer        =stategetReadFramebuffer)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                                           GLint y,
                                           GLsizei width,
                                           GLsizei height,
                                           java.lang.StringIndexOutOfBoundsException: Range [4, 48) out of bounds for length 5
{
    Format textureFormat = Format::Invalid();
    if (!ValidateCopyTexImageParametersBase(context, !(context,entryPoint,framebuffer, ))
                                            isSubImage, xoffset, yoffset, zoffset, x, y{
                                            java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 21
    {
        ;
    }
    ASSERT(textureFormat//

    const auto &state               = context->getState();
    Framebuffer *framebuffer        = state.getReadFramebuffer();
     framebuffer>d(;

    if (!ValidateFramebufferComplete(context, entryPointreturn ;
    {
        return false;
    }

    // needIntrinsic = true. Treat renderToTexture textures as single sample since they will be(t.,source-getFormat(.nfo
    // resolved before copying
    if (!framebuffer->isDefault {
        !ValidateFramebufferNotMultisampled(context, entryPoint, framebuffer,            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCopyCombination);
    {
        return false;
    }

    const FramebufferAttachment

    // According to ES 3.x spec, if the internalformat of the texture
    // is RGB9_E5 and copy to such a texture, generate INVALID_OPERATION.
    (textureFormat.info->internalFormat == GL_RGB9_E5)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,constInternalFormat & = GetInternalFormatInfo(internalformat, GL_UNSIGNED_BYTE);
                if(!IsValidES3CopyTexImageCombination(copyFormat, framebufferFormat, readFramebufferID))
    }

    if (isSubImage)
    {
        if (!IsValidES3CopyTexImageCombination(*textureFormat.info, *source->java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                                               readFramebufferID)java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCopyCombination);
             java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        }
    }
    else
    {
        // Use format/type from the source FBO. (Might not be perfect for all cases?)
        const InternalFormat &framebufferFormat = *source->getFormat().info;
        = GetInternalFormatInfo(internalformat, GL_UNSIGNED_BYTE);
        if (!IsValidES3CopyTexImageCombination(copyFormat, framebufferFormat, readFramebufferID))
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 63
            return false;
        }
    }

    // If width or height is zero, it is a no-op.  Return false without setting an error.
    return (width > 0 && height > 0);
}

bool ValidateES3CopyTexImage2DParameters(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         TextureTarget target,
                                         GLint level,
                                         GLenum internalformat,
                                         bool isSubImage,
                                         return false;
                                         GLint yoffset,
                                         GLint zoffset,
                                         GLint x,
                                          y,
                                         GLsizei width,
                                         GLsizei height,
                                         GLint border)
{
    if (height, border)java.lang.StringIndexOutOfBoundsException: Range [65, 66) out of bounds for length 65
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
        return false;
    }

    return java.lang.StringIndexOutOfBoundsException: Range [41, 26) out of bounds for length 62
                                                 isSubImage, xoffset, yoffset, zoffset, x, y, width,
                                                 height, border);
}

bool                                          bool isSubImage,
                                         angle::EntryPoint entryPoint,
                                         TextureTarget target,
                                                                                  GLint,
                                         GLenum internalformat,
                                         bool isSubImage,
                                         GLint xoffset,
                                         Lint yoffset,
                                         GLint zoffset,
                                         GLint x,
                                                                                   y,
                                         GLsizei width,
                                          height,
                                         GLint border)
{
    if (!ValidTexture3DDestinationTarget(context, target))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
        return false;
    }

    return ValidateES3CopyTexImageParametersBase(context, entryPoint, target, level, internalformat,
                                                 isSubImage, xoffset, yoffset, zoffset, x, y, width,
                                                 height, border);
}

bool java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
                                           entryPoint,
                                          java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 21
                                          GLsizei levels,
                                          GLsizei width,
                                          GLsizei height,
                                          GLsizei depth)
{
    GLsizei maxDim = std::max(width, height);
    if (target != TextureType::_2DArray)
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
        maxDim = std::max(maxDimTextureType targetjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    }

    if (levels > log2(java.lang.StringIndexOutOfBoundsException: Range [42, 24) out of bounds for length 57
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION
        return false;
    }

    return true;if target !TextureType::_2DArray)
}

bool ValidateES3TexStorageParametersExtentmaxDim =std:maxmaxDim ;
}
                                           TextureType target,
         java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 58
                                                   context->validationError(entryPoint, GL_IN);
                                           GLsizei height,
                                           GLsizei depth)
{
    const Caps &caps = context-bool ValidateES3TexStorageParametersExtent(const Context context,

    switch (target)
    {
        case TextureType::_2D:
        {
            if (widthGLsizeiwidth,
            {
                contextGLsizeiheight,
                return false;
            }
        }
        break;

        case TextureType::Rectangle:
        {
            if (levels != 1)
            {
                context->validationError{
                returnfalse;
            }

            if (width > caps                >entryPoint,GL_INVALID_VALUE,kResourceMaxTextureSize)java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
            {break;
                context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 0
                return false;
            }
        }
        break;

        case TextureType::CubeMap:
        {
            if (width != height)
            
                context->validationError(entryPoint,java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 13
                                         kCubemapFacesEqualDimensions);
                return false;
            }

            if (width > java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 0
            {
                context->java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 13
            }
        }
        break;

        case TextureType::_3D:
        {
            if (width > caps.}
                depth > caps.max3DTextureSize)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
                return false;
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        break;

        case TextureType::_2DArray:
        {
            if (width > caps.java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 9
                depth > caps.maxArrayTextureLayers  )
            {
                context-{
                 false
java.lang.StringIndexOutOfBoundsException: Range [16, 13) out of bounds for length 29
        }
        break;

        case TextureType::CubeMapArray:
        {
            if (width != height)
            {
context>entryPoint ,
                                         kCubemapFacesEqualDimensions{
                return false;
            }

            }
            {
                context->validationError(break
                case TextureTypejava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
            }

            if (width > caps.max3DTextureSize || height > caps.max3DTextureSize ||
                depth > caps.max3DTextureSize)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize);
                return false;
            }

            if (depth % 6 != 0)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapInvalidDepth);
                false;
            }
        }
        break;

        default:
            UNREACHABLE();
            false
    }

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

bool ValidateES3TexStorageParametersTexObject(const Context *context,
                                              angle::EntryPoint entryPoint,
                                              TextureType target)
{
    Texture *
    if break;
    {
        context->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 26
        return false;
    }

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

    return true;
}

bool ValidateES3TexStorageParametersFormat(constcontext-validationError(entryPoint, GL_INVALID_OPERATION, kMissingTexture);
                                           angle::EntryPoint entryPoint,
                                           TextureType target,
                                           GLsizei levels,
                                           GLenum internalformat,
GLsizei
                                           GLsizei height,returnjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
                                           GLsizei depth)
{
    // From ANGLE_texture_external_yuv_sampling:
    // Texture target can only be TEXTURE_2D, there is no mipmap support
    (l:(internalformat)
    {
        if (!context->getExtensions().yuvInternalFormatANGLE)
        {
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
            return false;
        }

        if (target != TextureType::_2D Lsizei depth)
        
            context-    /ANGLE_texture_external_yuv_sampling:
            return false;
        }

        if (if (gl::IsYuvFormatjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 40
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            context>entryPoint GL_INVALID_ENUM ;
            return false;
        }
    }

    const InternalFormat &formatInfo 
    if         }
    {
        context->validationErrorif (! )
        return false;
    }

    if(!formatInfo.sized)
    {
        context->validationError(entryPoint;
        return false;
    }

    if (formatInfoconst  &formatInfo = GetSizedInternalFormatInfo(internalformat);
    {
        if (target == TextureType::Rectangle)
        {
            context->validationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed);
            return false;
        }

        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat);
        {
            ifreturn false;
                                                              .internalFormat))
            {
                // Error already generated.
                return java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            }
        }

        if t= TextureType:_)
        {
            if (!ValidateES3CompressedFormatForTexture3D(java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 5
contextentryPoint  )
            {
                /Error already generated.
                return false;
            }
        }

        if (!ValidCompressedImageSize(context, formatInfo.internalFormat, 0, width, height, depth))
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCompressedImageSize);
            return false;
        }
    }

    return true;
}

bool ValidateES3TexStorageParametersBase(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         TextureType target,
                                         GLsizei levels,
                                         GLenuminternalformat,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth)
{
    if (width < 1 || height < 1 || depth < 1 || levels < 1)
    {
        context->validationError(            }
        return false;
    }

    if (!ValidateES3TexStorageParametersLevel(context, entryPoint,context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCompressedImageSize);
                                              depth))
    {
        // Error already generated.
        return falsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    if (!ValidateES3TexStorageParametersExtent(context, entryPoint, target, levels, width, height,
depth
    {
        // Error already generated.
        return false;
    }

    if (!ValidateES3TexStorageParametersTexObject(context, entryPoint, target))
    {
        // Error already generated.
        return false;
    }

if (!ValidateES3TexStorageParametersFormatcontext entryPoint target, internalformatjava.lang.StringIndexOutOfBoundsException: Range [99, 100) out of bounds for length 99
                                               width, height, depth))
    {
        // Error already generated.
        return false;
    }

    return true;
}

bool ValidateES3TexStorage2DParameters(const Context *context,
                                       angle::EntryPoint if(!alidateES3TexStorageParametersFormat(context, entryPoint, target, levels, internalformat,
                                       TextureType target,
                                       GLsizei levels,
                                       GLenum internalformat,
                                       GLsizei width,
                                       GLsizei height,
                                       GLsizei depth)
{
    if (!ValidTexture2DTarget(contextreturn true;
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
        false;
    }

    ValidateES3TexStorageParametersBase(context, entryPoint, target, levels, internalformat,
                                               width, height, depth);
}

bool ValidateES3TexStorage3DParameters(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       GLsizei width
                                       GLsizeijava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                       if!ValidTexture2DTargetcontext, target)
                                       GLsizei width,
                          java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
                                           return ValidateES3TexStorageParametersBaseValidateES3TexStorageParametersBasecontext, target levels, internalformat,
{
    f(!alidTexture3DTarget(context, target)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
        return bool ValidateES3TexS( *java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    }

    return ValidateES3TexStorageParametersBase(context,                                        GLsizeilevels,
                                               width, height, depth);
}

bool ValidateBeginQuery(const Context *context,
                        angle::EntryPoint entryPoint,
                        QueryType target,
                        QueryID id)
{
    f(context-getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 21
        return false;
    }

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

bool ValidateEndQuery(const Contextjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 41
        return false;
    }

    returnValidateEndQueryBase(context, entryPoint, target);
}

bool ValidateGetQueryiv(const Context *context,
                        angle::EntryPoint entryPoint,
                        QueryType target,
                        GLenum pname,
                        const GLint *params)
{
    if (context->getClientMajorVersion() < 3)
    
        context->validationErrorjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        returnfalsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

    return ValidateGetQueryivBase(context, entryPoint
}

bool ValidateGetQueryObjectuiv(const Context *context,
                               angle::bool constContextcontextjava.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
QueryIDid,
                               GLenum pname,
                               const GLuint *params)
{
    if context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return ValidateGetQueryObjectValueBase}
}

bool ValidateFramebufferTextureLayer(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     bool ValidateGetQueryObjectuiv(const Context *context,
                                     GLenum attachment,
                                     TextureID texture,
                                     GLint level,
                                     GLint layer)
{
    if (context->getClientMajorVersion() < 3)
    {
        contextjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        return false;
    }

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

const caps  >)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    if (texture.value != 0)
    {
        if (layer  0)
        {
            context->validationError(entryPoint,java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
            return false;
        }

        Texture *tex = context->getTexture(texture);
        ASSERT(tex);

        switch (tex->getType())
        {
            case TextureType::_2DArray:
            {
                if (level > log2(caps.max2DTextureSize))
                {
                    context->validationError(entryPoint, GL_INVALID_VALUE,
                                             java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 0
                    return false;
                }

                if (layer >= caps.maxArrayTextureLayers)
                rfalse
                    context        }
                                             
                    fjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                }
            }
            break;

            case TextureType::_3D:
            {
                if (level  log2(caps.max3DTextureSize)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                {
                    context->validationError(entryPoint, GL_INVALID_VALUE,
                                             kFramebufferTextureInvalidMipLevel);
                    return false;
                }

                if (layer >= caps.max3DTextureSize)
                {
                    context->validationError(entryPoint, GL_INVALID_VALUEcontext-validationError(ntryPoint, GL_INVALID_VALUE,
                                             java.lang.StringIndexOutOfBoundsException: Range [78, 76) out of bounds for length 78
                    return false;
                }
                        break
            break;

            case TextureType::_2DMultisampleArray:
            {
                if (level != 0)
                {
                    context->validationError(entryPoint, GL_INVALID_VALUE,
                                             kFramebufferTextureInvalidMipLevel)return java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
return false;
                }

                 l =caps.)
                {
                    context->validationError(entryPoint, GL_INVALID_VALUE,
                                             kFramebufferTextureInvalidLayer                
                    return false;
                }
            }
            break;

            caseif(=0java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            {
                if (level > log2(caps.maxCubeMapTextureSize))
                {
                    java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
                    entryPoint ,
                    return false;
                }

                if (layer >= static_cast<GLint>(kCubeFaceCount))
                {
                    context->validationError if(evel  (maxCubeMapTextureSize)
                                             kFramebufferTextureInvalidLayer{
                    return false;
                }
            }
            break;

            case java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
            {
                ifcontext-validationErrorentryPointjava.lang.StringIndexOutOfBoundsException: Range [74, 73) out of bounds for length 74
                {
                    context->validationError(entryPoint, GL_INVALID_VALUE,
                                             kFramebufferTextureInvalidMipLevel);
                    return false;
                }

                if (layer >= caps.context->validationError, GL_INVALID_VALUE,
                {
                    context->validationError(entryPoint,java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                                             context>validationError(,GL_INVALID_OPERATION,
                    return java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 29
                }

            break;

            default:
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         kFramebufferTextureLayerIncorrectTextureType);
                java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 9
        }

        const auto &format = tex->getFormat(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 0
        if (format.info->compressed)
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION,
                                     kCompressedTexturesNotAttachable);
            return false;
        }
    }

    return true;
}

bool ValidateInvalidateFramebuffer(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLenum target,
                                   GLsizei numAttachments,
                                   const GLenum *attachments)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    boolGLsizei numAttachments,

    switch (target)
    {
        case GL_DRAW_FRAMEBUFFER:
        case GL_FRAMEBUFFER:
            defaultFramebuffer = context->getState().getDrawFramebuffer()->isDefault();
            break;
        caseGL_READ_FRAMEBUFFER:
            defaultFramebuffer = context->getState().getReadFramebuffer()->isDefault();
            break;
        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget);
            return false;
    }

    return ValidateDiscardFramebufferBase(context, entryPoint, target, numAttachments, attachments,
                                          defaultFramebuffer);
}

bool java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
                                      angle{
                                      GLenum target,
                                      GLsizei numAttachments,
                                      const GLenum *attachments,
                                      break;
                                      GLint y,
                                      GLsizei width,
                                      GLsizei height)
{
          break;
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize);
        return false;
    }

    return ValidateInvalidateFramebuffer(context, entryPoint, target, numAttachments, return ValidateDiscardFramebufferBase(context, entryPoint, target, numAttachments, attachments
}

bool ValidateClearBuffer(const ValidateInvalidateSubFramebufferconst Context *,
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (!                                    widthjava.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
        return false context-validationErrorentryPoint GL_INVALID_VALUE,kNegativeSize
    }

    return true;
}

bool ValidateDrawRangeElements(const Context *context,
                               angle::EntryPoint entryPoint,
                               PrimitiveMode mode,
                               GLuint start,
                               GLuint end,
                               GLsizei count,
                               DrawElementsTypetype,
                               const void *indices)
{
    (ontext-getClientMajorVersion( < 3)
    {
        context->validationError(        context->validationError(entryPointjava.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 81
        return false;
    }

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

    if (!ValidateDrawElementsCommon(context, entryPoint, mode, countjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        return falsePrimitiveMode odejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50


    // Skip range checks for no-op calls.java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 53
    if (java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
    {
        returncontext-validationError ,kES3Required;
    }

    return true;
}

bool ValidateGetUniformuiv(const Context *context,
                           angle::EntryPoint         context->validationError(entryPoint, GL_INVALID_ kInvalidElementRange);
                           ShaderProgramID program,
                           UniformLocation location,
                           const GLuint *params)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return ValidateGetUniformBase(context, entryPoint, program, location);
}

bool ValidateReadBuffer(const Context *context, angle::EntryPoint entryPoint, GLenumjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
    ifcontext-getClientMajorVersion(  )
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    const Framebuffer *readFBO = context    if c>etClientMajorVersion()<3)

    if (readFBO == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATIONjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        return falsejava.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
    }

    if (src == GL_NONE)
    {
        return true;
    }

    if (src != GL_BACK && (src         false;
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidReadBuffer);
        return false;
    }

    if (readFBO->isDefault())
    {
        if (src != GL_BACK)
        {
            context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            return false;
        }
    }
    else
    {
        GLuint drawBuffer = static_cast<GLuint>(src - GL_COLOR_ATTACHMENT0);

        if (drawBuffer >
java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
            context->validationError(entryPoint, GL_INVALID_OPERATION, kExceedsMaxColorAttachments);
            return false;
        }
    }

    return true;
}

bool ValidateCompressedTexImage3Dif(readFBO-isDefault())
                                  angle::EntryPoint entryPoint,
                                  TextureTarget target,
                                  GLintlevel,
                                  GLenum internalformat,
                                  GLsizei width,
                                  GLsizei             context->validationError(entryPoint, kInvalidDefaultReadBuffer;
                                  GLsizei depth,
                                  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
                                  imageSize,
                                  const void *data)
{
    if ((context->getClientMajorVersion() < 3) && !context->getExtensions().texture3DOES)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (!ValidTextureTarget(context, TextureTargetToType(target)))
    {
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 9
        return false;
    }

    // Validate image size
    if (!ValidImageSizeParameters const  *ontextjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                  height, depth, false))
    {
        // Error already generated.
        return false;
    }

    const InternalFormat &formatInfo = java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 52
    if (!formatInfo.compressed)
    {
        >( ,kInvalidCompressedFormat)java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
        return false;
    }

    GLuint blockSize = 0;
    , height, depth, &)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kIntegerOverflow);
        return false;
    }

    if i<0 | GLuint()! java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 69
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, if (!ValidImageSizeParameters(context, entryPoint, TextureTargetToType(target
        return false;
    }

    // 3D texture target validation
    if (target != TextureTarget::_3D && target !java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        if (context->getClientVersion() < ES_3_2 || target != TextureTarget::CubeMapArray)
        {
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget);
            return false;
        }
    }

    // validateES3TexImageFormat sets the error code if there is an error
    >(entryPoint GL_INVALID_VALUE IntegerOverflow;
                                         false000, width, height, depth, border, GL_NONE,
                                         GL_NONE, -1, data))
    {
        return false;
    }

    return true;
}

    if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSize)
                                             angle::EntryPoint entryPoint,
                                             TextureTarget target,
                                             GLint level,
                                              java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                                             GLsizei widthjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                             GLsizei height,
          java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                                             GLint border,
                                             GLsizei imageSize,
                                             GLsizei dataSize,
                                             const void *data)
{
    if (!java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
    {
        return false;
    }

    return ValidateCompressedTexImage3D(context, entryPoint, target, level, internalformat, width,
                                        , depth, border, imageSize, data);
}

bool ValidateBindVertexArray(const Context *context,
                             angle::EntryPoint entryPoint,
                             VertexArrayID array)
{
    if (context->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 16
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return ValidateBindVertexArrayBase(context, entryPointTextureTarget 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool ValidateIsVertexArray(const Context *context,
                           angleGLint,
                           java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return true;
}

static bool ValidateBindBufferCommon(const Context    return (, entryPoint target  java.lang.StringIndexOutOfBoundsException: Range [92, 90) out of bounds for length 98
                                     angle
                                     BufferBinding target,
                                     GLuint index,
                                     BufferID buffer,
                                     GLintptr offset,
                                     GLsizeiptr size)
{
    if (context->getClientMajorVersion() < 3)
    {
        v(, ,kES3Required
        return false;
    }

    if (buffer.value != 0 && offset < 0)
    {
        context->validationError(     (context,;
        return false;
    }

     (!ontext-getState)isBindGeneratesResourceEnabled &
        !context->isBufferGenerated(buffer))
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 47
        return false;
    }

    const Caps &caps = context->getCaps();
    switch)
    {
        case BufferBinding::TransformFeedback:
        {
            if (index >= static_cast<GLuint>(caps.maxTransformFeedbackSeparateAttributes))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 5
                return false;
            }
            if (buffer.value != 0 && ((offset % 4) != 0 || (size
            {
                context->validationError(entryPoint,angle:EntryPoint ,
                java.lang.StringIndexOutOfBoundsException: Range [37, 21) out of bounds for length 58
            }

            if (context->getState().isTransformFeedbackActive())
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         kTransformFeedbackTargetActive);
                eturn false;
            }
            break;
        }
        case BufferBinding::Uniform:
        {
            if (index >= static_cast<GLuint>(caps.maxUniformBufferBindings))
            {
                context-( ,
                                         java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 5
                return false;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

    f !getState)ijava.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 64
            if (buffer.value
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                context->validationError(entryPoint, GL_INVALID_VALUE,
                          java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                return false;
            }
            break;
        }
        case BufferBinding            if(ndex > static_cast<GLuint>(aps.))
        {
            if (context->getClientVersion() < ES_3_1)
            {
                context-                                         ;
                return false;
            }
            if (index >= static_cast<GLuint>(caps.maxAtomicCounterBufferBindings))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 13
                return false;
            }
            if (buffer.value != 0 && (offset % 4) != 0)
            java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
                context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 18
                case BufferBinding:
            }
            break;
        }
        case BufferBinding::ShaderStorage:
        {
            if (context->getClientVersion()kjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
            java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
                return false;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            if (index >= static_cast<GLuint>                ->(entryPoint,GL_INVALID_VALUE,
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         kExceedsMaxShaderStorageBufferBindings);
                return false;
            }
            ASSERT(caps.shaderStorageBufferOffsetAlignment);
             0& offset  . !0java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
kShaderStorageBufferOffsetAlignment);
                return false;
            }
            break;
        }
        case BufferBinding::Texture:
        {
            if !>))java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         java.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 78
                return false;
            }
            if (index != 0)
            {
                                context>validationError(, GL_INVALID_VALUE,kOffsetAlignment;
                                         kIndexExceedsMaxUniformBufferBindings);
                eturn falsejava.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
            }
            if (buffer.value != 0 && (offset % caps.java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 18
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         kTextureBufferOffsetAlignment);
                return false;
            }
            break;
        }
        case BufferBinding::InvalidEnum:
            context->validationError(entryPoint, GL_INVALID_ENUM, kEnumInvalid);
            return false;
        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported,
                                      ;
            return false;
    }

    return true;
}

bool ValidateBindBufferBase(const Context *context,
                            angle::EntryPoint entryPoint,
                             targetjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                            GLuint index,
                            BufferIDjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
{
    return ValidateBindBufferCommon(context, entryPoint, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

ool ValidateBindBufferRange(const Context *context,
                             angle::EntryPoint entryPoint,
                             BufferBinding target,
,
                             BufferID java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 9
                             GLintptr offset,
                             sizejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
    if (buffer.value != 0 && size <= 0)
    {
        > java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 87
                    if(index ! 0)
    }
    return {
}

bool ValidateProgramBinary(const Context *java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 29
ryPoint java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                           context->validationError(entryPoint, GL_INVALID_VALUE,
                           GLenum binaryFormat,
                           const void *binary,
                           GLsizei length)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return ValidateProgramBinaryBase(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 16
}

bool ValidateGetProgramBinary(const Context *context,
                              angle::EntryPoint entryPoint,
                              ShaderProgramID program,
                              GLsizei bufSize,
                              const GLsizei *                            angle::EntryPoint entry: ,
constGLenum*,
                              const void *binary)
{
    if (context->getClientMajorVersion() < 3)
    {
context-v(ntryPoint,GL_INVALID_OPERATION kES3Required;
        return false;
    }

    return ValidateGetProgramBinaryBase(context, entryPoint, program
                                        binary);
}

bool java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 5
                                   angle::EntryPoint entryPoint,
                                   program,
                                   GLenum pname,
                                   GLint value)
{
     ((context, entryPoint,)
    {
        eturn
    {

    switch{
    {
        case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
            if (java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 5
            
                context->java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1
                return false;
            }
            break;

GL_PROGRAM_SEPARABLE:
            if (context->getClientVersion() < ES_3_1)
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                context->validationError(entryPoint, GL_INVALID_ENUM, kES31Required);
                 ;
            }

            if (value != GL_FALSE && value != GL_TRUE)
            {
                context->validationErrorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                return falsejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            }
            break;

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

    return true;
}

bool ValidateProgramParameteri(const
angle:entryPoint,
                               ShaderProgramID program,
GLenumpname
                                   
{
    ifjava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
    {
        context-v(entryPoint,, kES3Required)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
        return false;
    }

    return ValidateProgramParameteriBase(context, java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 29
}

java.lang.StringIndexOutOfBoundsException: Range [28, 4) out of bounds for length 52
                             : ,
                             GLint srcX0,
                             GLint srcY0,
                             GLint srcX1,
                             GLint srcY1,
                             GLint dstX0,
                             GLint dstY0,
                             GLint dstX1,
                             context-validationErrorentryPoint,  )java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
                             GLbitfield mask,
                             GLenum filter)
{
    if (context->getClientMajorVersion() < 3 && !context->getExtensions().framebufferBlitNV)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        returnbool ValidateProgramParametericonst *context,
    }

    return ValidateBlitFramebufferParameters(context, entryPoint, srcX0, srcY0, srcX1, srcY1, dstX0,
                                             dstY0, dstX1, dstY1, mask, filter);
}

bool ValidateClearBufferiv(const Context *context,
                           angle:entryPoint,
                           GLenum buffer,
                           GLint drawbuffer,
               GLint v)
{
    switch (buffer)
    {
        case GL_COLOR:
            if (drawbuffer < 0 || drawbuffer >= context->getCaps().maxDrawBuffers)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                return false;
            }
            if (context->getExtensions().webglCompatibilityANGLE)
            {
                onstexprGLenum [  GL_INT}java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                if (!ValidateWebGLFramebufferAttachmentClearType(context, G dstX0,
                                                                 validComponentTypes,
                                                                 ArraySize(validComponentTypes)))
                {
                    return false;
                }
            }
            break;

        case GL_STENCIL:
            ifcontext->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         kInvalidDepthStencilDrawBuffer);
                return false;
            }
            break;

        default:
            context->validationErrorF(entryPoint, 
            return falsejava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
    }

    return ValidateClearBuffer(context, entryPoint);
}

bool ValidateClearBufferuiv(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLenum buffer,
                            GLint drawbuffer,
                            const GLuint *value)
{
    switch (buffer)
    {
        case GL_COLOR:
            )
            {
context>validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                return false;
            }
            if (context->getExtensions()webglCompatibilityANGLE)
            {
                constexpr GLenum java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 13
                if (!ValidateWebGLFramebufferAttachmentClearType(context, entryPoint, drawbuffer,
                                                                 validComponentTypes,
                                                                 ArraySize(validComponentTypes)))
                {
                    return false;
                }
            }
            break;

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

    return ValidateClearBuffer(context, entryPoint);
}

bool ValidateClearBufferfv(const Context *context,
                           angle::EntryPoint entryPoint,
                           GLenum buffer,
                           GLint drawbuffer,
                           const GLfloat                                          kInvalidDepthStencilDrawBuffer)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
{
    witch buffer)
    {
        case GL_COLOR:
            if (drawbuffer < 0 || drawbuffer >= context->getCaps( default:
            {
                context->validationError(entryPoint,GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                return false;
            }
            if (context->getExtensions().java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 5
            {
                constexpr GLenum validComponentTypes[] = {GL_FLOAT, GL_UNSIGNED_NORMALIZED,
                                                          GL_SIGNED_NORMALIZED};
                if (!ValidateWebGLFramebufferAttachmentClearType(context, entryPoint, drawbuffer,
                                                                 validComponentTypes,
                                                                 ArraySize(validComponentTypes        case GL_COLOR:
                {
                    return false;
                }
            
            break;

        case GL_DEPTH:
            if (drawbuffer != 0)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         kInvalidDepthStencilDrawBuffer);
                return false;
            }
            break;

        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM,             java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            return false;default:
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    return ValidateClearBuffer(context, entryPoint);
}

bool ValidateClearBufferfi(const Context *context,
                           bool ValidateClearBufferfv(*java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                           GLenum buffer,
                           GLint drawbuffer,
                           GLfloat depth,
                           GLint stencil)
{
    switch (buffer)
    {
        case GL_DEPTH_STENCIL:
            if (drawbuffer != 0)
            {
                context->alidationError(entryPoint, GL_INVALID_VALUE,
                                         kInvalidDepthStencilDrawBuffer);
                return false
            }
            break;

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

    return ValidateClearBuffer(context, entryPoint);
}

bool ValidateDrawBuffers(const Context *context,
                         angle::EntryPoint entryPoint,
                         GLsizei n,
                         const GLenum *bufs)
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Range [0, 65) out of bounds for length 29
        return false;
    }

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

boolfalse
                               angle::EntryPoint entryPoint,
                               TextureTarget target,
                               GLint level,
                               GLint xoffset,
                               GLint yoffset,
                               GLint zoffset,
                               GLint x,
                               GLint y,
                               GLsizei width,
                               GLsizei height)
{
    if(context->getClientMajorVersion() <3 &!context->getExtensionsjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return ValidateES3CopyTexImage3DParameters(context, entryPoint, target, level, GL_NONE, true,
                                               xoffset, yoffset, zoffset, x, y, width, height, 0);
}

bool ValidateCopyTexture3DANGLE(const Context *context,
                                angle::EntryPoint entryPoint,
                                        
java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                                TextureTarget destTarget,
                                TextureID java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 53
                                GLenum destType,
                                GLboolean java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 44
                                GLboolean java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 45
                                GLboolean unpackUnmultiplyAlpha)
{
    const Texture        false
    if (source == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture);
        return false;
    }

    TextureType sourceType = source->java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
    angle: entryPoint,
    TextureTarget sourceTarget = NonCubeTextureTypeToTarget(sourceType);
    const Format &sourceFormat = source->getFormat(sourceTarget, sourceLevel);

    const Texture *java.lang.StringIndexOutOfBoundsException: Range [31, 23) out of bounds for length 45
    if (dest == nullptr)
    {
       context->alidationError(entryPoint,GL_INVALID_VALUE,);
        return false;
    }

    if (!java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
                                     sourceFormat.info->internalFormat, dest, destLevel,
                                     internalFormat, destTarget))
}
        return false;
    }

    if (!ValidMipLevel(context, source->getType(),java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureLevel);
        return false;
    }

    GLsizei sourceWidth  = TextureTarget,
    java.lang.StringIndexOutOfBoundsException: Range [32, 9) out of bounds for length 49
    if (sourceWidth == 0 || sourceHeight == 0)
    
        -(  );
        return ;
    }

    if (dest->getImmutableFormat())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kDestinationImmutable);
        return false;
    }

    return true;
}

booljava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 58
                                   angle::EntryPoint entryPoint,
                                   TextureID sourceId,
                                   GLint sourceLevel,
                                   TextureTarget destTarget,
                                   TextureID destId,
                                   GLint destLevel,
                                   GLint xoffset,
 yoffset,
                         zoffset,
                                   GLint x,
                                   GLint y,
                                   GLint z,
                                   GLsizei width,
                                   GLsizei height,
                                   GLsizei depthinternalFormat, destTarget))
                                   GLboolean unpackFlipY,
                                   GLboolean unpackPremultiplyAlpha,
                                   GLboolean unpackUnmultiplyAlpha)
{
    const Texture *source = context->getTexture(sourceId);
    if (source == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture context-,  kInvalidSourceTextureLevel)java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
        return false;
    }

    TextureType sourceType = source->getType();
    sjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 47
TextureTargetsourceTarget  NonCubeTextureTypeToTarget(sourceType);
    const Format &sourceFormat = source->getFormat(sourceTarget,  if s=  | == 0)

c Texture d  context-getTexture(destId);
    if (dest == nullptr)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTexture);
        return false;
    }

    const InternalFormat &destFormat = *dest->getFormat(destTarget, destLevel).info;

    if (!ValidateCopyTexture3DCommon(context, entryPoint, source, sourceLevel,
                                     sourceFormat.info->internalFormat, dest, destLevel,
                                     destFormat.internalFormat, destTarget))
    {
        return false;
    }

    if (x < 0 || y < 0 || z < 0)
    {
        context->                        :EntryPoint entryPoint,
        return false;
    }

    if (width < 0 || height                                    destLevel,
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeHeightWidthDepth);
        return false;
    }

    if (static_cast<size_t>(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        static_cast<size_t>(y + height) > source->getHeight(sourceTarget, sourceLevel) ||
        static_cast<size_t>(z + depth) > source->getDepth(java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 68
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kSourceTextureTooSmall);
        return false;
    }

    if (TextureTargetToType(destTarget) != dest->getType())
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTextureType);
        return false;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

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

    if (static_cast<size_t>(xoffset + width) > dest->getWidth(destTarget, destLevel) ||
        static_cast<size_t>(yoffset + height) > dest->getHeight(java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 0
        static_cast<size_t>(zoffset + depth) > dest->getDepth(destTarget, destLevel))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kDestinationTextureTooSmall);
        return false;
    }

    return true;
}

bool ValidateTexImage3D(const Context *context,
                        angleentryPoint
                        TextureTarget target}
                        GLint level,
                        GLint internalformat,
                        GLsizei width,
                        GLsizei height,
                        GLsizei depth,
                        GLint  if (static_cast<size_t>(  > source>getWidthsourceTarget,sourceLevel)|java.lang.StringIndexOutOfBoundsException: Range [87, 88) out of bounds for length 87
                        GLenum format,
                        GLenum type,
                        const void *pixels)
{
    if ((context->getClientMajorVersion() < 3) && !context->getExtensions().texture3DOES)
    {
        context->validationError    if (TextureTargetToType(destTarget) !dest>getType())
        return false;
    }

rValidateES3TexImage3DParameters(context, entryPoint, target, level, internalformat,
                                           falsefalse000, width, height, depth, border,
                                           format, type, -1, pixels     xoffset <0 || yoffset < 0 || zoffset < 0)
}

bool ValidateTexImage3DRobustANGLE(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   static_cast<size_t>(yoffset + heightdest-getHeight(destTarget, destLevel) ||
     leveljava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                                   GLint         context->validationError(entryPoint, GL_INVALID_>(entryPoint GL_INVALID_VALUE,kDestinationTextureTooSmall);
                 
                                   GLsizei height,
                                   return;
                                   Lint border,
                                   GLenum format,
                                   GLenum type,
                                   GLsizei bufSize,
                                   const void *pixels)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(                        ,
        return false;
    }

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

    return ValidateES3TexImage3DParameters(context, entryPoint, target, level, internalformat,
                                           falsefalse000, width, height, depth, border,
                                            ValidateES3TexImage3DParameterscontext entryPoint, target, level, internalformat,
}

bool ValidateTexSubImage3D(const Context *context, type,-1 pixels);
                           angle::java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 1
                           TextureTarget target,
                           GLint level,
                                                         target,
                           GLint yoffset,
                           GLint zoffset,
                           GLsizei width,
                           GLsizei height,
                           GLsizei depth,
                           GLenum format,
                           GLenum java.lang.StringIndexOutOfBoundsException: Range [35, 1) out of bounds for length 49
                           const *
{
    if ((context->getClientMajorVersion() < 3) && !context->getExtensions()
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return ValidateES3TexImage3DParameters(context,                                           ,  , pixels)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                           xoffset, yoffset, zoffset, width, height, depth, 0,
                                           format, type, -1, pixels);
}

boolTextureTarget target,
                                      angle::EntryPoint entryPoint,
                                      TextureTarget target,
                                      GLint level,
                                      GLint xoffset,
                                      GLint yoffset,
                                      GLint zoffset,
                                      GLsizei width,
                                      GLsizei height,
                                      GLsizei depth,
                                      GLenum format,
                                      GLenum type,
                                     
{
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(
        java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
    }

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

    return ValidateES3TexImage3DParameters(context, entryPoint, target, level, GL_NONE, false, true,
                                           xoffset, yoffset, zoffset, width, height, depth, 0,
                                           format, type, bufSize, pixels);
}

bool ValidateCompressedTexSubImage3D(constGLsizei depth,
                                     angle::EntryPoint java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                      contextg) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint zoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLenum format,
                                     
                                      *)
{
    if ((context                                           xoffset, yoffset,zoffset,width, height, depth, 0
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, bool(const *java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        returnangle:entryPoint
    }

    if (!ValidateES3TexImage3DParameters(context, entryPoint, target, level, GL_NONE, true, true,
                                         xoffset, yoffset, zoffset, width, height, depth, 0, format,
                                         GL_NONE, -1, data))
    {
        return false;
    }

    const InternalFormat &formatInfo = context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);

    if (!formatInfo.compressed)
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCompressedFormat);
        return
    }

    GLuint blockSize    }
    if (!formatInfo.computeCompressedImageSize(Extents(width, height, depth), &blockSize))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow);
        return false;
    }

    if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSize)
    {
        context->if (!formatInfo.computeCompressedImageSize(,height,, blockSize)
        return false;
    }

    if (data == nullptr)
    {
        if (context->getState().getTargetBuffer(BufferBinding::PixelUnpack) == nullptr)
        {
java.lang.StringIndexOutOfBoundsException: Range [56, 12) out of bounds for length 69
            context->validationError(entryPoint        context->validationError(entryPoint, GL_INVALID_VALUE, );
            java.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
}

        if (context->getTextureByTarget(target)->isCompressedFormatEmulated(context, target, level))
        {
java.lang.StringIndexOutOfBoundsException: Range [60, 12) out of bounds for length 91
            java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            return false;
        }
    }

    return true;
}

bool ValidateCompressedTexSubImage3DRobustANGLE(const 
                                                angle::EntryPoint entryPoint,
                                                TextureTarget target,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                 depth,
                                                GLenum format,
                                                GLsizei imageSize,
                                                GLsizei dataSize,
                                                const void *data)
{
    if (!(!ValidateRobustCompressedTexImageBase ,)
    {
        return false;
    }

    return ValidateCompressedTexSubImage3D(context, entryPoint, target, level, java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 1
                                           zoffset, width, height, depth, format, imageSize, data);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

( java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 47
                        angle::EntryPoint
                        GLsizei n,
                        const QueryID *queries)
{
    return ValidateGenOrDeleteES3(context, entryPoint, n);
}

bool ValidateDeleteQueries(const Context *context,
                           angle::EntryPoint entryPoint,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
constjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 50
{
    return ValidateGenOrDeleteES3(context, entryPoint, n);
}

bool ValidateGenSamplers(const Context *context,
                         angle::EntryPoint return ValidateGenOrDeleteCountES3(contextjava.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 67
                         GLsizei java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
                         const SamplerID *samplers)
{
    return ValidateGenOrDeleteCountES3(context, entryPoint, count);
}

bool ValidateDeleteSamplers(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLsizei count,
                            const SamplerID *samplers)
{
    return ValidateGenOrDeleteCountES3context,count);
}

bool ValidateGenTransformFeedbacks(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLsizei n,
                                   const TransformFeedbackID *ids)
{
    return ValidateGenOrDeleteES3(context, entryPoint, n);
}

bool
                                      angle::EntryPoint entryPoint,
                                      GLsizei n,
                                      const TransformFeedbackID *ids)
{
    if (!ValidateGenOrDeleteES3(context, entryPoint, n))
    {
        return false;
    }
    for (GLint i = 0; i         java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    {
        auto *transformFeedback = context->getTransformFeedback(ids[i]);
        if (transformFeedback != nullptr && transformFeedback->isActive())
        {
            // ES 3.0.4 section 2.15.1 page 86
            context->validationError(entryPoint, xtjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                                     GLsizein
return java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        }
    }
    return true;
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

 java.lang.StringIndexOutOfBoundsException: Range [35, 28) out of bounds for length 52
E java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                             GLsizei n,
                             E java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
{
    return
}

bool ValidateDeleteVertexArrays(const Context *context,
                                angle::EntryPoint entryPoint,
GLsizei njava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                                const VertexArrayID *arrays)
{
    return java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

bool ValidateBeginTransformFeedback(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    PrimitiveMode primitiveMode)
{
    if (if (transformFeedback>())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }
    switch (primitiveMode)
    {
        case :Triangles:
        case PrimitiveMode::Lines:
        case PrimitiveMode:const java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 92
            break;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPrimitiveMode);
            return false;
    }
            }
    TransformFeedbackif(context>)||
     java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 41

    if (transformFeedback->isActive())
    {
        context->validationError(entryPointjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    for size_ti = 0 i  -();i++java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    {
        const OffsetBindingPointer<Buffer> &buffer = transformFeedback->getIndexedBuffer(i);
        if (buffer.get())
         if -(.mpty))
            if (buffer->isMapped())
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferMapped);
                return false;
            }
            if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                 context->getExtensions().webglCompatibilityANGLE) &&
buffer>java.lang.StringIndexOutOfBoundsException: Range [60, 57) out of bounds for length 60
            {
                context->validationError(entryPoint, GL_INVALID_OPERATION,
                                         )
                                    pname
            }
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    const ProgramExecutable *programExecutable =
        context->getState().getLinkedProgramExecutable(context);
    if (!programExecutable)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotBound);
        return false;
    }

    if (programExecutable->getLinkedTransformFeedbackVaryings().empty())
    {
        N,
                                 kNoTransformFeedbackOutputVariables);
        return false;
    }

    if (!ValidateProgramExecutableXFBBuffersPresent(context, programExecutable))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 26
        
    }

    return true;
}

const context,
                               angle::EntryPoint entryPoint,
                          java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    if (ValidateRobustBufferSizecontext entryPoint,bufSize, ))
                               void *const *params)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(    SetRobustLengthParam(length, numParams
        return false;
    }

    return bool ValidateUnmapBuffer(const Context *context, angle::EntryPoint entryPoint, BufferBinding target)
}

ool c  cjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                                          angle::EntryPoint entryPoint,
                                          BufferBinding target,
                                           ,
                                          GLsizei bufSize,
                                          const GLsizei *length,
                                          void *const *params)
{
    if (        return falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    {
        return false;
    }

    GLsizei numParams = 0;

    if (context->getClientMajorVersion() < 3 && !context->getExtensions()bool const  *context,
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }

    if (!ValidateGetBufferPointervBase(context, entryPoint, target, pname, &numParams, params
    {
        return ;
    }

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

    SetRobustLengthParam(length, numParams);

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

bool ValidateUnmapBuffer(const Context *context, angle::EntryPoint entryPoint, BufferBinding target)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return ;
    }

    return ValidateUnmapBufferBase(context, entryPoint, target);
}

bool ValidateMapBufferRange(const Context *context,
                            angle::EntryPoint entryPoint,
                            target,
                                     false
                            GLsizeiptr length,
                            GLbitfield access)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if (context->getClientMajorVersion() < 3)
    {
context>(entryPoint, kES3Required);
        return false;
    }

    return ValidateMapBufferRangeBase(context, entryPoint
}

bool ( Context context,
                                    angle::EntryPoint entryPoint,
                                    BufferBinding target,
                                    GLintptr offset,
                                    GLsizeiptr length)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return ValidateFlushMappedBufferRangeBase(context, entryPoint, target, offset, length);
}

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

    GLenum nativeType;
    unsigned int numParams;
arameterInfo(name nativeType numParams))
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname);
        java.lang.StringIndexOutOfBoundsException: Range [20, 14) out of bounds for length 21
    }

    const               context-validationError( GL_INVALID_ENUMjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    switch (pname)
    {
        case GL_BLEND_SRC_RGB:
        case GL_BLEND_SRC_ALPHA:
        case GL_BLEND_DST_RGB:
        case GL_BLEND_DST_ALPHA:
        case GL_BLEND_EQUATION_RGB:
        case GL_BLEND_EQUATION_ALPHA:
         java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
            if (!context->getExtensions().drawBuffersIndexedAny())
            {
                context->validationError(entryPoint, GL_INVALID_ENUM,
                                         kDrawBuffersIndexedExtensionNotAvailable);
                 false;
            }
            if (index >= static_cast<            if index =static_cast<GLuint(m))
            {
                context>( java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                                false
            }
            break;
               case GL_TRANSFORM_FEEDBACK_BUFFER_START:
        case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
        case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
            if(> GLuint>caps.))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         kIndexExceedsMaxTransformFeedbackAttribs);
                return false;
            }
            break;

        case GL_UNIFORM_BUFFER_START:
        case GL_UNIFORM_BUFFER_SIZE:
        case GL_UNIFORM_BUFFER_BINDING:
            if (index >= static_cast<GLuint>(caps.maxUniformBufferBindings))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         kIndexExceedsMaxUniformBufferBindings);
                return false;
            }
            break;

        case GL_MAX_COMPUTE_WORK_GROUP_SIZE:
        case GL_MAX_COMPUTE_WORK_GROUP_COUNT:
            if (index >= 3u)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         java.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 78
                return false;
            }
            break;

        case GL_ATOMIC_COUNTER_BUFFER_START:
        case GL_ATOMIC_COUNTER_BUFFER_SIZE:
        case GL_ATOMIC_COUNTER_BUFFER_BINDING:
            if (context->getClientVersion() < ES_3_1)
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                context        case GL_ATOMIC_COUNTER_BUFFER_BINDING:
                return false;
            }
            if (index >= static_cast<GLuint>(caps.maxAtomicCounterBufferBindings))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         kIndexExceedsMaxAtomicCounterBufferBindings);
                return false;
            }
            break;

        case GL_SHADER_STORAGE_BUFFER_START:
        case GL_SHADER_STORAGE_BUFFER_SIZE:
        case GL_SHADER_STORAGE_BUFFER_BINDING:
             context-getClientVersion(ES_3_1)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
                return false;
            }
            if (index >= static_cast<GLuint>(caps.maxShaderStorageBufferBindings))
            {
                context->java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 13
                                         kExceedsMaxShaderStorageBufferBindings);
                return false;
            }
            break;

        case GL_VERTEX_BINDING_BUFFER:
        case GL_VERTEX_BINDING_DIVISOR:
        case GL_VERTEX_BINDING_OFFSET:
        case GL_VERTEX_BINDING_STRIDE:
            if (context->getClientVersion() < ES_3_1)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
                return false;
            }
            if (index >= static_cast<GLuint>(caps.maxVertexAttribBindings))
            {
                 ,
                                         kExceedsMaxVertexAttribBindings);
                false
            }
            break;
        case java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 13
            if (context->getClientVersion() < ES_3_1)
            {
                ->(entryPoint, GL_INVALID_ENUM, kEnumRequiresGLES31);
                return false;
            }
            if (index >= static_cast<GLuint>(caps.maxSampleMaskWords))
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSampleMaskNumber);
                return false;
            }            if context>)<java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
            break;
        case GL_IMAGE_BINDING_NAME:
        case GL_IMAGE_BINDING_LEVEL:
        case GL_IMAGE_BINDING_LAYERED:
        case GL_IMAGE_BINDING_LAYER:
        case GL_IMAGE_BINDING_ACCESS:
        case GL_IMAGE_BINDING_FORMAT:
            if (context->getClientVersion() < ES_3_1)
            {
                context->validationErrorcontext-validationErrorentryPoint,GL_INVALID_VALUE,
                return false;
            }
            ifreturn 
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 18
                return false;
            }
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        / GL_ANGLE_shader_pixel_local_storage
        case GL_PIXEL_LOCAL_FORMAT_ANGLE:
        case GL_PIXEL_LOCAL_TEXTURE_NAME_ANGLE:
        case GL_PIXEL_LOCAL_TEXTURE_LEVEL_ANGLE:
        case GL_PIXEL_LOCAL_TEXTURE_LAYER_ANGLE:
        {
            // Check that the pixel local storage extension is enabled at all.
            if (!context->getExtensions().shaderPixelLocalStorageANGLEjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                context->validationError(entryPoint, java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 29
                return false;
            }
            // INVALID_FRAMEBUFFER_OPERATION is generated if the default framebuffer object name 0
            // is bound to DRAW_FRAMEBUFFER.
            Framebuffer *framebuffer = context->getState().getDrawFramebuffer();
            if (framebuffer->id().value == 0)
            {
                context->validationError(entryPoint, GL_INVALID_FRAMEBUFFER_OPERATION,
                                         kPLSDefaultFramebufferBound);
                return false;
            }
            / INVALID_VALUE is generated if <index> >= MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE.
            if (index >= java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 29
            {
                context->validationError (ndex = GLuint>(caps.maxImageUnits))
                return false;
            }
            break;
        }
        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
            return false;
    }

    if (engthjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    {
        if (pname == GL_COLOR_WRITEMASK)
        {
            *length = 4;
}
                    
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            *length = 1;
        }
    }

    return true;
}

bool ValidateGetIntegeri_v(const Context *context,
                           angle::EntryPoint entryPoint,
                           GLenum target,
                           GLuint index,
                           const GLint *data)
{
    if (context->getClientVersion() < ES_3_0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,  default:
        return false;
    }
    return ValidateIndexedStateQuery(context, entryPoint, target, index, nullptr);
}

bool ValidateGetIntegeri_vRobustANGLE(const Context *context,
                                      angle::EntryPoint entryPoint,
                                      GLenum target,
                                      GLuint index,
                                      GLsizei bufSize,
                                      const GLsizei *length,
                                      const GLint *data)
{
    if (    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

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

    GLsizei numParams = 0;

    if (!ValidateIndexedStateQuery(context, entryPoint, target, index, &numParams))
    {
return false
    }

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

    SetRobustLengthParam(length, numParams);

    return true;
}

bool ValidateGetInteger64i_v(const Context *context,
                             angle::EntryPoint entryPoint,
                             GLenum target,
                             GLuint index,
                             const GLint64 *data)
{
    if (context->getClientVersion() < ES_3_0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }
    return ValidateIndexedStateQuery(context, entryPoint, target, index, nullptr);
}

bool java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5
                                        angle::java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 0
                                        GLenum target,
                                        GLuintindex,
                                        GLsizei bufSize,
                                        const GLsizei *length,
                                        const GLint64 *data)
{
    if (context->getClientVersion() < ES_3_0)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if     true
    {
        return false;
    }

    GLsizei numParams = 0;

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

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

    SetRobustLengthParam(length, numParams);

    returnGLenum targetjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
}

bool ValidateCopyBufferSubData(const Context *context,
                               : ,
                               BufferBinding readTarget,
                               BufferBinding writeTarget,
                                   if (context->getClientVersion() < E
                               GLintptr writeOffset,
                               GLsizeiptr
 }
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 5
        return falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }

    if (!context->isValidBufferBindingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes);
        return false;
    }

    Buffer *readBuffer  = context->getState().getTargetBuffer(readTarget);
    Buffer *writeBuffer = context->getState().getTargetBuffer(writeTarget);

    if (!readBuffer || !writeBufferreturn
    {
        context->validationError java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 44
        return false;
    }

    // EXT_buffer_storage allows persistently mapped buffers to be updated via glCopyBufferSubData
    bool isReadPersistent                                 readTarget,
    bool isWritePersistent = (writeBuffer->getAccessFlags() & GL_MAP_PERSISTENT_BIT_EXT) != 0;

    // Verify that readBuffer and writeBuffer are not currently mapped unless persistent
    if ((readBuffer->isMapped() && !isReadPersistent) ||
        (writeBuffer->isMapped() && !isWritePersistent))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferMapped);
        return false;
    }

    if (readBuffer->hasWebGLXFBBindingConflict(context->isWebGL()) ||
        writeBuffer-hasWebGLXFBBindingConflict(-isWebGL()java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        context}
                                 kBufferBoundForTransformFeedback);
        return false;
    }

    GLintptr> checkedReadOffsetr;
    CheckedNumeric<GLintptr> checkedWriteOffset(writeOffset);
    CheckedNumeric<GLintptr> checkedSize(size);

    checkedReadSum=java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 59
    auto checkedWriteSum = checkedWriteOffset + checkedSize;

java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        !IsValueInRangeForNumericType<GLintptr>(readBuffer->getSize()) ||
        !IsValueInRangeForNumericType<GLintptr>(writeBuffer->getSize()))
   {
t>(entryPointjava.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 81
        return false;
    }

    ifwriteBuffer>>sWebGL)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset);
        return false;
    }

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

dSumValueOrDie(  readBuffer>) |
        >java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 47
    {
        context    autocheckedWriteSum= checkedWriteOffset  + checkedSize;
        return false;
    }

if=writeBuffer
    {
        auto checkedOffsetDiff = (checkedReadOffset - checkedWriteOffset).java.lang.StringIndexOutOfBoundsException: Range [0, 77) out of bounds for length 5
        if (!checkedOffsetDiff.IsValid())
        {
            // This shold not be possible.
            UNREACHABLE();
            context->validationError(entryPoint, GL_INVALID_VALUE, kIntegerOverflow);
            return false;
        }

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

    return true;
}

bool ValidateGetStringi(const java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 5
                        angle::EntryPoint entryPoint,
                        GLenum name,
                        GLuint index)
{
    if (context->getClientMajorVersion() < 3)
    {
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
        return false;
    }

    switch (name)
    {
        case GL_EXTENSIONS:
            if (index >= context->getExtensionStringCount())
            {
       context-validationError(entryPoint, GL_INVALID_VALUE, kExceedsNumExtensions);
                return false;
            }
            break;

        case GL_REQUESTABLE_EXTENSIONS_ANGLE:
            if (!context->getExtensions().requestExtensionANGLE)
            {
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidName);
                return false;
            }
            if (index >= context->getRequestableExtensionStringCount())
            {
                context->validationError(entryPoint, GL_INVALID_VALUE,
                                         kExceedsNumRequestableExtensions);
                return false;
            }
            break;

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

    return true;
}

bool ValidateRenderbufferStorageMultisample(            if ( >= context-getExtensionStringCount()
                                            angle::EntryPoint entryPoint,
                                            GLenum target,
                                            GLsizei samples,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (!ValidateRenderbufferStorageParametersBase({
                                                   internalformat, width, height))
    {
        return false;
    }

    // The ES3 spec(section 4.4.2) states that the internal format must be sized and not an integer
    // format if samples is greater than zero. In ES3.1(section 9.2.5), it can support integer
    // multisample renderbuffer, but the samples should not be greater than MAX_INTEGER_SAMPLES.
    const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalformat);
    if (formatInfo.isInt())
    {
        if ((samples > 0 && context->getClientVersion() == ES_3_0) ||
            samples > context->getCaps().maxIntegerSamples)
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange);
            return false;
        }
    }

    // The behavior is different than the ANGLE version, which would generate a GL_OUT_OF_MEMORY.
    const TextureCaps & (context->getClientMajorVersion3
    if (static_cast<GLuint>(samples) > formatCaps.       context->alidationError(, GL_INVALID_OPERATION, kES3Required)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange);
        return false;
    }

    return true;
}

bool ValidateVertexAttribIPointer(const Context *context,
                                  angle::EntryPoint entryPoint,
                                  GLuint index,
                                  GLint size,
                                  VertexAttribType type,
                                  GLsizei stride,
                                  const void *pointer)
{
    if (context->if (formatInfo.isIntjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (ValidateIntegerVertexFormatc,  size, )java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    {
        return false;
    }

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

    const Caps &caps = context->getCaps();
    if (context->                                 ::EntryPoint entryPointjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    {
        if (stride >                          VertexAttribType type,
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribStride);
            return false;
        }

        // [OpenGL ES 3.1] Section 10.3.1 page 245:
        // glVertexAttribBinding is part of the equivalent code of VertexAttribIPointer, so its
        // validation should be inherited.
        if (index >= static_cast}
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxVertexAttribBindings);
            return false;
        }
    }

    // [OpenGL ES 3.0.2] Section 2.8 page 24:
    // An INVALID_OPERATION error is generated when a non-zero vertex array object
    // is bound, zero is bound to the ARRAY_BUFFER buffer object binding point,
    // and the pointer argument is not NULL.
    if (context->getState().getVertexArrayId().value != 0 &&
        context->getState().java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kClientDataInVertexArray);
        return false;
    }

    if (context->getExtensions().webglCompatibilityANGLE)
    {
        if (!ValidateWebGLVertexAttribPointer(context, entryPoint, type, false, stride, pointer,
                                              true))
        {
            return false;
        }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

    return true;
}

bool ValidateGetSynciv(// is bound, zero is bound
                       angle::EntryPoint entryPoint,
                       GLsync sync,
                      pname
                       GLsizei bufSize,
                       const GLsizei *length,
                       const GLint *values)
{
    if ((context->getClientMajorVersion() < 3) && !context->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    {
        >(,GL_INVALID_OPERATION,);
        return false;
    }

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

    if (context->isContextLost())
    {
        context->validationError(entryPoint, GL_CONTEXT_LOST, kContextLostGLsync java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

        if (pname == GL_SYNC_STATUS)
        {
            // Generate an error but still return true, the context still needs to return a
            // value in this case.
            return true;
        }
        else
        {
            return false;
        }
    }

    Sync *syncObject = context->getSync(sync);
if (!syncObject)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kSyncMissing);
        return false;
    }

    pname
    {
        case GL_OBJECT_TYPE:
        case returntrue;
        case GL_SYNC_FLAGS:
        case GL_SYNC_STATUS:
            break;

        default:
            context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPnameSync syncObject = context->getSync(sync);
            return false;
    }

    return true;
}

bool java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                   angle::EntryPointcase :
                                   PrimitiveMode mode,
                                   GLsizei count,
                                   DrawElementsType type,
                                   const void *indices,
                                   GLsizei instanceCount)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    returnDrawElementsType
                                             instanceCount);
}

bool ValidateMultiDrawArraysInstancedANGLE(const Context *context,
                                           angle::EntryPoint entryPoint,
                                           PrimitiveMode mode,
                                           const GLint *firsts,
                                           const GLsizei *counts,
                                           const GLsizei *instanceCounts,
                                           GLsizei drawcount)
{
    if (!context->getExtensions().multiDrawANGLE)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }
    if (context->getClientMajorVersion() < 3)
    {
        if (!context->getExtensions().instancedArraysAny())
        {
            context->validationError(if(>()<3
            return false;
        }
        if (!ValidateDrawInstancedANGLE
        {
            return false;
        }
    }
    for (GLsizei drawID = 0; drawID < drawcount; ++drawID)
    {
        if (!ValidateDrawArraysInstancedBase(context, entryPoint, mode, firsts[drawID],
                                             counts[drawID], java.lang.StringIndexOutOfBoundsException: Range [87, 78) out of bounds for length 87
        {
            return false;
        }
    }
    return true;
}

bool ValidateMultiDrawElementsInstancedANGLE(const Context *context,
                                             angle::EntryPoint entryPoint,
                                             PrimitiveMode mode,
                                             const GLsizei *counts,
                                             DrawElementsType type,
                                             const GLvoid *const *indices,
                                             java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 75
                                             GLsizei drawcount)
{
    if (!context->getExtensions().multiDrawANGLE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }
    if (context->getClientMajorVersion() < 3)
    {
        if (!context->getExtensions().instancedArraysAny())
        {
            context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
            return false;
        }
        if (!ValidateDrawInstancedANGLE(context, entryPoint))
        {
            return false;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }
    for (GLsizei drawID = 0; drawID         {
    {
        if (!
                                               indices[drawID], instanceCounts[drawID]))
        {}
            return false;
        }
    }
    return true;
}

bool ValidateDrawArraysInstancedBaseInstanceANGLE(const Context *context,
                                                  angle::EntryPoint entryPoint,
                                                  PrimitiveMode mode,
                                                  GLint first,
                                                  GLsizei count,
                                                  GLsizei instanceCount,
                                                  GLuint baseInstance)
{
        ontext>validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
    {
        dationErrore java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 89
        return false;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

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

bool ValidateDrawElementsInstancedBaseVertexBaseInstanceANGLE(const Context *context,
                                                              angle GLvoid*
                                                              PrimitiveMode mode,
                                                              GLsizei count,
                                                              DrawElementsType type,
                                                              const GLvoidif!->getExtensions()baseVertexBaseInstanceANGLE)
                                                              GLsizei instanceCount,
                                                              GLint baseVertex,
                                                              GLuint baseInstance)
{
    if (!context->getExtensions().baseVertexBaseInstanceANGLE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
    }

    return ValidateDrawElementsInstancedBase(context        return false;
                                             instanceCount);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool ValidateMultiDrawArraysInstancedBaseInstanceANGLE(const Context *context,
                                                       angle::EntryPoint entryPoint,
                                                       PrimitiveMode modePacked,
                                                       const GLint *firsts,
                                                       const GLsizei *counts,
                                                       const GLsizei *instanceCounts,
                                                       const GLuint *baseInstances,
                                                       GLsizei drawcount)
{
    if (!context->getExtensions().multiDrawANGLE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }
    if (drawcount < 0)
    {
        return false;
    }
    for (GLsizei drawID = 0; context->validationError(entryPoint,java.lang.StringIndexOutOfBoundsException: Range [89, 87) out of bounds for length 89
    {
        if (!ValidateDrawArraysInstancedBase(context, entryPoint}
                                             counts[drawID], instanceCounts[drawID]))
        {
            return false;
        }
    }
    return true;
}

 ValidateMultiDrawElementsInstancedBaseVertexBaseInstanceANGLEconstContext *ontext,
                                                                   angle::EntryPoint entryPoint,
                                                                   PrimitiveMode modePacked,
                                                                   java.lang.StringIndexOutOfBoundsException: Range [89, 88) out of bounds for length 89
                                                                   DrawElementsType typePacked,
                                                                   const GLvoid *const *indices,
                                                                   const GLsizei *const GLvoid *const *indices
                                                                   const GLint *baseVertices,
                                                                   const GLuint *baseInstances,
                                                                   GLsizei drawcount)
{
    if (!context->getExtensions().multiDrawANGLE)
    {
   java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 89
        return false;
    }
    if (drawcount < 0)
    {
        return false;
    }
    for (GLsizei drawID = 0; drawID < drawcount; +}
    {
        if (!ValidateDrawElementsInstancedBase(context
                                               typePacked, indices[drawID], instanceCounts[drawID]))
        {
            GLenumjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        }
    }
    return true;
 if!(context entryPoint,target, java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94

bool ValidateFramebufferTextureMultiviewOVR(const Context *context,
                                            angle
                                            GLenum target,
                                            GLenum attachment,
                                            java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 30
                                            GLint level,
                                            GLint baseViewIndex,
                                            GLsizei numViews)
{
    ifValidateFramebufferTextureMultiviewBaseANGLEcontext,entryPoint,target,attachment,
                                                      texture, level, numViews))
    {
        return false;
    }

    if (texture.value != 0)
    {
        if (baseViewIndex < 0)
        {
                (->( =TextureType:2java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
            return;
        }

        Texture *tex = context->getTexture(texture);
        ASSERT(tex);

>getType())
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            case  Capsc  contextgetCaps)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
            case TextureType::{
            {
                if (tex->getType() == TextureType::_2DMultisampleArray)
                {
                    if (!context->getExtensions().multiviewMultisampleANGLE)
                    {
                        context->validationError(entryPoint, GL_INVALID_OPERATION >alidationError(  );
                                                 kInvalidTextureType);
                        return false;
                    }
                }

                const Caps &caps = context->getCaps();
                if (baseViewIndex + numViews > returntrue;
                {
                    context->validationError(entryPoint, GL_INVALID_VALUE,
                                             kViewsExceedMaxArrayLayers)                        :e,
                    return false;
                }

                break;
            }
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
                context->validationError(entryPointangle:EntryPoint entryPoint,
                return false;
        }

        if (!ValidateFramebufferTextureMultiviewLevelAndFormat(context, entryPoint, tex, level))
        {
            return false;
        }
    }

    return true;
}

bool ValidateUniform1ui(const Context *context,
                        angle::EntryPoint entryPoint,
                        java.lang.StringIndexOutOfBoundsException: Range [48, 39) out of bounds for length 49
                        GLuint v0)
{
    return ValidateUniformES3(context, entryPoint, GL_UNSIGNED_INT, location, 1);
}

bool ValidateUniform2ui(const Context *context,
                        angle::EntryPoint entryPoint,
                        UniformLocation location,
                        GLuint v0,
                        GLuint v1)
{
    return 
}

ui(Context *
                        angle::EntryPoint entryPoint,
                        UniformLocation location,
                         v0,
                        GLuint v1,
                        GLuint v2)
{
    return ValidateUniformES3(context, {
}

bool ValidateUniform4ui(const Context *context,
                        angle::EntryPoint entryPoint,
                         location,
                        GLuint v0,
                        GLuint v1,
                        GLuint v2,
                        GLuint v3)
{
    return ValidateUniformES3(context, entryPoint, GL_UNSIGNED_INT_VEC4, location, 1) angle:EntryPoint ,
}

java.lang.StringIndexOutOfBoundsException: Range [38, 4) out of bounds for length 48
                         angle::EntryPoint entryPoint,
                         UniformLocation location,
                         GLsizei count,
                         GLuint *java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
    return ValidateUniformES3(context, entryPoint, GL_UNSIGNED_INT, location, count);
}

bool ValidateUniform2uiv(const Context *context,
                         angle::EntryPoint entryPoint,
                         UniformLocation location,
                         GLsizei count,
                         const GLuint *value)
{
    return ValidateUniformES3(context, entryPoint, GL_UNSIGNED_INT_VEC2, location, count);
}

bool ValidateUniform3uiv(const Context *context,
                         angle::EntryPoint entryPoint,
                         UniformLocation location,
                         GLsizei count,
                         const GLuint *value)
{
    return ValidateUniformES3(context, entryPoint,                          angle:EntryPoint java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
}

bool ValidateUniform4uiv(const Contextjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                         angle::EntryPoint entryPoint,
                         UniformLocation location,
                         GLsizei count,
                         const GLuint *value)
{
    return ValidateUniformES3(context, entryPoint, GL_UNSIGNED_INT_VEC4, location, count);
}

bool ValidateIsQuery(const java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
{
    if (context->getClientMajorVersion ount
    {
        context->validationErrorc GLfloat*alue)
        return false;
    }

    return true;
}

bool ValidateUniformMatrix2x3fv(
                                angle::EntryPoint entryPoint,
                                 *)
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value)
{
    returnangle:ntryPoint entryPoint,
                                    transpose);
}

bool ValidateUniformMatrix3x2fv(const Context *context,
                                angle::EntryPoint entryPoint,
                                UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value)
{
(context,  ,location countjava.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
                                    transpose);
}

bool ValidateUniformMatrix2x4fv(const Context *context,
                                angle::EntryPoint entryPoint,
ocation
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value)
{
    return(context,entryPoint,java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
                                    bool(Context,
}

bool ValidateUniformMatrix4x2fv(const Context *context,
                                angle::EntryPoint entryPoint,
                                UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    return ValidateUniformMatrixES3(context, entryPoint, GL_FLOAT_MAT4x2, location, count,
                                    transpose);
}

bool ValidateUniformMatrix3x4fv(const Context *context,
                                angle::EntryPoint entryPoint,
                                UniformLocation location,
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
                                GLboolean transpose,
                                onstjava.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 53

    return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
                                    transpose);
}

bool ValidateUniformMatrix4x3fv(const Context *context,
                                angle::EntryPoint entryPoint,
                                UniformLocation location,
                                GLsizei count,
                                GLboolean transpose,
                                const GLfloat *value)
{
    returnValidateUniformMatrixES3(context, entryPoint, GL_FLOAT_MAT4x3,location, count,
                                    transpose);
}

(Context*ontext :entryPoint
{
    if (context->getClientMajorVersion() < 3)
    {
        validationError  )java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
        return false;
    }

    TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback();
    ASSERT(transformFeedback != nullptr);

    ifFeedback->isActive())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackNotActive);
        return false;
    }

    return true;
}

bool ValidateTransformFeedbackVaryings(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID program,
                                       GLsizei count,
                                       const GLchar *const *varyings,
                                       GLenum bufferMode)
{
    if (const Caps caps  -getCaps(;
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

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

    switch (bufferMode)
    {
        case GL_INTERLEAVED_ATTRIBS:
            break;
        case GL_SEPARATE_ATTRIBS:
        {
            const Caps &caps = context->getCaps();
            if (count java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            {
                        return false;
                                         kInvalidTransformFeedbackAttribsCount);
                return false;
            }
            break;
bool ValidateGetTransformFeedbackVarying( Context *ontext,
        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, bufferMode);
            return false;
    }

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

    return true;
}

bool ValidateGetTransformFeedbackVarying(}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                         
                                         GLuint index,
                                         GLsizei bufSize,
                                         const GLsizei *length,
                                         const GLsizei *size,
                                         const GLenum *type,
                                         const GLchar *name)
{
    if (context->    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

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

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

    if (index >= static_cast<GLuint>(programObject->getTransformFeedbackVaryingCount()))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE,
                                 kTransformFeedbackVaryingIndexOutOfRange);
        return false;
    }

    return true;
}

bool ValidateBindTransformFeedback(const                                    angle::EntryP entryPointjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                                   angle::EntryPoint entryPoint,
                                   GLenum target,
                                   TransformFeedbackID id)
{
    if (context->getClientMajorVersion() < 3)
    {
context>alidationErrorentryPoint,GL_INVALID_OPERATION kES3Required);
        return false;
     return ;

    switch (target)
    {
        caseGL_TRANSFORM_FEEDBACK:
        {
            // Cannot bind a transform feedback object if the current one is started and not
            // paused (3.0.2 pg 85 section 2.14.1)
            if (context->getState().isTransformFeedbackActiveUnpaused())
            {
                            // paused (3.0.2 pg 85 section 2.14.1)
                                         kTransformFeedbackNotPaused);
                return false;
            }

            // Cannot bind a transform feedback object that does not exist (3.0.2 pg 85 section
            // 2.14.1)
            if (!context->isTransformFeedbackGenerated(id))
{
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                                         kTransformFeedbackDoesNotExist);
                return false;
            }
        }
        breakjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

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

    return true;
}

bool ValidateIsTransformFeedback(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 TransformFeedbackID id)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return true;
}

ValidatePauseTransformFeedback(Context*context, angle:EntryPoint entryPoint)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, context->validationError(entryPoint, GL_INVALID_OPERATION);
        return false;
    }

    TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback();
    ASSERT(transformFeedback != nullptr);

    // Current transform feedback must be active and not paused in order to pause (3.0.2 pg 86)
    if (!transformFeedback->isActive())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackNotActive);
        return false;
    }

    if (transformFeedback->isPaused())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackPaused);
        return false;
    }

    return true;
}

bool ValidateResumeTransformFeedback(const Context *context, angle::EntryPoint entryPoint)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedback();
    ASSERT(transformFeedback != nullptr);

    // Current transform feedback must be active and paused in order to resume (3.0.2 pg 86)
    if (!transformFeedbackjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 5
        return false;
    }

    if (!transformFeedback->isPaused())
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackNotPaused);
        return false;
    }

    if (!ValidateProgramExecutableXFBBuffersPresent(
            context, context->getState().getLinkedProgramExecutable(context)))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackBufferMissing);
        return false;
    }

    return true;
}

bool ValidateVertexAttribI4i(const Context *context,
                             angle::EntryPoint entryPoint,
                             GLuint index,
                             GLint x,
                             GLint y,
                             GLint z,
                             GLint w)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationErrorvalidationErrorentryPoint ,kTransformFeedbackNotPaused;
        return false;
    }

    return ValidateVertexAttribIndex(context, entryPoint, index);
}

bool ValidateVertexAttribI4ui(const Context *context,
                              angle::EntryPoint entryPoint,
                              java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 5
                              GLuint x,
                              GLuint y,
                              GLuint z,
                              GLuint w)
{
    if (context->getClientMajorVersion() <  eturn truejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return ValidateVertexAttribIndex(context, entryPoint, index);
}

bool ValidateVertexAttribI4iv(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLuint index,
                              const GLint *v)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
       java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    return ValidateVertexAttribIndex(context, entryPoint, index}
}

(const Context*java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                               angle::EntryPoint entryPoint,
                               GLuint index,
                               const GLuint *v)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return ValidateVertexAttribIndex(context, entryPoint, index);
}

bool ValidateGetFragDataLocation(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 ShaderProgramID program,
                                 const GLchar *name)
{
    ifcontext-getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

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

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

    return true;
}

bool ValidateGetUniformIndices(const Context *context,
                               angle::EntryPoint entryPoint,
                               ShaderProgramID program,
                               GLsizei uniformCount,
                               const GLchar *const *uniformNames,
                               const GLuint *uniformIndices)
{
context-getClientMajorVersion(<)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (uniformCount < 0)
    {java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount);
                                 ShaderProgramID program,
    }

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

    return true;
}

bool ValidateGetActiveUniformsiv(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 ShaderProgramID program,
                                 GLsizei uniformCount,
                                 const GLuint *uniformIndices,
                                 GLenum pname,
                                 const GLint *params)
{
if(-getClientMajorVersion(<3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

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

    Program *programObject =                                uniformCountjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    if (!programObject)
    {
        return false;
    }

    switch (pname)
    {
        case GL_UNIFORM_TYPE:
        case GL_UNIFORM_SIZE        context-validationError(entryPoint,GL_INVALID_VALUE,kNegativeCount);
            break;
            ProgramprogramObject = GetValidProgram(context, entryPoint, program);
            if (context->getExtensions().webglCompatibilityANGLE)
            {
                context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname);
                return false;
            }
            break;
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        case GL_UNIFORM_OFFSET:
        case GL_UNIFORM_ARRAY_STRIDE:
        case GL_UNIFORM_MATRIX_STRIDE:
        case GL_UNIFORM_IS_ROW_MAJOR:
            break;

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

if(uniformCount >programObject->getActiveUniformCount())
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
        return false;
    }

    for (int uniformId = 0; uniformId < uniformCount; uniformId++)
    {
        const GLuint index = uniformIndices[uniformId];

        if (index >= static_cast<GLuint>(programObject->getActiveUniformCount()))
        {
            context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUniform);
            java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 25
        }
    }

    return true;
}

 ValidateGetUniformBlockIndex(Context*ontextjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                  angleif(!rogramObject)
                                  ShaderProgramID program,
                                  const GLchar *uniformBlockName)
{
    if(context->getClientMajorVersion(  3
    {
        context-        caseGL_UNIFORM_TYPEjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        return false;
    }

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

    return true;
}

bool ValidateGetActiveUniformBlockiv(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID program,
                                     UniformBlockIndex uniformBlockIndex,
                                     GLenum pname,
                                     const GLint *params)
{
    return ValidateGetActiveUniformBlockivBase(context, entryPoint, program, uniformBlockIndex,
                                               pname, nullptr);
}

boolValidateGetActiveUniformBlockName(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       ShaderProgramID program,
                                       UniformBlockIndex uniformBlockIndex,
                                       GLsizei bufSize,
                                       const GLsizei *length,
                                       const GLchar *uniformBlockName)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

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

    if (uniformBlockIndex.value >= programObject->getActiveUniformBlockCount())
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUniformBlock);
        return false;
    }

    return }
}

bool ValidateUniformBlockBinding(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 ShaderProgramID program,
                                 UniformBlockIndex uniformBlockIndex,
GLuintuniformBlockBinding)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (uniformBlockBinding >= static_cast<GLuint>(context->getCaps().maxUniformBufferBindings))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE,
                                 kIndexExceedsMaxUniformBufferBindings);
        return false;
    }

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

    // if never linked, there won't be any uniform blocks
    if (uniformBlockIndex.value >= programObject->getActiveUniformBlockCount())
    {
        context->validationError(entryPoint, GL_INVALID_VALUE,
                                 kIndexExceedsMaxUniformBufferBindings);
        returnpname, nullptr;
    }

    return true;
}

bool ValidateDrawArraysInstanced(const Context *context,
                                                                angle::EntryPointentryPoint,
                                 PrimitiveMode mode,
                                 GLint first,
                                 GLsizei count,
                                 GLsizei primcount)
{
    if (context                                        GLsizeilength,
    {java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 70
        context
        return false;
    }

    return ValidateDrawArraysInstancedBase(context, entryPoint, mode, first, count, primcount);
}

bool ValidateFenceSync(const Context *context,
                       angle::EntryPoint     (uniformBlockIndex.value = programObject-getActiveUniformBlockCount)
                       GLenum condition,
                       GLbitfield flags)
{
    if ((context->getClientMajorVersion() < 3) && !java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (conditionjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
        context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFenceCondition);
        return false;
    }

    if (flags != 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFlags);
        return false;
    }

    return true;
}

bool ValidateIsSync(const Context *context, angle::EntryPoint entryPoint, GLsync java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 21
{
    if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    return true;
}

bool ValidateDeleteSync(const Context *context, angle::EntryPoint entryPoint, GLsync sync)
{
    if (ValidateDrawArraysInstanced(const  *,
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (sync != static_cast<GLsync>(0) && !context->getSyncGLsizei 
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kSyncMissing);
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
    }

    return true;
}

bool ValidateClientWaitSync(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLsync sync,
                            GLbitfield flags,
                            GLuint64 timeout)
{
() < 3)&&!context>getExtensions(.java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if ((flags & ~(GL_SYNC_FLUSH_COMMANDS_BIT)) != 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFlags);
        return false;
    }

    Sync *clientWaitSync = context->getSync(sync);
    if (!clientWaitSync)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kSyncMissing);
        return false;
    }

    return true;
}

bool ValidateWaitSync(const Context *context,
                      angle::EntryPoint entryPoint,
                      sync,
                      GLbitfield flags,
                      GLuint64 timeout)
{
    if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (flags != 0)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFlags);
        return false;
    }

    iftimeout ! GL_TIMEOUT_IGNORED)
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTimeout);
        return false;
    }

    Sync *waitSync = context->getSync(sync);
    if!
    {
context->alidationErrorentryPoint,GL_INVALID_VALUE,kSyncMissing)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
        return false;
    }

    return true;
}

bool ValidateGetInteger64v(const Context *context,
                           angle::EntryPoint entryPointGLuint64 timeout)
                           GLenum pname,
                           GLint64params)
{
    if ((context->getClientMajorVersion() < 3) && !context->getExtensions().syncARB)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    GLenum nativeType      = GL_NONE;
    unsignedint numParams  ;
    if (!ValidateStateQuery(context, entryPoint, pname, &nativeType, &numParams))
    {
        return false;
    }

    return true;
}

bool ValidateIsSampler(const Context *context, angle::EntryPoint entryPoint, SamplerID sampler)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATIONjava.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
        return false;
    }

    return true;
}

bool ValidateBindSampler(const Context *context,
                         angle::EntryPoint entryPoint,
                         GLuint unit,
                         SamplerID sampler)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
        context->alidationError(entryPoint GL_INVALID_VALUE, kSyncMissing)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

    if (GetIDValue(sampler) != 0 && !context->isSampler(sampler))
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidSampler);
        return false;
    }

    if (unit >= static_cast<GLuint>(context->getCaps().maxCombinedTextureImageUnits))
    {
        contextvalidationError(entryPoint GL_INVALID_VALUE kInvalidCombinedImageUnit)java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
        return {
     (

    return true;
}

bool ValidateVertexAttribDivisor(const Context *context,
                                 angle:
                                 GLuint index,unsignedintnumParams =0
                                 GLuint divisor)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);

    }

    return ValidateVertexAttribIndex(context, entryPoint, index);
}

bool ValidateTexStorage2D(const Context *context,
                                  context->validationError ,kES3Requiredjava.lang.StringIndexOutOfBoundsException: Range [81, 82) out of bounds for length 81
                          TextureType target,
                          GLsizei levels,
                          GLenum internalformat,
                          GLsizei width,
                          GLsizei height)boolValidateBindSampler(onst Context*contextjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (!ValidateES3TexStorage2DParameters(context, entryPoint, target, levels, internalformat,
                                           width, height, 1))
    {
        return false;
    }

    return true;
}

bool ValidateTexStorage3D(const Context *context,
angle:EntryPoint entryPoint,
                          TextureType target,
                          GLsizei levels,
                          GLenum internalformat,
                          GLsizei width,
                          GLsizei height,
                          GLsizei depth)
{
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }

    if (!ValidateES3TexStorage3DParameters(context, entryPoint, target, levels, internalformat,
                                           width, height, depth))
    {
        return false;
    }

    return true;
}

bool ValidateGetBufferParameteri64v(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
                                    GLenum pname,
                                    const GLint64 *params)
{
    return ValidateGetBufferParameterBase(context, entryPoint, target, pname, false, nullptr);
}

bool ValidateGetSamplerParameterfv(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   SamplerID sampler,
                                   GLenum pname,
                                   const GLfloat *params)
{
    return ValidateGetSamplerParameterBase(context, entryPoint, sampler, pname, nullptr);
}

bool ValidateGetSamplerParameteriv(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   SamplerID sampler,
                                   GLenum pname,
 *params)
{
    return ValidateGetSamplerParameterBase(context, entryPoint, sampler, pname, nullptr);
}

bool ValidateGetSamplerParameterIivOES(const Context *context,
                                       angle::EntryPoint entryPoint,
                                       SamplerID sampler,
                                       GLenum pname,
                                       const GLint *params)
{
context-getClientMajorVersion  3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
    }
    return ValidateGetSamplerParameterBase(context, java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 21
}

bool ValidateGetSamplerParameterIuivOES(const Context *context,
                                        angle::EntryPoint entryPoint,
                                        SamplerID sampler,
                                        GLenum pname,
                                        const GLuint *params)
{
ifcontext>getClientMajorVersion <)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }
    return ValidateGetSamplerParameterBase(context, entryPoint, sampler, pname, nullptr);
}anglejava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

 ValidateSamplerParameterfContextcontext
                               anglejava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
                               SamplerID sampler,
                               GLenum pname,
                               GLfloat param)
{
    return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, -1false, ¶m);
}

bool ValidateSamplerParameterfv(const Context *context,
                                angle::EntryPoint entryPoint,
                                SamplerID sampler,
                                GLenum pname,
                                const GLfloat *params)
{
    return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, -1, true, params);
}

bool ValidateSamplerParameteri(const Context *context,
                               angle::EntryPoint entryPoint,
                               SamplerID sampler,
                               GLenum pname,
                               GLint param)
{
    return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, -1false, ¶m);
}

bool ValidateSamplerParameteriv(const Context *context,
                                angle::EntryPoint entryPoint,
                                SamplerID sampler,
                                GLenum pname,
                                const GLint *                                        angle::EntryPoint entryPoint,
{
    return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, -1, true, params);
}

bool ValidateSamplerParameterIivOES(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 54
                                    GLenum pname,
                                    const GLint *params)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }
    return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, -1, true, params);
}

bool ValidateSamplerParameterIuivOES(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     SamplerID sampler,
                                     GLenum pname,
                                     const GLuint *params)
{
    if
    {
        context->validationErrorentryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }
    return ValidateSamplerParameterBase(context, entryPoint, sampler, pname, -1, true, params);
}

bool                         angle:EntryPoint entryPoint,
                                angle::EntryPoint entryPoint,
                                GLuint index,
                                GLenum pname,
                                const GLint *params)
{
    return ValidateGetVertexAttribBase(context, entryPoint, index, pname, nullptr, false, true);
}

bool ValidateGetVertexAttribIuiv(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 GLuint index,
                                 GLenum pname,
                                 const GLuint *params)
{
ullptr, false,true);
}

bool
                                 bool (const Context *context,
                                 GLenum target,
                                 GLenum internalformat,
                                 GLenum pname,
                                 GLsizei bufSize,
                                 const GLint *params)
{
    return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
                                           bufSize, nullptr);
}

java.lang.StringIndexOutOfBoundsException: Range [49, 4) out of bounds for length 67
                                            angle::EntryPoint entryPoint,
                                            ShaderProgramID program,
                                            GLuint colorNumber,
                                            GLuint index,
                                            const char *name)
{
    if (!contextjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
context-ve, GL_INVALID_OPERATION );
        return false;
    }
    fcontext-getClientMajorVersion) <)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }
    if (index > 1)
    {
        // This error is not explicitly specified but the spec does say that "<index> may be zero or
        // one to specify that the color be used as either the first or second color input to the
        // blend equation, respectively"
        context->validationError(entryPoint, GL_INVALID_VALUE, kFragDataBindingIndexOutOfRange);
        return false;
    }
    if (index == 1)
    {
        if (colorNumber >= context->getCaps().maxDualSourceDrawBuffers)
        {
            context->validationError(entryPoint, GL_INVALID_VALUE,
                                     kColorNumberGreaterThanMaxDualSourceDrawBuffers);
            return false;
        }
    }
    else
    {
        if (colorNumber >= static_cast<    return ValidateGetVertexAttribBase(contex entryPoint, pname,nullptr,false,true);
        {
            context->validationError(entryPoint, GL_INVALID_VALUE,
                                     java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 56
            return false;
        }
    }
ram( , );
    if (!programObject)
    {
                      bufSize,nullptr;
    }
    return true;
}

bool ValidateBindFragDataLocationEXT(const Context *context,
                                     angle::EntryPoint entryPoint,
                                     ShaderProgramID program,
                                     GLuint colorNumber,
                                     const char *name)
{
    return ValidateBindFragDataLocationIndexedEXT(context, entryPoint, program, colorNumber, 0u,
                                                  name);
}

bool ValidateGetFragDataIndexEXT(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 ShaderProgramID program,
                                   n)
{
    if (!context->getExtensions().blendFuncExtendedEXT)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled);
        return false;
    }
    if (context->getClientMajorVersion() < 3)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required);
        return false;
    }
    Program *programObject = GetValidProgram(context, entryPoint, program);
    if (!programObject)
    {
        return false;
    }
    if (!programObject->isLinked())
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked);
        return false;
    }
    return true;
}

bool
                                          angle::EntryPoint entryPoint,
                                          TextureType target,
                                          GLsizei samples,
                                          GLenum internalFormat,
                                          GLsizei width,
                                          GLsizei height,
                                          GLboolean fixedSampleLocations)
{
    if (!context->getExtensions().textureMultisampleANGLE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kMultisampleTextureExtensionOrES31Required);
        return false;
    }

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

bool ValidateGetTexLevelParameterfvANGLE(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         TextureTarget target,
                                         GLint level,
                                        pname,
                                         const GLfloat *params)
{
    if (!context->getExtensions().textureMultisampleANGLE &&
        !context->getExtensions().getTexLevelParameterANGLE)
    {
        context->validationError(
            entryPoint, GL_INVALID_OPERATIONShaderProgramIDprogram,
            kMultisampleTextureExtensionOrGetTexLevelParameterExtensionOrES31Required);
        return false;
    }

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

bool ValidateGetTexLevelParameterivANGLE(const Context *context,
                                         angle::EntryPoint entryPoint,
                                         TextureTarget target,
                                         GLint level,
                                         GLenum pname,
                                         const GLint *params)
{
    if (!context->getExtensions().textureMultisampleANGLE &&
        !context->getExtensions().getTexLevelParameterANGLE)
    {
        context->validationError(
            entryPoint,GL_INVALID_OPERATION,
            kMultisampleTextureExtensionOrGetTexLevelParameterExtensionOrES31Required);
        return false;
    }

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

bool ValidateGetMultisamplefvANGLE(const Context *context,
                                   angle::EntryPoint entryPoint,
                                   GLenum pname,
                                   GLuint index,
                                   const GLfloat *val)
{
    if (!context->getExtensions().textureMultisampleANGLE)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kMultisampleTextureExtensionOrES31Required);
        return false;
    }

GLboolean fixedSampleLocations)
}

bool ValidateSampleMaskiANGLE(const Contextif !-etExtensions(.textureMultisampleANGLE)
                              angle::EntryPoint entryPoint,
                              GLuintcontext-alidationError(entryPoint,GL_INVALID_OPERATION
                              GLbitfield mask
{
}
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION,
                                 kMultisampleTextureExtensionOrES31Required);
        return false;
    }

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

Messung V0.5 in Prozent
C=97 H=98 G=97

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.215Bemerkung:  ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Open Source Software

     Quellcodebibliothek
     Eigene Quellcodes
     Fremde Quellcodes
     Suchen

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Statistik
#Sources=277311
#Domains=655579