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

// DebugTest.cpp : Tests of the GL_KHR_debug extension

#include "common/debug.h"
#include "test_utils/ANGLETest.h"
#include "test_utils/gl_raii.h"

namespace angle
{
constexpr char kBufferObjLabel[]          = "buffer";
constexpr char kShaderObjLabel[]          = "shader";
constexpr char kProgramObjLabel[]         = "program";
constexpr char kVertexArrayObjLabel[]     = "vertexarray";
constexpr char kQueryObjLabel[]           = "query";
constexpr char kProgramPipelineObjLabel[] = "programpipeline";
constexpr GLenum kObjectTypes[]           = {GL_BUFFER_OBJECT_EXT,           GL_SHADER_OBJECT_EXT,
                                             GL_PROGRAM_OBJECT_EXT,          GL_QUERY_OBJECT_EXT,
                                             GL_PROGRAM_PIPELINE_OBJECT_EXT, GL_VERTEX_ARRAY_OBJECT_EXT};

class DebugTest : public ANGLETest<>
{
  protected:
    DebugTest() : mDebugExtensionAvailable(false)
    {
        setWindowWidth(128);
        setWindowHeight(128);
        setConfigRedBits(8);
        setConfigGreenBits(8);
        setConfigBlueBits(8);
        setConfigAlphaBits(8);
        setConfigDepthBits(24);
        setDebugEnabled(true);
        setExtensionsEnabled(false);
    }

    void testSetUp() override
    {
        mDebugExtensionAvailable = EnsureGLExtensionEnabled("GL_KHR_debug");
        if (mDebugExtensionAvailable)
        {
            glEnable(GL_DEBUG_OUTPUT);
        }
    }

    bool mDebugExtensionAvailable;
};

void createGLObjectAndLabel(GLenum identifier,
                            GLuint &object,
                            const char **label,
                            int major,
                            int minor)
{
    switch (identifier)
    {
        case GL_BUFFER_OBJECT_EXT:
            glGenBuffers(1, &object);
            glBindBuffer(GL_ARRAY_BUFFER, object);
            *label = kBufferObjLabel;
            break;
        case GL_SHADER_OBJECT_EXT:
            object = glCreateShader(GL_VERTEX_SHADER);
            *label = kShaderObjLabel;
            break;
        case GL_PROGRAM_OBJECT_EXT:
            object = glCreateProgram();
            *label = kProgramObjLabel;
            break;
        case GL_VERTEX_ARRAY_OBJECT_EXT:
            if (major < 3)
            {
                glGenVertexArraysOES(1, &object);
                glBindVertexArrayOES(object);
            }
            else
            {
                glGenVertexArrays(1, &object);
                glBindVertexArray(object);
            }
            *label = kVertexArrayObjLabel;
            break;
        case GL_QUERY_OBJECT_EXT:
            if (major < 3)
            {
                glGenQueriesEXT(1, &object);
                glBeginQueryEXT(GL_ANY_SAMPLES_PASSED, object);
            }
            else
            {
                glGenQueries(1, &object);
                glBeginQuery(GL_ANY_SAMPLES_PASSED, object);
            }
            *label = kQueryObjLabel;
            break;
        case GL_PROGRAM_PIPELINE_OBJECT_EXT:
            if (major < 3 || minor < 1)
            {
                glGenProgramPipelinesEXT(1, &object);
                glBindProgramPipelineEXT(object);
            }
            else
            {
                glGenProgramPipelines(1, &object);
                glBindProgramPipeline(object);
            }
            *label = kProgramPipelineObjLabel;
            break;
        default:
            UNREACHABLE();
            break;
    }
}

void deleteGLObject(GLenum identifier, GLuint &object, int major, int minor)
{
    switch (identifier)
    {
        case GL_BUFFER_OBJECT_EXT:
            glDeleteBuffers(1, &object);
            break;
        case GL_SHADER_OBJECT_EXT:
            glDeleteShader(object);
            break;
        case GL_PROGRAM_OBJECT_EXT:
            glDeleteProgram(object);
            break;
        case GL_VERTEX_ARRAY_OBJECT_EXT:
            if (major < 3)
            {
                glDeleteVertexArraysOES(1, &object);
            }
            else
            {
                glDeleteVertexArrays(1, &object);
            }
            break;
        case GL_QUERY_OBJECT_EXT:
            if (major < 3)
            {
                glEndQueryEXT(GL_ANY_SAMPLES_PASSED);
                glDeleteQueriesEXT(1, &object);
            }
            else
            {
                glEndQuery(GL_ANY_SAMPLES_PASSED);
                glDeleteQueries(1, &object);
            }
            break;
        case GL_PROGRAM_PIPELINE_OBJECT_EXT:
            if (major < 3 || minor < 1)
            {
                glDeleteProgramPipelinesEXT(1, &object);
            }
            else
            {
                glDeleteProgramPipelines(1, &object);
            }
            break;
        default:
            UNREACHABLE();
            break;
    }
}

// Test basic usage of setting and getting labels using GL_EXT_debug_label
TEST_P(DebugTest, ObjectLabelsEXT)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_debug_label"));

