/*-------------------------------------------------------------------------
 * drawElements Quality Program EGL Module
 * ---------------------------------------
 *
 * Copyright 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Test negative use case of KHR_partial_update
 *//*--------------------------------------------------------------------*/

#include "teglNegativePartialUpdateTests.hpp"

#include "tcuTestLog.hpp"
#include "tcuSurface.hpp"

#include "egluCallLogWrapper.hpp"
#include "egluConfigFilter.hpp"
#include "egluNativeWindow.hpp"
#include "egluStrUtil.hpp"
#include "egluUnique.hpp"
#include "egluUtil.hpp"

#include "eglwLibrary.hpp"
#include "eglwEnums.hpp"

using namespace eglu;
using namespace eglw;
using tcu::TestLog;

namespace deqp
{
namespace egl
{
namespace
{

class NegativePartialUpdateTest : public TestCase
{
public:
    enum SurfaceType // used as a bit field when selecting a suitable EGL config
    {
        SURFACETYPE_WINDOW  = 1 << 0,
        SURFACETYPE_PBUFFER = 1 << 1
    };

    NegativePartialUpdateTest(EglTestContext &eglTestCtx, bool preserveBuffer, SurfaceType surfaceType,
                              const char *name, const char *description);
    ~NegativePartialUpdateTest(void);
    void init(void);
    void deinit(void);
    virtual IterateResult iterate(void) = 0;

protected:
    void expectError(eglw::EGLenum error);
    void expectBoolean(EGLBoolean expected, EGLBoolean got);
    inline void expectTrue(eglw::EGLBoolean got)
    {
        expectBoolean(EGL_TRUE, got);
    }
    inline void expectFalse(eglw::EGLBoolean got)
    {
        expectBoolean(EGL_FALSE, got);
    }

