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

// RobustClientMemoryTest.cpp : Tests of the GL_ANGLE_robust_client_memory extension.

#include "test_utils/ANGLETest.h"

#include "test_utils/gl_raii.h"

namespace angle
{

constexpr GLsizei kWindowSize = 128;

class RobustClientMemoryTest : public ANGLETest<>
{
  protected:
    RobustClientMemoryTest()
    {
        setWindowWidth(kWindowSize);
        setWindowHeight(kWindowSize);
        setConfigRedBits(8);
        setConfigGreenBits(8);
        setConfigBlueBits(8);
        setConfigAlphaBits(8);
    }
};

// Test basic usage and validation of glGetIntegervRobustANGLE
TEST_P(RobustClientMemoryTest, GetInteger)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory"));

    // Verify that the robust and regular entry points return the same values
    GLint resultRobust;
    GLsizei length;
    glGetIntegervRobustANGLE(GL_MAX_VERTEX_ATTRIBS, 1, &length, &resultRobust);
    EXPECT_GL_NO_ERROR();
    EXPECT_EQ(1, length);

    GLint resultRegular;
    glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &resultRegular);
    EXPECT_GL_NO_ERROR();
    EXPECT_EQ(resultRegular, resultRobust);

    // Query a dynamic value
    GLint numCompressedFormats;
    glGetIntegervRobustANGLE(GL_NUM_COMPRESSED_TEXTURE_FORMATS, 1, &length, &numCompressedFormats);
    ASSERT_GL_NO_ERROR();
    EXPECT_EQ(1, length);

    if (numCompressedFormats > 0)
    {
        std::vector<GLint> resultBuf(numCompressedFormats * 2, 0);

        // Test when the bufSize is too low
        glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS, numCompressedFormats - 1, &length,
                                 resultBuf.data());
        EXPECT_GL_ERROR(GL_INVALID_OPERATION);
        EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(),
                                [](GLint value) { return value == 0; }));

        // Make sure the GL doesn't touch the end of the buffer
        glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS,
                                 static_cast<GLsizei>(resultBuf.size()), &length, resultBuf.data());
        EXPECT_GL_NO_ERROR();
        EXPECT_EQ(numCompressedFormats, length);
        EXPECT_TRUE(std::none_of(resultBuf.begin(), resultBuf.begin() + length,
                                 [](GLint value) { return value == 0; }));
        EXPECT_TRUE(std::all_of(resultBuf.begin() + length, resultBuf.end(),
                                [](GLint value) { return value == 0; }));
    }

    // Test with null length
    glGetIntegervRobustANGLE(GL_MAX_VARYING_VECTORS, 1, nullptr, &resultRobust);
    EXPECT_GL_NO_ERROR();

    glGetIntegervRobustANGLE(GL_MAX_VIEWPORT_DIMS, 1, nullptr, &resultRobust);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    GLint maxViewportDims[2];
    glGetIntegervRobustANGLE(GL_MAX_VIEWPORT_DIMS, 2, nullptr, maxViewportDims);
    EXPECT_GL_NO_ERROR();
}

// Test basic usage and validation of glGetInteger64vRobustANGLE
TEST_P(RobustClientMemoryTest, GetInteger64)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory"));
    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);

    constexpr GLint64 kMinRequiredMaxElementIndex = 16777215;

    // Verify that the regular and robust entry points return the same values
    GLint64 resultRegular;
    glGetInteger64v(GL_MAX_ELEMENT_INDEX, &resultRegular);
    ASSERT_GL_NO_ERROR();
    ASSERT_GE(resultRegular, kMinRequiredMaxElementIndex);

    GLsizei length;
    GLint64 resultRobust;
    glGetInteger64vRobustANGLE(GL_MAX_ELEMENT_INDEX, 1, &length, &resultRobust);
    EXPECT_GL_NO_ERROR();
    EXPECT_EQ(1, length);
    EXPECT_EQ(resultRegular, resultRobust);
}