    for (const GLenum identifier : kObjectTypes)
    {
        bool skip = false;
        switch (identifier)
        {
            case GL_PROGRAM_OBJECT_EXT:
            case GL_SHADER_OBJECT_EXT:
                if (getClientMajorVersion() < 2)
                {
                    skip = true;
                }
                break;
            case GL_PROGRAM_PIPELINE_OBJECT_EXT:
                if ((getClientMajorVersion() < 3 || getClientMinorVersion() < 1) &&
                    !EnsureGLExtensionEnabled("GL_EXT_separate_shader_objects"))
                {
                    skip = true;
                }
                break;
            case GL_QUERY_OBJECT_EXT:
                if (getClientMajorVersion() < 3 &&
                    !EnsureGLExtensionEnabled("GL_EXT_occlusion_query_boolean"))
                {
                    skip = true;
                }
                break;
            case GL_VERTEX_ARRAY_OBJECT_EXT:
                if (getClientMajorVersion() < 3 &&
                    !EnsureGLExtensionEnabled("GL_OES_vertex_array_object"))
                {
                    skip = true;
                }
                break;
            default:
                break;
        }

        // if object enum is not supported, move on to the next object type
        if (skip)
        {
            continue;
        }

        GLuint object;
        const char *label;
        createGLObjectAndLabel(identifier, object, &label, getClientMajorVersion(),
                               getClientMinorVersion());
        ASSERT_GL_NO_ERROR();

        glLabelObjectEXT(identifier, object, 0, label);
        ASSERT_GL_NO_ERROR();

        std::vector<char> labelBuf(strlen(label) + 1);
        GLsizei labelLengthBuf = 0;
        glGetObjectLabelEXT(identifier, object, static_cast<GLsizei>(labelBuf.size()),
                            &labelLengthBuf, labelBuf.data());
        ASSERT_GL_NO_ERROR();

        EXPECT_EQ(static_cast<GLsizei>(strlen(label)), labelLengthBuf);
        EXPECT_STREQ(label, labelBuf.data());

        deleteGLObject(identifier, object, getClientMajorVersion(), getClientMinorVersion());
        ASSERT_GL_NO_ERROR();

        glLabelObjectEXT(identifier, object, 0, label);
        EXPECT_GL_ERROR(GL_INVALID_OPERATION);

        glGetObjectLabelEXT(identifier, object, static_cast<GLsizei>(labelBuf.size()),
                            &labelLengthBuf, labelBuf.data());
        EXPECT_GL_ERROR(GL_INVALID_OPERATION);
    }
}

// Test basic usage of setting and getting labels using GL_EXT_debug_label on timer query objects
TEST_P(DebugTest, TimerQueryObjectLabelsEXT)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_debug_label"));

    ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_EXT_disjoint_timer_query"));

    GLuint object;
    glGenQueriesEXT(1, &object);
    glBeginQueryEXT(GL_TIME_ELAPSED_EXT, object);
    ASSERT_GL_NO_ERROR();

    glLabelObjectEXT(GL_QUERY_OBJECT_EXT, object, 0, kQueryObjLabel);
    EXPECT_GL_NO_ERROR();

    std::vector<char> labelBuf(strlen(kQueryObjLabel) + 1);
    GLsizei labelLengthBuf = 0;
    glGetObjectLabelEXT(GL_QUERY_OBJECT_EXT, object, static_cast<GLsizei>(labelBuf.size()),
                        &labelLengthBuf, labelBuf.data());
    ASSERT_GL_NO_ERROR();

    EXPECT_EQ(static_cast<GLsizei>(strlen(kQueryObjLabel)), labelLengthBuf);
    EXPECT_STREQ(kQueryObjLabel, labelBuf.data());

    glEndQueryEXT(GL_TIME_ELAPSED_EXT);
    glDeleteQueriesEXT(1, &object);
    ASSERT_GL_NO_ERROR();

    glLabelObjectEXT(GL_QUERY_OBJECT_EXT, object, 0, kQueryObjLabel);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    glGetObjectLabelEXT(GL_QUERY_OBJECT_EXT, object, static_cast<GLsizei>(labelBuf.size()),
                        &labelLengthBuf, labelBuf.data());
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
}