    const bool m_preserveBuffer;
    SurfaceType m_surfaceType;
    EGLDisplay m_eglDisplay;
    EGLConfig m_eglConfig;
    NativeWindow *m_window;
    EGLSurface m_eglSurface;
    EGLContext m_eglContext;
};

bool isWindow(const CandidateConfig &c)
{
    return (c.surfaceType() & EGL_WINDOW_BIT) == EGL_WINDOW_BIT;
}

bool isPbuffer(const CandidateConfig &c)
{
    return (c.surfaceType() & EGL_PBUFFER_BIT) == EGL_PBUFFER_BIT;
}

bool isES2Renderable(const CandidateConfig &c)
{
    return (c.get(EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT) == EGL_OPENGL_ES2_BIT;
}

bool hasPreserveSwap(const CandidateConfig &c)
{
    return (c.surfaceType() & EGL_SWAP_BEHAVIOR_PRESERVED_BIT) == EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
}

EGLConfig getEGLConfig(const Library &egl, EGLDisplay eglDisplay, unsigned surfaceTypes, bool preserveBuffer)
{
    FilterList filters;
    if ((surfaceTypes & NegativePartialUpdateTest::SURFACETYPE_WINDOW) != 0)
        filters << isWindow;
    if ((surfaceTypes & NegativePartialUpdateTest::SURFACETYPE_PBUFFER) != 0)
        filters << isPbuffer;
    if (((surfaceTypes & NegativePartialUpdateTest::SURFACETYPE_WINDOW) == 0) &&
        ((surfaceTypes & NegativePartialUpdateTest::SURFACETYPE_PBUFFER) == 0))
        DE_FATAL("Invalid surfaceType");

    filters << isES2Renderable;

    if (preserveBuffer)
        filters << hasPreserveSwap;

    return chooseSingleConfig(egl, eglDisplay, filters);
}

EGLContext initAndMakeCurrentEGLContext(const Library &egl, EGLDisplay eglDisplay, EGLSurface eglSurface,
                                        EGLConfig eglConfig, const EGLint *attribList)
{
    EGLContext eglContext = EGL_NO_CONTEXT;

    egl.bindAPI(EGL_OPENGL_ES_API);
    eglContext = egl.createContext(eglDisplay, eglConfig, EGL_NO_CONTEXT, attribList);
    EGLU_CHECK_MSG(egl, "eglCreateContext");
    TCU_CHECK(eglSurface != EGL_NO_SURFACE);
    egl.makeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
    EGLU_CHECK_MSG(egl, "eglMakeCurrent");

    return eglContext;
}

NegativePartialUpdateTest::NegativePartialUpdateTest(EglTestContext &eglTestCtx, bool preserveBuffer,
                                                     SurfaceType surfaceType, const char *name, const char *description)
    : TestCase(eglTestCtx, name, description)
    , m_preserveBuffer(preserveBuffer)
    , m_surfaceType(surfaceType)
    , m_eglDisplay(EGL_NO_DISPLAY)
    , m_window(DE_NULL)
    , m_eglSurface(EGL_NO_SURFACE)
    , m_eglContext(EGL_NO_CONTEXT)
{
}

NegativePartialUpdateTest::~NegativePartialUpdateTest(void)
{
    deinit();
}

void NegativePartialUpdateTest::init(void)
{
    const Library &egl                      = m_eglTestCtx.getLibrary();
    static const EGLint contextAttribList[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
    const int width                         = 480;
    const int height                        = 480;

    m_eglDisplay = getAndInitDisplay(m_eglTestCtx.getNativeDisplay());

    if (!hasExtension(egl, m_eglDisplay, "EGL_KHR_partial_update"))
        TCU_THROW(NotSupportedError, "EGL_KHR_partial_update is not supported");

    if (m_surfaceType == SURFACETYPE_PBUFFER)
    {
        m_eglConfig                      = getEGLConfig(egl, m_eglDisplay, SURFACETYPE_PBUFFER, m_preserveBuffer);
        const EGLint pbufferAttribList[] = {EGL_WIDTH, width, EGL_HEIGHT, height, EGL_NONE};
        m_eglSurface                     = egl.createPbufferSurface(m_eglDisplay, m_eglConfig, pbufferAttribList);
    }
    else
    {
        m_eglConfig = getEGLConfig(egl, m_eglDisplay, SURFACETYPE_WINDOW | SURFACETYPE_PBUFFER, m_preserveBuffer);
        const NativeWindowFactory &factory =
            selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine());
        m_window = factory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, m_eglConfig, DE_NULL,
                                        WindowParams(width, height, parseWindowVisibility(m_testCtx.getCommandLine())));
        m_eglSurface =
            createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_window, m_eglDisplay, m_eglConfig, DE_NULL);
    }
    m_eglContext = initAndMakeCurrentEGLContext(egl, m_eglDisplay, m_eglSurface, m_eglConfig, contextAttribList);
}

void NegativePartialUpdateTest::deinit(void)
{
    const Library &egl = m_eglTestCtx.getLibrary();

    if (m_eglContext != EGL_NO_CONTEXT)
    {
        EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
        EGLU_CHECK_CALL(egl, destroyContext(m_eglDisplay, m_eglContext));
        m_eglContext = EGL_NO_CONTEXT;
    }

    if (m_eglSurface != EGL_NO_SURFACE)
    {
        EGLU_CHECK_CALL(egl, destroySurface(m_eglDisplay, m_eglSurface));
        m_eglSurface = EGL_NO_SURFACE;
    }

    if (m_eglDisplay != EGL_NO_DISPLAY)
    {
        EGLU_CHECK_CALL(egl, terminate(m_eglDisplay));
        m_eglDisplay = EGL_NO_DISPLAY;
    }

    delete m_window;
    m_window = DE_NULL;
}

void NegativePartialUpdateTest::expectError(EGLenum expected)
{
    const EGLenum err = m_eglTestCtx.getLibrary().getError();

    if (err != expected)
    {
        m_testCtx.getLog() << TestLog::Message << "// ERROR expected: " << eglu::getErrorStr(expected)
                           << ", Got: " << eglu::getErrorStr(err) << TestLog::EndMessage;
        if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid error");
    }
}

void NegativePartialUpdateTest::expectBoolean(EGLBoolean expected, EGLBoolean got)
{
    if (expected != got)
    {
        m_testCtx.getLog() << TestLog::Message << "// ERROR expected: " << eglu::getBooleanStr(expected)
                           << ", Got: " << eglu::getBooleanStr(got) << TestLog::EndMessage;
        if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
    }
}

class NotPostableTest : public NegativePartialUpdateTest
{
public:
    NotPostableTest(EglTestContext &context);
    TestCase::IterateResult iterate(void);
};

NotPostableTest::NotPostableTest(EglTestContext &context)
    : NegativePartialUpdateTest(context, false, SURFACETYPE_PBUFFER, "not_postable_surface",
                                "Call setDamageRegion() on pbuffer")
{
}

TestCase::IterateResult NotPostableTest::iterate(void)
{
    const Library &egl = m_eglTestCtx.getLibrary();
    TestLog &log       = m_testCtx.getLog();
    CallLogWrapper wrapper(egl, log);
    EGLint damageRegion[] = {10, 10, 10, 10};
    int bufferAge         = -1;

    wrapper.enableLogging(true);
    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    {
        tcu::ScopedLogSection(log, "Test1", "If the surface is pbuffer (not postable) --> EGL_BAD_MATCH");
        EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
        EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
        expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion,
                                                  DE_LENGTH_OF_ARRAY(damageRegion) / 4));
        expectError(EGL_BAD_MATCH);
    }