// Test basic usage and validation of glTexImage2DRobustANGLE and glTexSubImage2DRobustANGLE
TEST_P(RobustClientMemoryTest, TexImage2D)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory"));

    GLTexture tex;
    glBindTexture(GL_TEXTURE_2D, tex);

    GLsizei dataDimension = 1024;
    std::vector<GLubyte> rgbaData(dataDimension * dataDimension * 4);

    // Test the regular case
    glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA,
                            GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()),
                            rgbaData.data());
    EXPECT_GL_NO_ERROR();

    glTexSubImage2DRobustANGLE(GL_TEXTURE_2D, 0, 0, 0, dataDimension, dataDimension, GL_RGBA,
                               GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()),
                               rgbaData.data());
    EXPECT_GL_NO_ERROR();

    // Test with no data and zero size
    glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA,
                            GL_UNSIGNED_BYTE, 0, nullptr);
    EXPECT_GL_NO_ERROR();

    // Test with data and negative size
    glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA,
                            GL_UNSIGNED_BYTE, -1, rgbaData.data());
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Test with no data and negative size
    glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA,
                            GL_UNSIGNED_BYTE, -1, nullptr);
    EXPECT_GL_ERROR(GL_INVALID_VALUE);

    // Test with no data and positive size
    glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA,
                            GL_UNSIGNED_BYTE, 1, nullptr);
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    // Test with a data size that is too small
    glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA,
                            GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()) / 2,
                            rgbaData.data());
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    glTexSubImage2DRobustANGLE(GL_TEXTURE_2D, 0, 0, 0, dataDimension, dataDimension, GL_RGBA,
                               GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()) / 2,
                               rgbaData.data());
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);

    if (getClientMajorVersion() >= 3)
    {
        {
            // Test bufSize when a PBO is bound
            GLBuffer buffer;
            glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
            glBufferData(GL_PIXEL_UNPACK_BUFFER, rgbaData.size(), nullptr, GL_STATIC_COPY);

            // Zero bufSize must be accepted
            glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0,
                                    GL_RGBA, GL_UNSIGNED_BYTE, 0, reinterpret_cast<void *>(0));
            EXPECT_GL_NO_ERROR();

            // Positive bufSize must be rejected
            glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0,
                                    GL_RGBA, GL_UNSIGNED_BYTE, 1, reinterpret_cast<void *>(0));
            EXPECT_GL_ERROR(GL_INVALID_OPERATION);

            // Negative bufSize is invalid
            glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0,
                                    GL_RGBA, GL_UNSIGNED_BYTE, -1, reinterpret_cast<void *>(0));
            EXPECT_GL_ERROR(GL_INVALID_VALUE);

            glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
        }

        // Set an unpack parameter that would cause the driver to read past the end of the buffer
        glPixelStorei(GL_UNPACK_ROW_LENGTH, dataDimension + 1);
        glTexImage2DRobustANGLE(GL_TEXTURE_2D, 0, GL_RGBA, dataDimension, dataDimension, 0, GL_RGBA,
                                GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()),
                                rgbaData.data());
        EXPECT_GL_ERROR(GL_INVALID_OPERATION);
    }
}

// Test basic usage and validation of glReadPixelsRobustANGLE
TEST_P(RobustClientMemoryTest, ReadPixels)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory"));

    // TODO(ynovikov): Looks like a driver bug on Intel HD 530 http://anglebug.com/42260689
    ANGLE_SKIP_TEST_IF(IsLinux() && IsIntel() && IsDesktopOpenGL());

    GLsizei dataDimension = 16;
    std::vector<GLubyte> rgbaData(dataDimension * dataDimension * 4);

    // Test the regular case
    GLsizei length  = -1;
    GLsizei columns = -1;
    GLsizei rows    = -1;
    glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE,
                            static_cast<GLsizei>(rgbaData.size()), &length, &columns, &rows,
                            rgbaData.data());
    EXPECT_GL_NO_ERROR();
    EXPECT_EQ(static_cast<GLsizei>(rgbaData.size()), length);
    EXPECT_EQ(dataDimension, columns);
    EXPECT_EQ(dataDimension, rows);

    // Test a case that would be partially clipped
    length  = -1;
    columns = -1;
    rows    = -1;
    glReadPixelsRobustANGLE(-1, kWindowSize - dataDimension + 3, dataDimension, dataDimension,
                            GL_RGBA, GL_UNSIGNED_BYTE, static_cast<GLsizei>(rgbaData.size()),
                            &length, &columns, &rows, rgbaData.data());
    EXPECT_GL_NO_ERROR();
    EXPECT_EQ(static_cast<GLsizei>(rgbaData.size()), length);
    EXPECT_EQ(dataDimension - 1, columns);
    EXPECT_EQ(dataDimension - 3, rows);

    length  = 123;
    columns = 456;
    rows    = 789;
    // Test with a data size that is too small, the output params must not be updated
    glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE,
                            static_cast<GLsizei>(rgbaData.size()) - 1, &length, &columns, &rows,
                            rgbaData.data());
    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
    EXPECT_EQ(length, 123);
    EXPECT_EQ(columns, 456);
    EXPECT_EQ(rows, 789);

    // Test that all output parameters may be null
    glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE,
                            static_cast<GLsizei>(rgbaData.size()), nullptr, nullptr, nullptr,
                            rgbaData.data());
    EXPECT_GL_NO_ERROR();

    if (getClientMajorVersion() >= 3)
    {
        {
            // Test that non-negative bufSize is ignored when a PBO is bound
            GLBuffer buffer;
            glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer);
            glBufferData(GL_PIXEL_PACK_BUFFER, rgbaData.size(), nullptr, GL_STATIC_COPY);

            // Zero bufSize must be accepted
            glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE,
                                    0, nullptr, nullptr, nullptr, reinterpret_cast<void *>(0));
            EXPECT_GL_NO_ERROR();

            // Small bufSize must be accepted
            glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE,
                                    16, nullptr, nullptr, nullptr, reinterpret_cast<void *>(0));
            EXPECT_GL_NO_ERROR();

            // Test that negative bufSize is still invalid when a PBO is bound
            glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE,
                                    -1, nullptr, nullptr, nullptr, reinterpret_cast<void *>(0));
            EXPECT_GL_ERROR(GL_INVALID_VALUE);

            glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
        }

        // Set a pack parameter that would cause the driver to write past the end of the buffer
        glPixelStorei(GL_PACK_ROW_LENGTH, dataDimension + 1);
        glReadPixelsRobustANGLE(0, 0, dataDimension, dataDimension, GL_RGBA, GL_UNSIGNED_BYTE,
                                static_cast<GLsizei>(rgbaData.size()), &length, nullptr, nullptr,
                                rgbaData.data());
        EXPECT_GL_ERROR(GL_INVALID_OPERATION);
    }
}