// Simple test for GetDebugMessageLogKHR validation
TEST_P(DebugTest, GetDebugMessageLog)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    glGetDebugMessageLogKHR(1, -1, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
    EXPECT_GL_NO_ERROR();

    glGetDebugMessageLogKHR(1, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
    EXPECT_GL_NO_ERROR();

    std::vector<char> messageBuf(1);
    glGetDebugMessageLogKHR(1, -1, nullptr, nullptr, nullptr, nullptr, nullptr, messageBuf.data());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glGetDebugMessageLogKHR(1, 0, nullptr, nullptr, nullptr, nullptr, nullptr, messageBuf.data());
    EXPECT_GL_NO_ERROR();
}

class DebugTestES3 : public DebugTest
{};

class DebugTestES32 : public DebugTestES3
{
    void testSetUp() override { ; }
};

struct Message
{
    GLenum source;
    GLenum type;
    GLuint id;
    GLenum severity;
    std::string message;
    const void *userParam;
};

static void GL_APIENTRY Callback(GLenum source,
                                 GLenum type,
                                 GLuint id,
                                 GLenum severity,
                                 GLsizei length,
                                 const GLchar *message,
                                 const void *userParam)
{
    Message m{source, type, id, severity, std::string(message, length), userParam};
    std::vector<Message> *messages =
        static_cast<std::vector<Message> *>(const_cast<void *>(userParam));
    messages->push_back(m);
}

// Test that all ANGLE back-ends have GL_KHR_debug enabled
TEST_P(DebugTestES3, Enabled)
{
    ASSERT_TRUE(mDebugExtensionAvailable);
}

// Test that when debug output is disabled, no message are outputted
TEST_P(DebugTestES3, DisabledOutput)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    glDisable(GL_DEBUG_OUTPUT);

    glDebugMessageInsertKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, 1,
                            GL_DEBUG_SEVERITY_NOTIFICATION, -1, "discarded");

    GLint numMessages = 0;
    glGetIntegerv(GL_DEBUG_LOGGED_MESSAGES, &numMessages);
    ASSERT_EQ(0, numMessages);

    std::vector<Message> messages;
    glDebugMessageCallbackKHR(Callback, &messages);
    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);

    ASSERT_EQ(0u, messages.size());
}

// Test a basic flow of inserting a message and reading it back
TEST_P(DebugTestES3, InsertMessage)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    const GLenum source       = GL_DEBUG_SOURCE_APPLICATION;
    const GLenum type         = GL_DEBUG_TYPE_OTHER;
    const GLuint id           = 1;
    const GLenum severity     = GL_DEBUG_SEVERITY_NOTIFICATION;
    const std::string message = "Message";

    glDebugMessageInsertKHR(source, type, id, severity, -1, message.c_str());

    GLint numMessages = 0;
    glGetIntegerv(GL_DEBUG_LOGGED_MESSAGES, &numMessages);
    ASSERT_EQ(1, numMessages);

    GLint messageLength = 0;
    glGetIntegerv(GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH, &messageLength);
    EXPECT_EQ(static_cast<GLint>(message.length()) + 1, messageLength);

    GLenum sourceBuf   = 0;
    GLenum typeBuf     = 0;
    GLenum idBuf       = 0;
    GLenum severityBuf = 0;
    GLsizei lengthBuf  = 0;
    std::vector<char> messageBuf(messageLength);
    GLuint ret =
        glGetDebugMessageLogKHR(1, static_cast<GLsizei>(messageBuf.size()), &sourceBuf, &typeBuf,
                                &idBuf, &severityBuf, &lengthBuf, messageBuf.data());
    EXPECT_EQ(1u, ret);
    EXPECT_EQ(source, sourceBuf);
    EXPECT_EQ(type, typeBuf);
    EXPECT_EQ(id, idBuf);
    EXPECT_EQ(severity, severityBuf);
    EXPECT_EQ(lengthBuf, messageLength);
    EXPECT_STREQ(message.c_str(), messageBuf.data());

    glGetIntegerv(GL_DEBUG_LOGGED_MESSAGES, &numMessages);
    EXPECT_EQ(0, numMessages);

    ASSERT_GL_NO_ERROR();
}