    return STOP;
}

class NotCurrentSurfaceTest : public NegativePartialUpdateTest
{
public:
    NotCurrentSurfaceTest(EglTestContext &context);
    TestCase::IterateResult iterate(void);
};

NotCurrentSurfaceTest::NotCurrentSurfaceTest(EglTestContext &context)
    : NegativePartialUpdateTest(context, false, SURFACETYPE_WINDOW, "not_current_surface",
                                "Call setDamageRegion() on pbuffer")
{
}

TestCase::IterateResult NotCurrentSurfaceTest::iterate(void)
{
    const int impossibleBufferAge = -26084;
    const Library &egl            = m_eglTestCtx.getLibrary();
    const EGLint attribList[]     = {EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE};
    const eglu::UniqueSurface unusedPbuffer(egl, m_eglDisplay,
                                            egl.createPbufferSurface(m_eglDisplay, m_eglConfig, attribList));
    TestLog &log = m_testCtx.getLog();
    CallLogWrapper wrapper(egl, log);
    EGLint damageRegion[] = {10, 10, 10, 10};
    int bufferAge         = impossibleBufferAge;

    wrapper.enableLogging(true);
    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, *unusedPbuffer, *unusedPbuffer, m_eglContext));
    {
        tcu::ScopedLogSection(
            log, "Test2.1",
            "If query buffer age on a surface that is not the current draw surface --> EGL_BAD_SURFACE");
        EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
        expectFalse(wrapper.eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
        expectError(EGL_BAD_SURFACE);

        if (bufferAge != impossibleBufferAge)
        {
            log << tcu::TestLog::Message
                << "On failure, eglQuerySurface shouldn't change buffer age but buffer age has been changed to "
                << bufferAge << tcu::TestLog::EndMessage;
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, bufferAge shouldn't be changed");
        }
    }
    {
        tcu::ScopedLogSection(
            log, "Test2.2",
            "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH");
        expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1));
        expectError(EGL_BAD_MATCH);
    }

    EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
    {
        tcu::ScopedLogSection(
            log, "Test3.1",
            "If query buffer age on a surface that is not the current draw surface --> EGL_BAD_SURFACE");
        EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
        expectFalse(wrapper.eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
        expectError(EGL_BAD_SURFACE);

        if (bufferAge != impossibleBufferAge)
        {
            log << tcu::TestLog::Message
                << "On failure, eglQuerySurface shouldn't change buffer age but buffer age has been changed to "
                << bufferAge << tcu::TestLog::EndMessage;
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, bufferAge shouldn't be changed");
        }
    }
    {
        tcu::ScopedLogSection(
            log, "Test3.2",
            "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH");
        expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1));
        expectError(EGL_BAD_MATCH);
    }

    if (hasExtension(egl, m_eglDisplay, "EGL_KHR_surfaceless_context"))
    {
        EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, m_eglContext));
        {
            tcu::ScopedLogSection(
                log, "Test4.1",
                "If query buffer age on a surface that is not the current draw surface --> EGL_BAD_SURFACE");
            EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
            expectFalse(wrapper.eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
            expectError(EGL_BAD_SURFACE);

            if (bufferAge != impossibleBufferAge)
            {
                log << tcu::TestLog::Message
                    << "On failure, eglQuerySurface shouldn't change buffer age but buffer age has been changed to "
                    << bufferAge << tcu::TestLog::EndMessage;
                m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail, bufferAge shouldn't be changed");
            }
        }
        {
            tcu::ScopedLogSection(
                log, "Test4.2",
                "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH");
            expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1));
            expectError(EGL_BAD_MATCH);
        }
    }

    return STOP;
}

