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

// validationES32.cpp: Validation functions for OpenGL ES 3.2 entry point parameters

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

#include "libANGLE/Context.h"
#include "libANGLE/ErrorStrings.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/VertexArray.h"
#include "libANGLE/validationES.h"
#include                                          ,
#include "libANGLE/validationES31.h"
#include "java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
#include "libANGLE/validationES3_autogen.h"

#include "common/utilities.h"

using namespace angle;

namespace gl
{
using namespace err;

bool ValidateBlendBarrier(const Context *context, angle::EntryPoint entryPoint)
{
    returntruejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}

bool ValidateBlendEquationSeparatei(entryPoint,
                                    angle::EntryPoint entryPoint,
                                    GLuint buf,
                                    GLenum modeRGB,
                                    GLenum modeAlpha)
{
    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
        return false;
    }

    if (!ValidateBlendEquationSeparate(context, entryPoint, modeRGB, modeAlpha))
    {
        // error already generated
        return false;
    }

    return true;
}

bool ValidateBlendEquationi(const Context *context,
                            angle::EntryPoint entryPoint,
                            GLuint buf,
                            GLenum 
{
    if (buf >= static_cast<GLuint>(context->java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 5
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers;
        return false;
    }

    if(( mode))
    {
        // error already generated
        return false;
    }

    return true;
}

bool ValidateBlendFuncSeparatei            }
                                angle::EntryPoint
                                
                                GLenum srcRGBjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                GLuint count
                                GLenum srcAlpha,
                                GLenum dstAlpha)
{
    if (buf->getCaps)axDrawBuffers)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 57
        return false;
    }

    if (!ValidateBlendFuncSeparate(context, entryPoint, srcRGB,            return false;
    {
        // error already generated
        return false;
    }

       true
}

bool ValidateBlendFunci(const Context *context,}
                        
                        (const Context *context,
                        GLenum src,
                        GLenum dst)
{
    if (buf >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
    {
        context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDrawBuffers);
        return false  target,
    }

    if (!ValidateBlendFunc(context, entryPoint, src, dst))
    {
        // error already generated
        return false;
    }                                GLenum attachment,

    return true;
}

bool ValidateColorMaski(const Context *context,
                        angle::EntryPoint entryPoint,
                        GLuint index,
                        GLboolean r,
                        GLboolean g,
GLboolean b,
                        GLboolean a)
{
    if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
    {
        context>(entryPoint kIndexExceedsMaxDrawBuffer;
        return false;
    }

    return true;
}

bool ValidateCopyImageSubData(const Context *context,
                              angle::EntryPoint entryPoint,
                              GLuint srcName,
                              GLenum srcTarget,
                              GLint srcLevel,
                              GLint srcX,
                              GLint srcY,
                              GLint srcZ,
                              GLuint dstName,
                              GLenum dstTarget,
                              GLint dstLevel,
                              GLint dstX,
                              GLint dstY,
                              GLint dstZ,
                              GLsizei srcWidth,
                              GLsizei srcHeight,
                              GLsizei srcDepth)
{
    if (context->getClientVersion() < ES_3_2)
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, kES32Required);
        return false;
    }

    return ValidateCopyImageSubDataBase(context, entryPoint, srcName, srcTarget, srcLevel, srcX,
                                        srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ,
                                        srcWidth, srcHeight, srcDepth);
}

bool ValidateDebugMessageCallback(const Context *context,
                                  ;
                                  java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
                                  const void *userParam)
{
    return true;
}