// Test inserting multiple messages
TEST_P(DebugTestES3, InsertMessageMultiple)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    const GLenum source          = GL_DEBUG_SOURCE_APPLICATION;
    const GLenum type            = GL_DEBUG_TYPE_OTHER;
    const GLuint startID         = 1;
    const GLenum severity        = GL_DEBUG_SEVERITY_NOTIFICATION;
    const char messageRepeatChar = 'm';
    const size_t messageCount    = 32;

    for (size_t i = 0; i < messageCount; i++)
    {
        std::string message(i + 1, messageRepeatChar);
        glDebugMessageInsertKHR(source, type, startID + static_cast<GLuint>(i), severity, -1,
                                message.c_str());
    }

    GLint numMessages = 0;
    glGetIntegerv(GL_DEBUG_LOGGED_MESSAGES, &numMessages);
    ASSERT_EQ(static_cast<GLint>(messageCount), numMessages);

    for (size_t i = 0; i < messageCount; i++)
    {
        glGetIntegerv(GL_DEBUG_LOGGED_MESSAGES, &numMessages);
        EXPECT_EQ(static_cast<GLint>(messageCount - i), numMessages);

        std::string expectedMessage(i + 1, messageRepeatChar);

        GLint messageLength = 0;
        glGetIntegerv(GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH, &messageLength);
        EXPECT_EQ(static_cast<GLint>(expectedMessage.length()) + 1, messageLength);

        GLenum sourceBuf   = 0;
        GLenum typeBuf     = 0;
        GLenum idBuf       = 0;
        GLenum severityBuf = 0;
        GLsizei lengthBuf  = 0;
        std::vector<char> messageBuf(messageLength);
        GLuint ret =
            glGetDebugMessageLogKHR(1, static_cast<GLsizei>(messageBuf.size()), &sourceBuf,
                                    &typeBuf, &idBuf, &severityBuf, &lengthBuf, messageBuf.data());
        EXPECT_EQ(1u, ret);
        EXPECT_EQ(source, sourceBuf);
        EXPECT_EQ(type, typeBuf);
        EXPECT_EQ(startID + i, idBuf);
        EXPECT_EQ(severity, severityBuf);
        EXPECT_EQ(lengthBuf, messageLength);
        EXPECT_STREQ(expectedMessage.c_str(), messageBuf.data());
    }

    glGetIntegerv(GL_DEBUG_LOGGED_MESSAGES, &numMessages);
    EXPECT_EQ(0, numMessages);

    ASSERT_GL_NO_ERROR();
}

