Add m-esr52 at 52.6.0

1 files changed, 451 insertions, 0 deletions

diff --git a/gfx/angle/src/tests/gl_tests/DebugTest.cpp b/gfx/angle/src/tests/gl_tests/DebugTest.cpp
new file mode 100755
index 000000000..fc79c5f64
--- /dev/null
+++ b/gfx/angle/src/tests/gl_tests/DebugTest.cpp
@@ -0,0 +1,451 @@
+//
+// 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 "test_utils/ANGLETest.h"
+
+namespace angle
+{
+
+class DebugTest : public ANGLETest
+{
+  protected:
+    DebugTest() : mDebugExtensionAvailable(false)
+    {
+        setWindowWidth(128);
+        setWindowHeight(128);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+        setConfigDepthBits(24);
+        setDebugEnabled(true);
+    }
+
+    void SetUp() override
+    {
+        ANGLETest::SetUp();
+
+        mDebugExtensionAvailable = extensionEnabled("GL_KHR_debug");
+        if (mDebugExtensionAvailable)
+        {
+            glEnable(GL_DEBUG_OUTPUT);
+        }
+    }
+
+    bool mDebugExtensionAvailable;
+};
+
+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(DebugTest, Enabled)
+{
+    ASSERT_TRUE(mDebugExtensionAvailable);
+}
+
+// Test that when debug output is disabled, no message are outputted
+TEST_P(DebugTest, DisabledOutput)
+{
+    if (!mDebugExtensionAvailable)
+    {
+        std::cout << "Test skipped because GL_KHR_debug is not available." << std::endl;
+        return;
+    }
+
+    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(DebugTest, InsertMessage)
+{
+    if (!mDebugExtensionAvailable)
+    {
+        std::cout << "Test skipped because GL_KHR_debug is not available." << std::endl;
+        return;
+    }
+
+    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()), messageLength);
+
+    GLenum sourceBuf   = 0;
+    GLenum typeBuf     = 0;
+    GLenum idBuf       = 0;
+    GLenum severityBuf = 0;
+    GLsizei lengthBuf = 0;
+    std::vector<char> messageBuf(messageLength + 1);
+    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(DebugTest, InsertMessageMultiple)
+{
+    if (!mDebugExtensionAvailable)
+    {
+        std::cout << "Test skipped because GL_KHR_debug is not available." << std::endl;
+        return;
+    }
+
+    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()), messageLength);
+
+        GLenum sourceBuf   = 0;
+        GLenum typeBuf     = 0;
+        GLenum idBuf       = 0;
+        GLenum severityBuf = 0;
+        GLsizei lengthBuf = 0;
+        std::vector<char> messageBuf(messageLength + 1);
+        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 using a debug callback
+TEST_P(DebugTest, DebugCallback)
+{
+    if (!mDebugExtensionAvailable)
+    {
+        std::cout << "Test skipped because GL_KHR_debug is not available." << std::endl;
+        return;
+    }
+
+    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(DebugTest, GetPointer)
+{
+    if (!mDebugExtensionAvailable)
+    {
+        std::cout << "Test skipped because GL_KHR_debug is not available." << std::endl;
+        return;
+    }
+
+    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(DebugTest, MessageControl1)
+{
+    if (!mDebugExtensionAvailable)
+    {
+        std::cout << "Test skipped because GL_KHR_debug is not available." << std::endl;
+        return;
+    }
+
+    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, NULL, 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, NULL, 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(DebugTest, MessageControl2)
+{
+    if (!mDebugExtensionAvailable)
+    {
+        std::cout << "Test skipped because GL_KHR_debug is not available." << std::endl;
+        return;
+    }
+
+    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, NULL, GL_FALSE);
+    glDebugMessageControlKHR(GL_DEBUG_SOURCE_THIRD_PARTY, GL_DONT_CARE, GL_DONT_CARE, 0, NULL,
+                             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, NULL, 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(DebugTest, ObjectLabels)
+{
+    if (!mDebugExtensionAvailable)
+    {
+        std::cout << "Test skipped because GL_KHR_debug is not available." << std::endl;
+        return;
+    }
+
+    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(DebugTest, ObjectPtrLabels)
+{
+    if (!mDebugExtensionAvailable || getClientMajorVersion() < 3)
+    {
+        std::cout << "Test skipped because GL_KHR_debug or ES3 is not available." << std::endl;
+        return;
+    }
+
+    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);
+}
+
+// Use this to select which configurations (e.g. which renderer, which GLES major version) these
+// tests should be run against.
+ANGLE_INSTANTIATE_TEST(DebugTest,
+                       ES2_D3D9(),
+                       ES2_D3D11(),
+                       ES3_D3D11(),
+                       ES2_OPENGL(),
+                       ES3_OPENGL());
+
+}  // namespace angle