class BufferPreservedTest : public NegativePartialUpdateTest
{
public:
    BufferPreservedTest(EglTestContext &context);
    TestCase::IterateResult iterate(void);
};

BufferPreservedTest::BufferPreservedTest(EglTestContext &context)
    : NegativePartialUpdateTest(context, true, SURFACETYPE_WINDOW, "buffer_preserved",
                                "Call setDamageRegion() on pbuffer")
{
}

TestCase::IterateResult BufferPreservedTest::iterate(void)
{
    const Library &egl = m_eglTestCtx.getLibrary();
    TestLog &log       = m_testCtx.getLog();
    CallLogWrapper wrapper(egl, log);
    EGLint damageRegion[] = {10, 10, 10, 10};
    int bufferAge         = -1;

    wrapper.enableLogging(true);
    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    {
        tcu::ScopedLogSection(log, "Test3", "If buffer_preserved --> EGL_BAD_MATCH");
        EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED));
        EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
        expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion,
                                                  DE_LENGTH_OF_ARRAY(damageRegion) / 4));
        expectError(EGL_BAD_MATCH);
    }

    return STOP;
}

class SetTwiceTest : public NegativePartialUpdateTest
{
public:
    SetTwiceTest(EglTestContext &context);
    TestCase::IterateResult iterate(void);
};

SetTwiceTest::SetTwiceTest(EglTestContext &context)
    : NegativePartialUpdateTest(context, false, SURFACETYPE_WINDOW, "set_damage_region_twice",
                                "Call setDamageRegion() twice")
{
}

TestCase::IterateResult SetTwiceTest::iterate(void)
{
    const Library &egl = m_eglTestCtx.getLibrary();
    TestLog &log       = m_testCtx.getLog();
    CallLogWrapper wrapper(egl, log);
    EGLint damageRegion[] = {10, 10, 10, 10};
    int bufferAge         = -1;

    wrapper.enableLogging(true);
    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    {
        tcu::ScopedLogSection(log, "Test4", "If call setDamageRegion() twice --> EGL_BAD_ACCESS");
        EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
        EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
        expectTrue(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion,
                                                 DE_LENGTH_OF_ARRAY(damageRegion) / 4));
        expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion,
                                                  DE_LENGTH_OF_ARRAY(damageRegion) / 4));
        expectError(EGL_BAD_ACCESS);
    }

    return STOP;
}

class NoAgeTest : public NegativePartialUpdateTest
{
public:
    NoAgeTest(EglTestContext &context);
    TestCase::IterateResult iterate(void);
};

NoAgeTest::NoAgeTest(EglTestContext &context)
    : NegativePartialUpdateTest(context, false, SURFACETYPE_WINDOW, "set_damage_region_before_query_age",
                                "Call setDamageRegion() without querying buffer age")
{
}

TestCase::IterateResult NoAgeTest::iterate(void)
{
    const Library &egl = m_eglTestCtx.getLibrary();
    TestLog &log       = m_testCtx.getLog();
    CallLogWrapper wrapper(egl, log);
    EGLint damageRegion[] = {10, 10, 10, 10};

    wrapper.enableLogging(true);
    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    {
        tcu::ScopedLogSection(log, "Test5", "If buffer age is not queried --> EGL_BAD_ACCESS");
        EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
        expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion,
                                                  DE_LENGTH_OF_ARRAY(damageRegion) / 4));
        expectError(EGL_BAD_ACCESS);
    }

    return STOP;
}