// Test that a too long label fails
TEST_P(DebugTest, ObjectLabelTooLong)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    // Limit includes the null terminator
    GLint maxLength = 0;
    glGetIntegerv(GL_MAX_LABEL_LENGTH_KHR, &maxLength);
    ASSERT_GE(maxLength, 1);

    GLBuffer object;
    glBindBuffer(GL_ARRAY_BUFFER, object);
    ASSERT_GL_NO_ERROR();

    // Implicit length
    glObjectLabelKHR(GL_BUFFER_KHR, object, -1, std::string(maxLength - 1, 'A').c_str());
    EXPECT_GL_NO_ERROR();

    glObjectLabelKHR(GL_BUFFER_KHR, object, -1, std::string(maxLength, 'A').c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glObjectLabelKHR(GL_BUFFER_KHR, object, -1, std::string(maxLength + 1, 'A').c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Explicit length
    const std::string label = std::string(maxLength + 1, 'B');

    glObjectLabelKHR(GL_BUFFER_KHR, object, maxLength - 1, label.c_str());
    EXPECT_GL_NO_ERROR();

    glObjectLabelKHR(GL_BUFFER_KHR, object, maxLength, label.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glObjectLabelKHR(GL_BUFFER_KHR, object, maxLength + 1, label.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
}

// Test that a too long sync object label fails
TEST_P(DebugTestES3, ObjectPtrLabelTooLong)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    // Limit includes the null terminator
    GLint maxLength = 0;
    glGetIntegerv(GL_MAX_LABEL_LENGTH_KHR, &maxLength);
    ASSERT_GE(maxLength, 1);

    GLsync object = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
    ASSERT_GL_NO_ERROR();

    // Implicit length
    glObjectPtrLabelKHR(object, -1, std::string(maxLength - 1, 'A').c_str());
    EXPECT_GL_NO_ERROR();

    glObjectPtrLabelKHR(object, -1, std::string(maxLength, 'A').c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glObjectPtrLabelKHR(object, -1, std::string(maxLength + 1, 'A').c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Explicit length
    const std::string label = std::string(maxLength + 1, 'B');

    glObjectPtrLabelKHR(object, maxLength - 1, label.c_str());
    EXPECT_GL_NO_ERROR();

    glObjectPtrLabelKHR(object, maxLength, label.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glObjectPtrLabelKHR(object, maxLength + 1, label.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glDeleteSync(object);
}

// Test that a too long debug group fails
TEST_P(DebugTest, PushDebugGroupTooLong)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    // Limit includes the null terminator
    GLint maxLength = 0;
    glGetIntegerv(GL_MAX_DEBUG_MESSAGE_LENGTH_KHR, &maxLength);
    ASSERT_GE(maxLength, 1);

    const GLenum source = GL_DEBUG_SOURCE_APPLICATION_KHR;

    // Implicit length
    glPushDebugGroupKHR(source, 1, -1, std::string(maxLength - 1, 'A').c_str());
    EXPECT_GL_NO_ERROR();

    glPushDebugGroupKHR(source, 1, -1, std::string(maxLength, 'A').c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glPushDebugGroupKHR(source, 1, -1, std::string(maxLength + 1, 'A').c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Explicit length
    const std::string message = std::string(maxLength + 1, 'B');

    glPushDebugGroupKHR(source, 1, maxLength - 1, message.c_str());
    EXPECT_GL_NO_ERROR();

    glPushDebugGroupKHR(source, 1, maxLength, message.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glPushDebugGroupKHR(source, 1, maxLength + 1, message.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
}

// Test that a too long message fails
TEST_P(DebugTest, InsertMessageTooLong)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    // Limit includes the null terminator
    GLint maxLength = 0;
    glGetIntegerv(GL_MAX_DEBUG_MESSAGE_LENGTH_KHR, &maxLength);
    ASSERT_GE(maxLength, 1);

    const GLenum source   = GL_DEBUG_SOURCE_APPLICATION_KHR;
    const GLenum type     = GL_DEBUG_TYPE_OTHER_KHR;
    const GLenum severity = GL_DEBUG_SEVERITY_NOTIFICATION_KHR;

    // Implicit length
    glDebugMessageInsertKHR(source, type, 1, severity, -1, std::string(maxLength - 1, 'A').c_str());
    EXPECT_GL_NO_ERROR();

    glDebugMessageInsertKHR(source, type, 1, severity, -1, std::string(maxLength, 'A').c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glDebugMessageInsertKHR(source, type, 1, severity, -1, std::string(maxLength + 1, 'A').c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Explicit length
    const std::string message = std::string(maxLength + 1, 'B');

    glDebugMessageInsertKHR(source, type, 1, severity, maxLength - 1, message.c_str());
    EXPECT_GL_NO_ERROR();

    glDebugMessageInsertKHR(source, type, 1, severity, maxLength, message.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glDebugMessageInsertKHR(source, type, 1, severity, maxLength + 1, message.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
}

// Test that passing a zero length inserts an empty message
TEST_P(DebugTest, InsertMessageZeroLength)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    GLint numMessages = 0;
    glGetIntegerv(GL_DEBUG_LOGGED_MESSAGES_KHR, &numMessages);
    ASSERT_EQ(0, numMessages);

    const GLenum source   = GL_DEBUG_SOURCE_APPLICATION_KHR;
    const GLenum type     = GL_DEBUG_TYPE_OTHER_KHR;
    const GLenum severity = GL_DEBUG_SEVERITY_NOTIFICATION_KHR;

    glDebugMessageInsertKHR(source, type, 1, severity, 0, "abc");
    EXPECT_GL_NO_ERROR();

    GLsizei lengthBuf = 0;
    std::vector<char> messageBuf(4, 0xFF);
    GLuint ret = glGetDebugMessageLogKHR(1, static_cast<GLsizei>(messageBuf.size()), nullptr,
                                         nullptr, nullptr, nullptr, &lengthBuf, messageBuf.data());
    EXPECT_GL_NO_ERROR();
    EXPECT_EQ(1u, ret);
    EXPECT_EQ(lengthBuf, 1);
    EXPECT_EQ('\x00', messageBuf[0]);
    EXPECT_EQ('\xFF', messageBuf[1]);
    EXPECT_EQ('\xFF', messageBuf[2]);
    EXPECT_EQ('\xFF', messageBuf[3]);

    glGetIntegerv(GL_DEBUG_LOGGED_MESSAGES_KHR, &numMessages);
    EXPECT_EQ(0, numMessages);
}

// Test using a debug callback
TEST_P(DebugTestES3, DebugCallback)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    std::vector<Message> messages;

    glDebugMessageCallbackKHR(Callback, &messages);
    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);

    const GLenum source       = GL_DEBUG_SOURCE_APPLICATION;
    const GLenum type         = GL_DEBUG_TYPE_OTHER;
    const GLuint id           = 1;
    const GLenum severity     = GL_DEBUG_SEVERITY_NOTIFICATION;
    const std::string message = "Message";

    glDebugMessageInsertKHR(source, type, id, severity, -1, message.c_str());

    GLint numMessages = 0;
    glGetIntegerv(GL_DEBUG_LOGGED_MESSAGES, &numMessages);
    EXPECT_EQ(0, numMessages);

    ASSERT_EQ(1u, messages.size());

    const Message &m = messages.front();
    EXPECT_EQ(source, m.source);
    EXPECT_EQ(type, m.type);
    EXPECT_EQ(id, m.id);
    EXPECT_EQ(severity, m.severity);
    EXPECT_EQ(message, m.message);

    ASSERT_GL_NO_ERROR();
}

// Test the glGetPointervKHR entry point
TEST_P(DebugTestES3, GetPointer)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    std::vector<Message> messages;

    glDebugMessageCallbackKHR(Callback, &messages);

    void *callback = nullptr;
    glGetPointervKHR(GL_DEBUG_CALLBACK_FUNCTION, &callback);
    EXPECT_EQ(reinterpret_cast<void *>(Callback), callback);

    void *userData = nullptr;
    glGetPointervKHR(GL_DEBUG_CALLBACK_USER_PARAM, &userData);
    EXPECT_EQ(static_cast<void *>(&messages), userData);
}

// Test usage of message control.  Example taken from GL_KHR_debug spec.
TEST_P(DebugTestES3, MessageControl1)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    std::vector<Message> messages;

    glDebugMessageCallbackKHR(Callback, &messages);
    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);

    // Setup of the default active debug group: Filter everything in
    glDebugMessageControlKHR(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);

    // Generate a debug marker debug output message
    glDebugMessageInsertKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 100,
                            GL_DEBUG_SEVERITY_NOTIFICATION, -1, "Message 1");

    // Push debug group 1
    glPushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION, 1, -1, "Message 2");

    // Setup of the debug group 1: Filter everything out
    glDebugMessageControlKHR(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_FALSE);

    // This message won't appear in the debug output log of
    glDebugMessageInsertKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 100,
                            GL_DEBUG_SEVERITY_NOTIFICATION, -1, "Message 3");

    // Pop debug group 1, restore the volume control of the default debug group.
    glPopDebugGroupKHR();

    // Generate a debug marker debug output message
    glDebugMessageInsertKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 100,
                            GL_DEBUG_SEVERITY_NOTIFICATION, -1, "Message 5");

    // Expected debug output from the GL implementation
    // Message 1
    // Message 2
    // Message 2
    // Message 5
    EXPECT_EQ(4u, messages.size());
    EXPECT_STREQ(messages[0].message.c_str(), "Message 1");
    EXPECT_STREQ(messages[1].message.c_str(), "Message 2");
    EXPECT_STREQ(messages[2].message.c_str(), "Message 2");
    EXPECT_STREQ(messages[3].message.c_str(), "Message 5");

    ASSERT_GL_NO_ERROR();
}

// Test usage of message control.  Example taken from GL_KHR_debug spec.
TEST_P(DebugTestES3, MessageControl2)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    std::vector<Message> messages;

    glDebugMessageCallbackKHR(Callback, &messages);
    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);

    // Setup the control of de debug output for the default debug group
    glDebugMessageControlKHR(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_FALSE);
    glDebugMessageControlKHR(GL_DEBUG_SOURCE_THIRD_PARTY, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr,
                             GL_FALSE);
    std::vector<GLuint> ids0 = {1234, 2345, 3456, 4567};
    glDebugMessageControlKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, GL_DONT_CARE,
                             static_cast<GLuint>(ids0.size()), ids0.data(), GL_FALSE);
    glDebugMessageControlKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, GL_DONT_CARE,
                             static_cast<GLuint>(ids0.size()), ids0.data(), GL_FALSE);

    // Push debug group 1
    // Inherit of the default debug group debug output volume control
    // Filtered out by glDebugMessageControl
    glPushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION, 1, -1, "Message 1");

    // In this section of the code, we are interested in performances.
    glDebugMessageControlKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PERFORMANCE, GL_DONT_CARE,
                             0, nullptr, GL_TRUE);
    // But we already identify that some messages are not really useful for us.
    std::vector<GLuint> ids1 = {5678, 6789};
    glDebugMessageControlKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, GL_DONT_CARE,
                             static_cast<GLuint>(ids1.size()), ids1.data(), GL_FALSE);

    glDebugMessageInsertKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PERFORMANCE, 1357,
                            GL_DEBUG_SEVERITY_MEDIUM, -1, "Message 2");
    glDebugMessageInsertKHR(GL_DEBUG_SOURCE_THIRD_PARTY,  // We still filter out these messages.
                            GL_DEBUG_TYPE_OTHER, 3579, GL_DEBUG_SEVERITY_MEDIUM, -1, "Message 3");

    glPopDebugGroupKHR();

    // Expected debug output from the GL implementation
    // Message 2
    EXPECT_EQ(1u, messages.size());
    EXPECT_STREQ(messages[0].message.c_str(), "Message 2");

    ASSERT_GL_NO_ERROR();
}