// Test the output length parameter
TEST_P(RobustClientMemoryTest, ReadPixelsLengthOutput)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory"));

    // Buffer twice as large as the window
    std::vector<GLubyte> rgbaData(2 * kWindowSize * kWindowSize * 4);

    // Test that output length is computed based on the input dimensions
    {
        // Input x, y, width, height, output length
        const int testValues[7][5] = {
            {0, 0, 0, 0, 0},               // Zero input area
            {0, 0, 128, 0, 0},             // Zero input height
            {0, 0, 0, 128, 0},             // Zero input width
            {0, 0, 128, 128, 65536},       // Full size
            {64, 0, 64, 128, 32768},       // Half width with positive offset
            {0, -128, 128, 256, 131072},   // Full width, double height with negative offset
            {128, 128, 128, 256, 131072},  // Origin OOB, zero intersection
        };

        for (auto &test : testValues)
        {
            GLsizei length = -1;
            glReadPixelsRobustANGLE(test[0], test[1], test[2], test[3], GL_RGBA, GL_UNSIGNED_BYTE,
                                    static_cast<GLsizei>(rgbaData.size()), &length, nullptr,
                                    nullptr, rgbaData.data());
            EXPECT_GL_NO_ERROR();
            EXPECT_EQ(length, test[4]);
        }
    }

    // Test that output length is zero when reading to PBO
    if (getClientMajorVersion() >= 3)
    {
        GLsizei length = -1;
        GLBuffer buffer;
        glBindBuffer(GL_PIXEL_PACK_BUFFER, buffer);
        glBufferData(GL_PIXEL_PACK_BUFFER, rgbaData.size(), nullptr, GL_STATIC_COPY);
        glReadPixelsRobustANGLE(0, 0, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE,
                                static_cast<GLsizei>(rgbaData.size()), &length, nullptr, nullptr,
                                reinterpret_cast<void *>(0));
        EXPECT_GL_NO_ERROR();
        EXPECT_EQ(length, 0);

        // Unbind and repeat
        glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
        glReadPixelsRobustANGLE(0, 0, 128, 128, GL_RGBA, GL_UNSIGNED_BYTE,
                                static_cast<GLsizei>(rgbaData.size()), &length, nullptr, nullptr,
                                rgbaData.data());
        EXPECT_GL_NO_ERROR();
        EXPECT_EQ(length, 128 * 128 * 4);
    }
}