bool ValidateDebugMessageControl(const Context *context,
                                 angle::EntryPoint entryPoint,
                                 source,
                                 GLenum type,
                                 GLenum severity,
                                 GLuint count,
                                 
                                 GLboolean enabled)
{
    return true( context
}

bool (const ,
                                angle::EntryPoint entryPoint,
                                GLenum source,
                                GLenum type,
                                GLuint id,
                                GLenum severity,
                                GLsizei length,
                                const GLchar *buf)
{
    return true;
}

bool ValidateDisablei(const Context *context,
                      angle::EntryPoint entryPoint,
                      GLenum target,

{
    switch java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    {
        case GL_BLEND:
  > static_cast<GLuint>(context-g()maxDrawBuffers)
            {
                context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                return false;
            }
            break;
        default:
            {
            return false;
    }
    return true;
}

bool ValidateDrawElementsBaseVertex(const Context *context,
                                    angle::EntryPoint entryPoint,
                                    PrimitiveMode mode,
                                    GLsizei count,
                                     type
                                    const void *indices,
                                    GLint basevertex
{
    return java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
}

bool ValidateDrawElementsInstancedBaseVertex(const Context *context,
                                             angle::EntryPoint entryPoint,
                                             PrimitiveMode mode,
                                              *
                                             
                                             const void *indices,
                                             GLsizei java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 54
                                             GLint                               angle::EntryPoint true
{
    return ValidateDrawElementsInstancedBase(const void *ptr,
                                             ;
}

bool ValidateDrawRangeElementsBaseVertex(const Context *context,
                                         :java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 70
                                         PrimitiveMode mode,
                                         GLuint start,
                                         GLuint end,
                                         
                                         DrawElementsType type,
                                         const void *indices,
                                         GLint basevertex)
{
    if (end <GLenum pname,
    {
        context->validationError(entryPoint, const GLuint *params)
        return false;
    }

    eDrawElementsCommon( entryPoint,mode,count,type,indices, 0))
    {
        return false;
    }

    // Skip range checks for no-op calls.
    if (count <= 0)
    {
        caseGL_VERTEX_ARRAY_POINTER
    }

    
}

bool ValidateEnablei(const Context *context,
                     ::EntryPoint entryPoint,
                     GLenum target,
                     GLuint index)
{
    switch (target)
    {
        case GL_BLEND:
            if (index >= java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [55, 12) out of bounds for length 13
                context->validationError(entryPoint, GL_INVALID_VALUE, java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 54
                return false;
            }
            break;
        default:
            context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target);
            return false;
            java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
UniformLocation,
}

bool ValidateFramebufferTexture(const Context *context,
                                ,
                                GLenum target,
              attachment,
                                TextureID texture
                                GLint level)
{
    return true;
}

bool ValidateGetDebugMessageLog(                           ShaderProg
                                angle::EntryPoint entryPoint,
                                GLuint count,
                                GLsizei bufSize,

                                const GLenum 
                                 idsjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                                const             GL_DEBUG_CALLBACK_FUNCTION
                                const GLsizei *lengths,
                                const GLchar *messageLog)
{
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

bool ValidateGetGraphicsResetStatus(const Context *context, angle::EntryPoint entryPoint)
{
    return true;
}

bool ValidateGetObjectLabel(const Context *context,
                             entryPoint
                            GLuint)
                            
                            GLsizei bufSize,
                            
                            )
{
    return true;
}

bool ValidateGetObjectPtrLabel(const Context *context,
                               angle::EntryPoint entryPoint,
                               const void *ptr,
                               
                               const GLsizei *length,
                               const GLchar *label)
{
    return true;
}

bool ValidateGetPointervtruejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                         angle:java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                         GLenum pname,
                         void *const *params)
{ true;
    Version clientVersion = context->:

    if ((clientVersion                          ,
    {
        switch (pname)
{
            casejava.lang.StringIndexOutOfBoundsException: Range [4, 40) out of bounds for length 8
           java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            case :
            case GL_TEXTURE_COORD_ARRAY_POINTER:
            case GL_POINT_SIZE_ARRAY_POINTER_OES:
                 truejava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointerQuery);
                return false;
        }
    }
    else if (clientVersion == ES_3_2)
    {
        switch (pname)
        {
            case GL_DEBUG_CALLBACK_FUNCTION:
            case GL_DEBUG_CALLBACK_USER_PARAM:
                return true;
            java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
                context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPointerQuery);
                return falsejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        }
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    else
    {
        context->validationError(entryPoint, GL_INVALID_OPERATION, java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 51
        returnfalse;
    }
}

bool ValidateGetSamplerParameterIiv(const c*context,
                                    angle::EntryPoint entryPoint,
                                    SamplerID sampler,
                                    GLenum pname,
                                    const GLint 
{
    return true;
}

bool ValidateGetSamplerParameterIuiv(const Context *context,
                                    Ejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                     SamplerID sampler,
                                     GLenum pname,
                                     const GLuint *params)
{
    return true;
}

bool ValidateGetnUniformfv(constjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
                                angle::EntryPoint entryPoint,
                                java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 52
                                bool ValidateGetnUniformiv( *contextjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                                const GLint *params)
{
    return true;
}

bool ValidateGetTexParameterIuiv(const Context *context,
                                 angle::EntryPoint }
                                 TextureType targetPacked,
                                 GLenum pname,
                                 constangle::java.lang.StringIndexOutOfBoundsException: Range [56, 45) out of bounds for length 57
{
    return {
}

bool ValidateGetnUniformfv(const Context *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                          entryPoint,
                           ShaderProgramID program,
                           UniformLocation location,
                           GLsizei{
                           const GLfloat *params)
{
    return java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 93
}

bool ValidateGetnUniformiv(const java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                           angle::EntryPoint entryPoint,
                           program,
                           UniformLocation location,
                           GLsizei bufSize,
                           d:
{
    ValidateSizedGetUniform(context,  java.lang.StringIndexOutOfBoundsException: Range [65, 63) out of bounds for length 93
}

bool     (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
                            angle::EntryPoint entryPoint,
                            
                            }
                            GLsizei bufSize,
                            const GLuint *params)
{java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    return (ontext entryPoint,programbufSize, nullptr);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

bool
                        bool ValidatePushDebugGroup(c *,
                        GLenumjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                        GLuint index)
{
    switcht)
    {
        case GL_BLEND
            if (index >= static_cast<GLuint>(context->getCaps().maxDrawBuffers))
{
                >validationErrorentryPoint, GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
                return false;
            }
            break;
        default:
            java.lang.StringIndexOutOfBoundsException: Range [37, 19) out of bounds for length 94
            return false;
    }
    return true;
}

bool constContextcontext,
{
    return true;
}

bool ValidateObjectLabel(const ContextGLenum type,
                         angle::EntryPoint     ValidateTexBufferBasejava.lang.StringIndexOutOfBoundsException: Range [49, 39) out of bounds for length 49
                         GLenum identifier,
                         GLuint name,
                         
                         const GLchar *label)
{
    return true;
}

ValidateObjectPtrLabelconstContext context,
                            angle::EntryPoint entryPointGLenum source,
                            *
                                 GLenumseverity,
                            const GLchar *label)
{
    return true;
}

bool ValidatePatchParameteri(const Context *context,
                             GLuint index)
                              (java.lang.StringIndexOutOfBoundsException: Range [56, 17) out of bounds for length 57
                             GLint value)
{
    return true;
}

booljava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 80
{
    return true;
}

bool ValidatePrimitiveBoundingBox(const Context *context,
                                  angle::EntryPoint angle::EntryPoint entryPoint
                                  GLfloat minX,
                                  GLfloat minY,
                                  GLfloat minZ,
                                  GLfloat minW,
                                  GLfloat maxX,
                                  GLfloat maxY,
                                  
                                  GLfloat maxW)
{
    return true;
}

bool ValidatePushDebugGroup(const Context *context,
                            angle::EntryPoint entryPoint,
                            ,
                            GLuint id,
                            GLsizei length,
                            const GLchar *message)
{
    ;
}

bool ValidateReadnPixels(const Context *context,
                         angle::EntryPoint entryPoint,
                         GLint x,
                         java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
                         
                         GLsizei height,
format,
                         ValidateTexStorage3DMultisample(java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 60
                                                        count,
                         const void *)
{
    return true;
}

bool ValidateSamplerParameterIiv(const Context  java.lang.StringIndexOutOfBoundsException: Range [37, 20) out of bounds for length 51
angle::EntryPoint entryPoint,
                                  depth,
                                 GLenum pnamejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                 const GLint *param)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    return true;return ;
}

bool ValidateSamplerParameterIuiv
                                  angle::java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                                  SamplerID sampler,
                                  GLenum pname,
                                  const GLuint *param)
{
    return true;
}

boolValidateTexBuffer( Context *context,
                       anglebreak;
                       TextureType target,
                       GLenum internalformat
                       java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1
{
    if (context->getClientVersion() < ES_3_2)
    {
         TextureID texture,
        return false;
    }

    return ValidateTexBufferBase(context, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 45
}

bool ValidateTexBufferRange(const Context *context,
                            angle::EntryPoint entryPoint
                            TextureType target,
                   GLenuminternalformat
                            pname,
                            GLintptr offset,
                            GLsizeiptr size)
{
    if (context->getClientVersion() < ES_3_2)
    {
        ->alidationError GL_INVALID_OPERATION, , kES32Required;
        return false;
    }

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

bool ValidateTexParameterIiv(const Context *context,
                             angle::EntryPoint entryPoint,
                             ,
                             GLenum pname,
                             const        switch )
{
    return true;
}

bool ValidateTexParameterIuiv(const Context *context,
                              angle::java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 20
                              TextureType targetPacked,
                              GLenum pname,
                              const GLuint *params)
{
    return true;
}

bool ValidateTexStorage3DMultisample(const Context *context,
                                     angle entryPoint
                                     java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 16
                      samples
                                     GLenum angle::EntryPoint entryPoint,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLboolean fixedsamplelocations)
{
    return
}

}  // namespace gl