// Test basic usage of setting and getting labels
TEST_P(DebugTestES3, ObjectLabelsKHR)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    GLuint renderbuffer = 0;
    glGenRenderbuffers(1, &renderbuffer);
    glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);

    const std::string &label = "renderbuffer";
    glObjectLabelKHR(GL_RENDERBUFFER, renderbuffer, -1, label.c_str());

    std::vector<char> labelBuf(label.length() + 1);
    GLsizei labelLengthBuf = 0;
    glGetObjectLabelKHR(GL_RENDERBUFFER, renderbuffer, static_cast<GLsizei>(labelBuf.size()),
                        &labelLengthBuf, labelBuf.data());

    EXPECT_EQ(static_cast<GLsizei>(label.length()), labelLengthBuf);
    EXPECT_STREQ(label.c_str(), labelBuf.data());

    ASSERT_GL_NO_ERROR();

    glDeleteRenderbuffers(1, &renderbuffer);

    glObjectLabelKHR(GL_RENDERBUFFER, renderbuffer, -1, label.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glGetObjectLabelKHR(GL_RENDERBUFFER, renderbuffer, static_cast<GLsizei>(labelBuf.size()),
                        &labelLengthBuf, labelBuf.data());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
}

// Test basic usage of setting and getting labels
TEST_P(DebugTestES3, ObjectPtrLabelsKHR)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);

    const std::string &label = "sync";
    glObjectPtrLabelKHR(sync, -1, label.c_str());

    std::vector<char> labelBuf(label.length() + 1);
    GLsizei labelLengthBuf = 0;
    glGetObjectPtrLabelKHR(sync, static_cast<GLsizei>(labelBuf.size()), &labelLengthBuf,
                           labelBuf.data());

    EXPECT_EQ(static_cast<GLsizei>(label.length()), labelLengthBuf);
    EXPECT_STREQ(label.c_str(), labelBuf.data());

    ASSERT_GL_NO_ERROR();

    glDeleteSync(sync);

    glObjectPtrLabelKHR(sync, -1, label.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glGetObjectPtrLabelKHR(sync, static_cast<GLsizei>(labelBuf.size()), &labelLengthBuf,
                           labelBuf.data());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
}