// Test edge cases of the returned image dimensions
TEST_P(RobustClientMemoryTest, ReadPixelsClipping)
{
    ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_ANGLE_robust_client_memory"));

    // Buffer twice as large as the window
    std::vector<GLubyte> rgbaData(2 * kWindowSize * kWindowSize * 4);

    // Origin, input dimension, output dimension
    const int testValues[16][3] = {
        {-15, 0, 0},      // Negative origin with zero length
        {-15, 16, 1},     // Negative origin with overlapping region
        {-16, 16, 0},     // Negative origin with adjacent region
        {-17, 16, 0},     // Negative origin with non-overlapping region
        {-16, 144, 128},  // Negative origin with exact length
        {-16, 160, 128},  // Negative origin with large length
        {0, 0, 0},        // Zero origin with zero length
        {0, 128, 128},    // Zero origin with exact length
        {0, 16, 16},      // Zero origin with small length
        {0, 144, 128},    // Zero origin with large length
        {16, 0, 0},       // Positive origin with zero length
        {16, 112, 112},   // Positive origin with exact length
        {16, 32, 32},     // Positive origin with small length
        {16, 128, 112},   // Positive origin with large width
        {144, 0, 0},      // Out of range origin with zero length
        {144, 16, 0},     // Out of range origin with non-zero length
    };

    for (auto &test : testValues)
    {
        // Test columns and rows separately
        {
            GLsizei columns = -1;
            glReadPixelsRobustANGLE(test[0], 0, test[1], 128, GL_RGBA, GL_UNSIGNED_BYTE,
                                    static_cast<GLsizei>(rgbaData.size()), nullptr, &columns,
                                    nullptr, rgbaData.data());
            EXPECT_GL_NO_ERROR();
            EXPECT_EQ(columns, test[2]);

            GLsizei rows = -1;
            glReadPixelsRobustANGLE(0, test[0], 128, test[1], GL_RGBA, GL_UNSIGNED_BYTE,
                                    static_cast<GLsizei>(rgbaData.size()), nullptr, nullptr, &rows,
                                    rgbaData.data());
            EXPECT_GL_NO_ERROR();
            EXPECT_EQ(rows, test[2]);
        }

        // Test that if one output is zero, then the other output is also zero
        if (test[2] == 0)
        {
            GLsizei columns = -1;
            GLsizei rows    = -1;
            glReadPixelsRobustANGLE(test[0], 0, test[1], 128, GL_RGBA, GL_UNSIGNED_BYTE,
                                    static_cast<GLsizei>(rgbaData.size()), nullptr, &columns, &rows,
                                    rgbaData.data());
            EXPECT_GL_NO_ERROR();
            EXPECT_EQ(columns, 0);
            EXPECT_EQ(rows, 0);

            columns = -1;
            rows    = -1;
            glReadPixelsRobustANGLE(0, test[0], 128, test[1], GL_RGBA, GL_UNSIGNED_BYTE,
                                    static_cast<GLsizei>(rgbaData.size()), nullptr, &columns, &rows,
                                    rgbaData.data());
            EXPECT_GL_NO_ERROR();
            EXPECT_EQ(columns, 0);
            EXPECT_EQ(rows, 0);
        }
    }
}

class RobustClientMemoryNoExtensionsTest : public RobustClientMemoryTest
{
  protected:
    RobustClientMemoryNoExtensionsTest() : RobustClientMemoryTest() { setExtensionsEnabled(false); }
};

// Test with empty result
TEST_P(RobustClientMemoryNoExtensionsTest, GetEmpty)
{
    GLint numFormats = 10;
    glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
    ASSERT_GL_NO_ERROR();
    ASSERT_EQ(numFormats, 0);  // Must be zero on unextended OpenGL ES 2.0

    GLsizei length = 1;
    std::vector<GLint> resultBuf(2, 3);

    // Test non-robust with empty response
    {
        glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, resultBuf.data());
        EXPECT_GL_NO_ERROR();

        // Must not touch the buffer
        EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(),
                                [](GLint value) { return value == 3; }));
    }

    ANGLE_SKIP_TEST_IF(!EnsureGLExtensionEnabled("GL_ANGLE_robust_client_memory"));

    // Test robust with empty response
    {
        glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS, resultBuf.size(), &length,
                                 resultBuf.data());
        EXPECT_GL_NO_ERROR();

        // Must update length
        EXPECT_EQ(length, 0);

        // Must not touch the buffer
        EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(),
                                [](GLint value) { return value == 3; }));
    }

    // Test robust with empty response and null length
    {
        glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS, resultBuf.size(), nullptr,
                                 resultBuf.data());
        EXPECT_GL_NO_ERROR();

        // Must not touch the buffer
        EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(),
                                [](GLint value) { return value == 3; }));
    }

    // Test robust with empty response, zero buffer size, and null length
    {
        glGetIntegervRobustANGLE(GL_COMPRESSED_TEXTURE_FORMATS, 0, nullptr, resultBuf.data());
        EXPECT_GL_NO_ERROR();

        // Must not touch the buffer
        EXPECT_TRUE(std::all_of(resultBuf.begin(), resultBuf.end(),
                                [](GLint value) { return value == 3; }));
    }
}

// Use this to select which configurations (e.g. which renderer, which GLES major version) these
// tests should be run against.
ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(RobustClientMemoryTest);

ANGLE_INSTANTIATE_TEST_ES2(RobustClientMemoryNoExtensionsTest);

}  // namespace angle