class PassNullTest : public NegativePartialUpdateTest
{
public:
    PassNullTest(EglTestContext &context);
    TestCase::IterateResult iterate(void);
};

PassNullTest::PassNullTest(EglTestContext &context)
    : NegativePartialUpdateTest(context, false, SURFACETYPE_WINDOW, "pass_null_0_as_params",
                                "Call setDamageRegion() with (NULL, 0)")
{
}

TestCase::IterateResult PassNullTest::iterate(void)
{
    const Library &egl = m_eglTestCtx.getLibrary();
    TestLog &log       = m_testCtx.getLog();
    CallLogWrapper wrapper(egl, log);
    int bufferAge = -1;

    wrapper.enableLogging(true);
    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    {
        tcu::ScopedLogSection(log, "Test6", "If pass (null, 0) to setDamageRegion(), no error");
        EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
        EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));
        expectTrue(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, DE_NULL, 0));
        expectError(EGL_SUCCESS);
    }

    return STOP;
}

class NotCurrentSurfaceTest2 : public NegativePartialUpdateTest
{
public:
    NotCurrentSurfaceTest2(EglTestContext &context);
    TestCase::IterateResult iterate(void);
};

NotCurrentSurfaceTest2::NotCurrentSurfaceTest2(EglTestContext &context)
    : NegativePartialUpdateTest(context, false, SURFACETYPE_WINDOW, "not_current_surface2",
                                "Call setDamageRegion() on pbuffer")
{
}

TestCase::IterateResult NotCurrentSurfaceTest2::iterate(void)
{
    const Library &egl        = m_eglTestCtx.getLibrary();
    const EGLint attribList[] = {EGL_WIDTH, 64, EGL_HEIGHT, 64, EGL_NONE};
    const eglu::UniqueSurface unusedPbuffer(egl, m_eglDisplay,
                                            egl.createPbufferSurface(m_eglDisplay, m_eglConfig, attribList));
    TestLog &log = m_testCtx.getLog();
    CallLogWrapper wrapper(egl, log);
    EGLint damageRegion[] = {10, 10, 10, 10};
    int bufferAge         = -1;

    wrapper.enableLogging(true);
    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

    EGLU_CHECK_CALL(egl, surfaceAttrib(m_eglDisplay, m_eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_DESTROYED));
    EGLU_CHECK_CALL(egl, querySurface(m_eglDisplay, m_eglSurface, EGL_BUFFER_AGE_KHR, &bufferAge));

    {
        tcu::ScopedLogSection(
            log, "Test7",
            "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH");
        EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, *unusedPbuffer, *unusedPbuffer, m_eglContext));
        expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1));
        expectError(EGL_BAD_MATCH);
    }
    {
        tcu::ScopedLogSection(
            log, "Test8",
            "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH");
        EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
        expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1));
        expectError(EGL_BAD_MATCH);
    }
    if (hasExtension(egl, m_eglDisplay, "EGL_KHR_surfaceless_context"))
    {
        tcu::ScopedLogSection(
            log, "Test9",
            "If call setDamageRegion() on a surface that is not the current draw surface --> EGL_BAD_MATCH");
        EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, m_eglContext));
        expectFalse(wrapper.eglSetDamageRegionKHR(m_eglDisplay, m_eglSurface, damageRegion, 1));
        expectError(EGL_BAD_MATCH);
    }

    return STOP;
}

} // namespace

NegativePartialUpdateTests::NegativePartialUpdateTests(EglTestContext &eglTestCtx)
    : TestCaseGroup(eglTestCtx, "negative_partial_update", "Negative partial update tests")
{
}

void NegativePartialUpdateTests::init(void)
{
    addChild(new NotPostableTest(m_eglTestCtx));
    addChild(new NotCurrentSurfaceTest(m_eglTestCtx));
    addChild(new BufferPreservedTest(m_eglTestCtx));
    addChild(new SetTwiceTest(m_eglTestCtx));
    addChild(new NoAgeTest(m_eglTestCtx));
    addChild(new PassNullTest(m_eglTestCtx));
    addChild(new NotCurrentSurfaceTest2(m_eglTestCtx));
}

} // namespace egl
} // namespace deqp