// Test setting labels before, during and after rendering.  The debug markers can be validated by
// capturing this test under a graphics debugger.
TEST_P(DebugTestES3, Rendering)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);

    // The test produces the following hierarchy:
    //
    // Group: Before Draw
    // Message: Before Draw Marker
    //   Message: In Group 1 Marker
    //   glDrawArrays
    //   Group: After Draw 1
    //      glDrawArrays
    //      Message: In Group 2 Marker
    //
    //      glCopyTexImage <-- this breaks the render pass
    //
    //      glDrawArrays
    //   End Group
    //
    //   glCopyTexImage <-- this breaks the render pass
    //
    //   Group: After Draw 2
    //      glDrawArrays
    //
    //      glCopyTexImage <-- this breaks the render pass
    //
    //      Message: In Group 3 Marker
    //   End Group
    //   Message: After Draw Marker
    // End Group
    const std::string beforeDrawGroup = "Before Draw";
    const std::string drawGroup1      = "Group 1";
    const std::string drawGroup2      = "Group 2";

    const std::string beforeDrawMarker = "Before Draw Marker";
    const std::string inGroup1Marker   = "In Group 1 Marker";
    const std::string inGroup2Marker   = "In Group 2 Marker";
    const std::string inGroup3Marker   = "In Group 3 Marker";
    const std::string afterDrawMarker  = "After Draw Marker";

    ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), essl1_shaders::fs::Blue());
    glUseProgram(program);

    glPushDebugGroupKHR(GL_DEBUG_SOURCE_THIRD_PARTY, 0, -1, beforeDrawGroup.c_str());
    glDebugMessageInsertKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PERFORMANCE, 0,
                            GL_DEBUG_SEVERITY_NOTIFICATION, -1, beforeDrawMarker.c_str());
    {
        glDebugMessageInsertKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0,
                                GL_DEBUG_SEVERITY_LOW, -1, inGroup1Marker.c_str());

        glDrawArrays(GL_TRIANGLES, 0, 6);

        glPushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION, 0, -1, drawGroup1.c_str());
        {
            glDrawArrays(GL_TRIANGLES, 0, 6);

            glDebugMessageInsertKHR(GL_DEBUG_SOURCE_THIRD_PARTY, GL_DEBUG_TYPE_PORTABILITY, 0,
                                    GL_DEBUG_SEVERITY_MEDIUM, -1, inGroup2Marker.c_str());

            GLTexture texture;
            glBindTexture(GL_TEXTURE_2D, texture);
            glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1, 0);

            glDrawArrays(GL_TRIANGLES, 0, 6);
        }
        glPopDebugGroupKHR();

        glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 2, 2, 0);

        glPushDebugGroupKHR(GL_DEBUG_SOURCE_THIRD_PARTY, 0, -1, drawGroup2.c_str());
        {
            glDrawArrays(GL_TRIANGLES, 0, 6);

            glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 3, 3, 0);

            glDebugMessageInsertKHR(GL_DEBUG_SOURCE_THIRD_PARTY, GL_DEBUG_TYPE_OTHER, 0,
                                    GL_DEBUG_SEVERITY_HIGH, -1, inGroup3Marker.c_str());
        }
        glPopDebugGroupKHR();

        glDebugMessageInsertKHR(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0,
                                GL_DEBUG_SEVERITY_HIGH, -1, afterDrawMarker.c_str());
    }
    glPopDebugGroupKHR();

    ASSERT_GL_NO_ERROR();
}

// Test that glPushGroupMarker() issues a stack overflow error when the stack size is capped.
TEST_P(DebugTestES3, PushTooManyGroupMarkers)
{
    ANGLE_SKIP_TEST_IF(!mDebugExtensionAvailable);
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_debug_marker"));

    GLint maxStackDepth;
    glGetIntegerv(GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR, &maxStackDepth);

    const std::string markerLabel = "Test Group Marker";
    for (GLint i = 0; i < maxStackDepth; i++)
    {
        glPushGroupMarkerEXT(0, markerLabel.c_str());
        ASSERT_GL_NO_ERROR();
    }

    glPushGroupMarkerEXT(0, markerLabel.c_str());
    EXPECT_GL_ERROR(GL_STACK_OVERFLOW);
}

// Test that glPopGroupMarker() is ignored if the stack is already empty.
TEST_P(DebugTestES3, PopGroupMarkerWithEmptyStack)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_debug_marker"));
    glPopGroupMarkerEXT();
    ASSERT_GL_NO_ERROR();
}

// Simple test for gl[Push, Pop]DebugGroup using ES32 core APIs
TEST_P(DebugTestES32, DebugGroup)
{
    const std::string testDrawGroup = "Test Draw Group";

    // Pop without a push should generate GL_STACK_UNDERFLOW error
    glPopDebugGroup();
    EXPECT_GL_ERROR(GL_STACK_UNDERFLOW);

    // Push a test debug group and expect no error
    glPushDebugGroup(GL_DEBUG_SOURCE_THIRD_PARTY, 0, -1, testDrawGroup.c_str());
    ASSERT_GL_NO_ERROR();

    // Pop the test debug group and expect no error
    glPopDebugGroup();
    ASSERT_GL_NO_ERROR();
}

// Simple test for setting and getting labels using ES32 core APIs
TEST_P(DebugTestES32, ObjectLabels)
{
    GLuint renderbuffer = 0;
    glGenRenderbuffers(1, &renderbuffer);
    glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);

    const std::string &label = "renderbuffer";
    glObjectLabel(GL_RENDERBUFFER, renderbuffer, -1, label.c_str());

    std::vector<char> labelBuf(label.length() + 1);
    GLsizei labelLengthBuf = 0;
    glGetObjectLabel(GL_RENDERBUFFER, renderbuffer, static_cast<GLsizei>(labelBuf.size()),
                     &labelLengthBuf, labelBuf.data());

    EXPECT_EQ(static_cast<GLsizei>(label.length()), labelLengthBuf);
    EXPECT_STREQ(label.c_str(), labelBuf.data());

    ASSERT_GL_NO_ERROR();

    glDeleteRenderbuffers(1, &renderbuffer);

    glObjectLabel(GL_RENDERBUFFER, renderbuffer, -1, label.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glGetObjectLabel(GL_RENDERBUFFER, renderbuffer, static_cast<GLsizei>(labelBuf.size()),
                     &labelLengthBuf, labelBuf.data());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
}

// Simple test for setting and getting labels using ES32 core APIs
TEST_P(DebugTestES32, ObjectPtrLabels)
{
    GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);

    const std::string &label = "sync";
    glObjectPtrLabel(sync, -1, label.c_str());

    std::vector<char> labelBuf(label.length() + 1);
    GLsizei labelLengthBuf = 0;
    glGetObjectPtrLabel(sync, static_cast<GLsizei>(labelBuf.size()), &labelLengthBuf,
                        labelBuf.data());

    EXPECT_EQ(static_cast<GLsizei>(label.length()), labelLengthBuf);
    EXPECT_STREQ(label.c_str(), labelBuf.data());

    ASSERT_GL_NO_ERROR();

    glDeleteSync(sync);

    glObjectPtrLabel(sync, -1, label.c_str());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glGetObjectPtrLabel(sync, static_cast<GLsizei>(labelBuf.size()), &labelLengthBuf,
                        labelBuf.data());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);
}

// Simple test for GetDebugMessageLog validation using ES32 core API
TEST_P(DebugTestES32, GetDebugMessageLog)
{
    glGetDebugMessageLog(1, -1, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
    EXPECT_GL_NO_ERROR();

    glGetDebugMessageLog(1, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
    EXPECT_GL_NO_ERROR();

    std::vector<char> messageBuf(1);
    glGetDebugMessageLog(1, -1, nullptr, nullptr, nullptr, nullptr, nullptr, messageBuf.data());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    glGetDebugMessageLog(1, 0, nullptr, nullptr, nullptr, nullptr, nullptr, messageBuf.data());
    EXPECT_GL_NO_ERROR();
}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DebugTestES3);
ANGLE_INSTANTIATE_TEST_ES3(DebugTestES3);

ANGLE_INSTANTIATE_TEST(DebugTest,
                       ANGLE_ALL_TEST_PLATFORMS_ES1,
                       ANGLE_ALL_TEST_PLATFORMS_ES2,
                       ANGLE_ALL_TEST_PLATFORMS_ES3,
                       ANGLE_ALL_TEST_PLATFORMS_ES31);

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DebugTestES32);
ANGLE_INSTANTIATE_TEST_ES32(DebugTestES32);
}  // namespace angle