diff --git a/graphic/vkgl/BUILD.gn b/graphic/vkgl/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..73fbc9872a730c4734c8ce9605338864807e667d --- /dev/null +++ b/graphic/vkgl/BUILD.gn @@ -0,0 +1,140 @@ +# Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. +# 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. + +import("//test/xts/tools/build/suite.gni") + +group("VKGLCTSTest") { + testonly = true + deps = [ + "src/deqpgles2/build0001:ActsDeqpgles2TestSuite0001", + "src/deqpgles2/build0002:ActsDeqpgles2TestSuite0002", + "src/deqpgles2/build0003:ActsDeqpgles2TestSuite0003", + "src/deqpgles2/build0004:ActsDeqpgles2TestSuite0004", + "src/deqpgles2/build0005:ActsDeqpgles2TestSuite0005", + "src/deqpgles2/build0006:ActsDeqpgles2TestSuite0006", + "src/deqpgles2/build0007:ActsDeqpgles2TestSuite0007", + "src/deqpgles2/build0008:ActsDeqpgles2TestSuite0008", + "src/deqpgles2/build0009:ActsDeqpgles2TestSuite0009", + "src/deqpgles2/build0010:ActsDeqpgles2TestSuite0010", + "src/deqpgles2/build0011:ActsDeqpgles2TestSuite0011", + "src/deqpgles2/build0012:ActsDeqpgles2TestSuite0012", + "src/deqpgles2/build0013:ActsDeqpgles2TestSuite0013", + "src/deqpgles2/build0014:ActsDeqpgles2TestSuite0014", + "src/deqpgles2/build0015:ActsDeqpgles2TestSuite0015", + "src/deqpgles2/build0016:ActsDeqpgles2TestSuite0016", + "src/deqpgles2/build0017:ActsDeqpgles2TestSuite0017", + "src/deqpgles3/build0001:ActsDeqpgles3TestSuite0001", + "src/deqpgles3/build0002:ActsDeqpgles3TestSuite0002", + "src/deqpgles3/build0003:ActsDeqpgles3TestSuite0003", + "src/deqpgles3/build0004:ActsDeqpgles3TestSuite0004", + "src/deqpgles3/build0005:ActsDeqpgles3TestSuite0005", + "src/deqpgles3/build0006:ActsDeqpgles3TestSuite0006", + "src/deqpgles3/build0007:ActsDeqpgles3TestSuite0007", + "src/deqpgles3/build0008:ActsDeqpgles3TestSuite0008", + "src/deqpgles3/build0009:ActsDeqpgles3TestSuite0009", + "src/deqpgles3/build0010:ActsDeqpgles3TestSuite0010", + "src/deqpgles3/build0011:ActsDeqpgles3TestSuite0011", + "src/deqpgles3/build0012:ActsDeqpgles3TestSuite0012", + "src/deqpgles3/build0013:ActsDeqpgles3TestSuite0013", + "src/deqpgles3/build0014:ActsDeqpgles3TestSuite0014", + "src/deqpgles3/build0015:ActsDeqpgles3TestSuite0015", + "src/deqpgles3/build0016:ActsDeqpgles3TestSuite0016", + "src/deqpgles3/build0017:ActsDeqpgles3TestSuite0017", + "src/deqpgles3/build0018:ActsDeqpgles3TestSuite0018", + "src/deqpgles3/build0019:ActsDeqpgles3TestSuite0019", + "src/deqpgles3/build0020:ActsDeqpgles3TestSuite0020", + "src/deqpgles3/build0021:ActsDeqpgles3TestSuite0021", + "src/deqpgles3/build0022:ActsDeqpgles3TestSuite0022", + "src/deqpgles3/build0023:ActsDeqpgles3TestSuite0023", + "src/deqpgles3/build0024:ActsDeqpgles3TestSuite0024", + "src/deqpgles3/build0025:ActsDeqpgles3TestSuite0025", + "src/deqpgles3/build0026:ActsDeqpgles3TestSuite0026", + "src/deqpgles3/build0027:ActsDeqpgles3TestSuite0027", + "src/deqpgles3/build0028:ActsDeqpgles3TestSuite0028", + "src/deqpgles3/build0029:ActsDeqpgles3TestSuite0029", + "src/deqpgles3/build0030:ActsDeqpgles3TestSuite0030", + "src/deqpgles3/build0031:ActsDeqpgles3TestSuite0031", + "src/deqpgles3/build0032:ActsDeqpgles3TestSuite0032", + "src/deqpgles3/build0033:ActsDeqpgles3TestSuite0033", + "src/deqpgles3/build0034:ActsDeqpgles3TestSuite0034", + "src/deqpgles3/build0035:ActsDeqpgles3TestSuite0035", + "src/deqpgles3/build0036:ActsDeqpgles3TestSuite0036", + "src/deqpgles3/build0037:ActsDeqpgles3TestSuite0037", + "src/deqpgles3/build0038:ActsDeqpgles3TestSuite0038", + "src/deqpgles3/build0039:ActsDeqpgles3TestSuite0039", + "src/deqpgles3/build0040:ActsDeqpgles3TestSuite0040", + "src/deqpgles3/build0041:ActsDeqpgles3TestSuite0041", + "src/deqpgles3/build0042:ActsDeqpgles3TestSuite0042", + "src/deqpgles3/build0043:ActsDeqpgles3TestSuite0043", + "src/deqpgles3/build0044:ActsDeqpgles3TestSuite0044", + "src/deqpgles3/build0045:ActsDeqpgles3TestSuite0045", + "src/deqpgles31/build0001:ActsDeqpgles31TestSuite0001", + "src/deqpgles31/build0002:ActsDeqpgles31TestSuite0002", + "src/deqpgles31/build0003:ActsDeqpgles31TestSuite0003", + "src/deqpgles31/build0004:ActsDeqpgles31TestSuite0004", + "src/deqpgles31/build0005:ActsDeqpgles31TestSuite0005", + "src/deqpgles31/build0006:ActsDeqpgles31TestSuite0006", + "src/deqpgles31/build0007:ActsDeqpgles31TestSuite0007", + "src/deqpgles31/build0008:ActsDeqpgles31TestSuite0008", + "src/deqpgles31/build0009:ActsDeqpgles31TestSuite0009", + "src/deqpgles31/build0010:ActsDeqpgles31TestSuite0010", + "src/deqpgles31/build0011:ActsDeqpgles31TestSuite0011", + "src/deqpgles31/build0012:ActsDeqpgles31TestSuite0012", + "src/deqpgles31/build0013:ActsDeqpgles31TestSuite0013", + "src/deqpgles31/build0014:ActsDeqpgles31TestSuite0014", + "src/deqpgles31/build0015:ActsDeqpgles31TestSuite0015", + "src/deqpgles31/build0016:ActsDeqpgles31TestSuite0016", + "src/deqpgles31/build0017:ActsDeqpgles31TestSuite0017", + "src/deqpgles31/build0018:ActsDeqpgles31TestSuite0018", + "src/deqpgles31/build0019:ActsDeqpgles31TestSuite0019", + "src/deqpgles31/build0020:ActsDeqpgles31TestSuite0020", + "src/deqpgles31/build0021:ActsDeqpgles31TestSuite0021", + "src/deqpgles31/build0022:ActsDeqpgles31TestSuite0022", + "src/deqpgles31/build0023:ActsDeqpgles31TestSuite0023", + "src/deqpgles31/build0024:ActsDeqpgles31TestSuite0024", + "src/deqpgles31/build0025:ActsDeqpgles31TestSuite0025", + "src/deqpgles31/build0026:ActsDeqpgles31TestSuite0026", + "src/deqpgles31/build0027:ActsDeqpgles31TestSuite0027", + "src/deqpgles31/build0028:ActsDeqpgles31TestSuite0028", + "src/deqpgles31/build0029:ActsDeqpgles31TestSuite0029", + "src/deqpgles31/build0030:ActsDeqpgles31TestSuite0030", + "src/deqpgles31/build0031:ActsDeqpgles31TestSuite0031", + "src/deqpgles31/build0032:ActsDeqpgles31TestSuite0032", + "src/deqpgles31/build0033:ActsDeqpgles31TestSuite0033", + "src/deqpgles31/build0034:ActsDeqpgles31TestSuite0034", + "src/deqpgles31/build0035:ActsDeqpgles31TestSuite0035", + "src/deqpgles31/build0036:ActsDeqpgles31TestSuite0036", + "src/deqpgles31/build0037:ActsDeqpgles31TestSuite0037", + "src/deqpgles31/build0038:ActsDeqpgles31TestSuite0038", + "src/khrgles2/build0001:ActsKhrgles2TestSuite0001", + "src/khrgles3/build0001:ActsKhrgles3TestSuite0001", + "src/khrgles3/build0002:ActsKhrgles3TestSuite0002", + "src/khrgles3/build0003:ActsKhrgles3TestSuite0003", + "src/khrgles3/build0004:ActsKhrgles3TestSuite0004", + "src/khrgles3/build0005:ActsKhrgles3TestSuite0005", + "src/khrgles31/build0001:ActsKhrgles31TestSuite0001", + "src/khrgles31/build0002:ActsKhrgles31TestSuite0002", + "src/khrgles31/build0003:ActsKhrgles31TestSuite0003", + "src/khrgles31/build0004:ActsKhrgles31TestSuite0004", + "src/khrgles32/build0001:ActsKhrgles32TestSuite0001", + "src/khrgles32/build0002:ActsKhrgles32TestSuite0002", + "src/khrgles32single/build0001:ActsKhrgles32singleTestSuite0001", + "src/khrgles32single/build0002:ActsKhrgles32singleTestSuite0002", + "src/khrgles32single/build0003:ActsKhrgles32singleTestSuite0003", + "src/khrgles32single/build0004:ActsKhrgles32singleTestSuite0004", + "src/khrgles32single/build0005:ActsKhrgles32singleTestSuite0005", + "src/khrgles32single/build0006:ActsKhrgles32singleTestSuite0006", + "src/khrgles32single/build0007:ActsKhrgles32singleTestSuite0007", + "src/khrglesext/build0001:ActsKhrglesextTestSuite0001", + ] +} diff --git a/graphic/vkgl/comm.gni b/graphic/vkgl/comm.gni new file mode 100644 index 0000000000000000000000000000000000000000..8eefc6e19480f21c4eacc6cd53be7f7d884d2cdf --- /dev/null +++ b/graphic/vkgl/comm.gni @@ -0,0 +1,116 @@ +# Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. +# 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. + +import("//test/xts/tools/build/suite.gni") + +common_include = [ + "//test/xts/acts/graphic/vkglcts/src", + "//foundation/graphic/standard/rosen/modules/2d_graphics/include", + "//foundation/graphic/standard/rosen/modules/2d_graphics/src", + "//foundation/graphic/standard/rosen/modules/render_service_base/src", + "//foundation/graphic/standard/rosen/modules/render_service_base/include", + "//foundation/graphic/standard/rosen/modules/render_service_client", + "//foundation/graphic/standard/interfaces/innerkits/vsync_module", + "//foundation/graphic/standard/rosen/include/common", + "//foundation/windowmanager/interfaces/innerkits/wm", + "//third_party/VK-GL-CTS", + "//third_party/VK-GL-CTS/framework/delibs/debase", + "//third_party/VK-GL-CTS/framework/delibs/decpp", + "//third_party/VK-GL-CTS/framework/delibs/depool", + "//third_party/VK-GL-CTS/framework/delibs/dethread", + "//third_party/VK-GL-CTS/framework/delibs/deutil", + "//third_party/VK-GL-CTS/framework/delibs/destream", + "//third_party/VK-GL-CTS/framework/common", + "//third_party/VK-GL-CTS/framework/qphelper", + "//third_party/VK-GL-CTS/framework/xexml", + "//third_party/VK-GL-CTS/framework/egl", + "//third_party/VK-GL-CTS/framework/egl/wrapper", + "//third_party/VK-GL-CTS/framework/opengl", + "//third_party/VK-GL-CTS/framework/opengl/wrapper", + "//third_party/VK-GL-CTS/framework/opengl/simplereference", + "//third_party/VK-GL-CTS/framework/platform/ohos", + "//third_party/VK-GL-CTS/external/libpng/src", + "//third_party/VK-GL-CTS/external/openglcts/modules", + "//third_party/VK-GL-CTS/external/openglcts/modules/common", + "//third_party/VK-GL-CTS/external/openglcts/modules/gl", + "//third_party/VK-GL-CTS/external/openglcts/modules/gles2", + "//third_party/VK-GL-CTS/external/openglcts/modules/gles3", + "//third_party/VK-GL-CTS/external/openglcts/modules/gles31", + "//third_party/VK-GL-CTS/external/openglcts/modules/gles32", + "//third_party/VK-GL-CTS/external/openglcts/modules/glesext", + "//third_party/VK-GL-CTS/external/openglcts/modules/runner", + "//third_party/VK-GL-CTS/framework/referencerenderer", + "//third_party/VK-GL-CTS/modules/glshared", + "//third_party/VK-GL-CTS/framework/platform/ohos/rosen_context", +] + +common_depends = [ + "//foundation/graphic/standard:libvsync_client", + "//foundation/graphic/standard/rosen/modules/2d_graphics:2d_graphics", + "//foundation/graphic/standard/rosen/modules/render_service_base:librender_service_base", + "//foundation/graphic/standard/rosen/modules/render_service_client:librender_service_client", + "//foundation/graphic/standard/rosen/samples/2d_graphics:drawing_sample_rs", + "//foundation/windowmanager/wm:libwm", + "//third_party/zlib:libz", + "//third_party/VK-GL-CTS/framework/common:libdeqp_tcutil", + "//third_party/VK-GL-CTS/framework/delibs/decpp:libdeqp_decpp", + "//third_party/VK-GL-CTS/framework/delibs/debase:libdeqp_debase", + "//third_party/VK-GL-CTS/framework/delibs/deutil:libdeqp_deutil", + "//third_party/VK-GL-CTS/framework/qphelper:libdeqp_qphelper", + "//third_party/VK-GL-CTS/framework/delibs/dethread:libdeqp_dethread", + "//third_party/VK-GL-CTS/framework/xexml:libdeqp_xexml", + "//third_party/VK-GL-CTS/framework/egl:libdeqp_eglutil", + "//third_party/VK-GL-CTS/framework/egl/wrapper:libdeqp_eglwrapper", + "//third_party/VK-GL-CTS/framework/opengl:libdeqp_glutil", + "//third_party/VK-GL-CTS/framework/opengl/wrapper:libdeqp_glwrapper", + "//third_party/VK-GL-CTS/framework/opengl/simplereference:libdeqp_glutil-sglr", + "//third_party/VK-GL-CTS/modules/egl:libdeqp-egl", + "//third_party/VK-GL-CTS/modules/gles2:libdeqp-gles2", + "//third_party/VK-GL-CTS/modules/gles3:libdeqp-gles3", + "//third_party/VK-GL-CTS/modules/gles31:libdeqp-gles31", + "//third_party/VK-GL-CTS/modules/glshared:libdeqp-gl-shared", + "//third_party/VK-GL-CTS/external/openglcts/modules:libdeqp_glcts", + + "//base/hiviewdfx/hilog/interfaces/native/innerkits:libhilog", + "//foundation/graphic/standard:libvsync_client", + "//foundation/graphic/standard:libwmclient", + "//foundation/graphic/standard/rosen/modules/2d_graphics:2d_graphics", + "//foundation/graphic/standard/rosen/modules/render_service_base:librender_service_base", + "//foundation/graphic/standard/rosen/modules/render_service_client:librender_service_client", + "//third_party/zlib:libz", + + "//foundation/windowmanager/dm:libdm", + "//foundation/windowmanager/dmserver:libdms", + "//foundation/windowmanager/wm:libwm", + "//foundation/windowmanager/wmserver:libwms", + "//third_party/VK-GL-CTS/framework/platform/ohos/rosen_context:rosen_context", +] + +common_src = [ + "//third_party/VK-GL-CTS/framework/platform/ohos/context/tcuOhosNativeContext.cpp", + "//third_party/VK-GL-CTS/framework/platform/ohos/context/tcuOhosEglContextFactory.cpp", + + "//third_party/VK-GL-CTS/framework/platform/ohos/display/tcuOhosNativeDisplay.cpp", + "//third_party/VK-GL-CTS/framework/platform/ohos/display/tcuOhosEglDisplayFactory.cpp", + + "//third_party/VK-GL-CTS/framework/platform/ohos/display/window/tcuOhosNativeWindow.cpp", + "//third_party/VK-GL-CTS/framework/platform/ohos/display/window/tcuOhosWindowFactory.cpp", + "//third_party/VK-GL-CTS/framework/platform/ohos/display/pixmap/tcuOhosNativePixmap.cpp", + "//third_party/VK-GL-CTS/framework/platform/ohos/display/pixmap/tcuOhosPixmapFactory.cpp", + + "//third_party/VK-GL-CTS/framework/platform/ohos/tcuOhosPlatform.cpp", + "logdefine.cpp", + "../../ActsApp.cpp", +] + +import("//third_party/VK-GL-CTS/vk_gl_cts.gni") diff --git a/graphic/vkgl/src/ActsApp.cpp b/graphic/vkgl/src/ActsApp.cpp new file mode 100755 index 0000000000000000000000000000000000000000..5b57823e0852c3b8abf5d2b055e3c9df21ee8103 --- /dev/null +++ b/graphic/vkgl/src/ActsApp.cpp @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#include "ActsApp.h" +#include "tcuPlatform.hpp" +#include "tcuTestContext.hpp" +#include "tcuTestSessionExecutor.hpp" +#include "tcuTestHierarchyUtil.hpp" +#include "tcuCommandLine.hpp" +#include "tcuTestLog.hpp" + +#include "qpInfo.h" +#include "qpDebugOut.h" +#include "deMath.h" + +namespace tcu { + using std::string; + /*--------------------------------------------------------------------****! + * Writes all packages found stdout without any + * separations. Recommended to be used with a single package + * only. It's possible to use test selectors for limiting the export + * to one package in a multipackage binary. + *--------------------------------------------------------------------*/ + static void writeCaselistsToStdout (TestPackageRoot& root, TestContext& testCtx) + { + DefaultHierarchyInflater inflater(testCtx); + de::MovePtr caseListFilter( + testCtx.getCommandLine().createCaseListFilter(testCtx.getArchive())); + TestHierarchyIterator iter(root, inflater, *caseListFilter); + + while (iter.getState() != TestHierarchyIterator::STATE_FINISHED) { + iter.next(); + tcu::TestNode* testNode = iter.getNode(); + while (testNode->getNodeType() != NODETYPE_PACKAGE) { + if (iter.getState() == TestHierarchyIterator::STATE_ENTER_NODE) + std::cout << (isTestNodeTypeExecutable(testNode->getNodeType()) ? "TEST" : "GROUP") + << ": " << iter.getNodePath() << "\n"; + iter.next(); + } + + DE_ASSERT(iter.getState() == TestHierarchyIterator::STATE_LEAVE_NODE && + testNode->getNodeType() == NODETYPE_PACKAGE); + iter.next(); + }; + } + + + /*--------------------------------------------------------------------****! + * Verifies that amber capability requirements in the .amber files + * match with capabilities defined on the CTS C code. + ****--------------------------------------------------------------------*/ + static void verifyAmberCapabilityCoherency (TestPackageRoot& root, TestContext& testCtx) + { + DefaultHierarchyInflater inflater(testCtx); + de::MovePtr caseListFilter( + testCtx.getCommandLine().createCaseListFilter(testCtx.getArchive())); + TestHierarchyIterator iter(root, inflater, *caseListFilter); + int count = 0; + int errorCount = 0; + + bool ok = true; + + while (iter.getState() != TestHierarchyIterator::STATE_FINISHED) { + iter.next(); + tcu::TestNode* testNode = iter.getNode(); + while (testNode->getNodeType() != NODETYPE_PACKAGE) { + if (iter.getState() == TestHierarchyIterator::STATE_ENTER_NODE && + isTestNodeTypeExecutable(testNode->getNodeType())) { + std::cout << iter.getNodePath() << "\n"; + testCtx.getLog() << tcu::TestLog::Message << iter.getNodePath() << tcu::TestLog::EndMessage; + count++; + }; + iter.next(); + }; + + DE_ASSERT(iter.getState() == TestHierarchyIterator::STATE_LEAVE_NODE && + testNode->getNodeType() == NODETYPE_PACKAGE); + iter.next(); + }; + std::cout << count << " amber tests, " << errorCount << " errors.\n"; + if (!ok) { + TCU_THROW(InternalError, "One or more CTS&Amber test requirements do not match; check log for details"); + }; + } + + /*--------------------------------------------------------------------****! + * \brief Construct test application + * + * If a fatal error occurs during initialization constructor will call + * die() with debug information. + * + * \param platform Reference to platform implementation. + *--------------------------------------------------------------------*/ + ActsApp::ActsApp (Platform& platform, Archive& archive, TestLog& log, const CommandLine& cmdLine) + : m_platform(platform), + m_watchDog(DE_NULL), + m_crashHandler(DE_NULL), + m_crashed(false), + m_testCtx(DE_NULL), + m_testRoot(DE_NULL), + m_testExecutor(DE_NULL) + { + print("dEQP Core %s (0x%08x) starting..\n", qpGetReleaseName(), qpGetReleaseId()); + print(" target implementation = '%s'\n", qpGetTargetName()); + + if (!deSetRoundingMode(DE_ROUNDINGMODE_TO_NEAREST_EVEN)) { + qpPrintf("WARNING: Failed to set floating-point rounding mode!\n"); + }; + + try { + const RunMode runMode = cmdLine.getRunMode(); + + // Initialize watchdog + if (cmdLine.isWatchDogEnabled()) { + TCU_CHECK_INTERNAL(m_watchDog = qpWatchDog_create(onWatchdogTimeout, this, + WATCHDOG_TOTAL_TIME_LIMIT_SECS, WATCHDOG_INTERVAL_TIME_LIMIT_SECS)); + }; + + // Initialize crash handler. + if (cmdLine.isCrashHandlingEnabled()) { + TCU_CHECK_INTERNAL(m_crashHandler = qpCrashHandler_create(onCrash, this)); + }; + + // Create test context + m_testCtx = new TestContext(m_platform, archive, log, cmdLine, m_watchDog); + + // Create root from registry + m_testRoot = new TestPackageRoot(*m_testCtx, TestPackageRegistry::getSingleton()); + + // \note No executor is created if runmode is not EXECUTE + if (runMode == RUNMODE_EXECUTE) { + m_testExecutor = new TestSessionExecutor(*m_testRoot, *m_testCtx); + } else if (runMode == RUNMODE_DUMP_STDOUT_CASELIST) { + writeCaselistsToStdout(*m_testRoot, *m_testCtx); + } else if (runMode == RUNMODE_DUMP_XML_CASELIST) { + writeXmlCaselistsToFiles(*m_testRoot, *m_testCtx, cmdLine); + } else if (runMode == RUNMODE_DUMP_TEXT_CASELIST) { + writeTxtCaselistsToFiles(*m_testRoot, *m_testCtx, cmdLine); + } else if (runMode == RUNMODE_VERIFY_AMBER_COHERENCY) { + verifyAmberCapabilityCoherency(*m_testRoot, *m_testCtx); + } else { + DE_ASSERT(false); + }; + } catch (const std::exception& e) { + cleanup(); + die("Failed to initialize dEQP: %s", e.what()); + }; + } + + ActsApp::~ActsApp (void) + { + cleanup(); + } + + void ActsApp::cleanup (void) + { + delete m_testExecutor; + delete m_testRoot; + delete m_testCtx; + + m_testExecutor = DE_NULL + m_testRoot = DE_NULL + m_testCtx = DE_NULL + + if (m_crashHandler) { + qpCrashHandler_destroy(m_crashHandler); + }; + + if (m_watchDog) { + qpWatchDog_destroy(m_watchDog); + }; + } + + /*--------------------------------------------------------------------****! + * \brief Step forward test execution + * \return true if application should call iterate() again and false + * if test execution session is complete. + ****--------------------------------------------------------------------*/ + bool ActsApp::iterate (void) + { + if (!m_testExecutor) { + DE_ASSERT(m_testCtx->getCommandLine().getRunMode() != RUNMODE_EXECUTE); + return false; + }; + + // Poll platform events + const bool platformOk = m_platform.processEvents(); + + // Iterate a step. + bool testExecOk = false; + if (platformOk) { + try { + testExecOk = m_testExecutor->iterate(); + } catch (const std::exception& e) { + die("%s", e.what()); + }; + }; + + return platformOk && testExecOk; + } + + const TestRunStatus& ActsApp::getResult (void) const + { + return m_testExecutor->getStatus(); + } +} // tcu \ No newline at end of file diff --git a/graphic/vkgl/src/ActsApp.h b/graphic/vkgl/src/ActsApp.h new file mode 100755 index 0000000000000000000000000000000000000000..debedf591c760fe5e4ccec4b67b2317970fd35b7 --- /dev/null +++ b/graphic/vkgl/src/ActsApp.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#ifndef _ActsApp_HPP +#define _ActsApp_HPP + +#include "tcuDefs.hpp" +#include "qpWatchDog.h" +#include "qpCrashHandler.h" +#include "deMutex.hpp" +#include "tcuResource.hpp" +#include "tcuPlatform.hpp" +#include "tcuTestContext.hpp" +#include "tcuTestSessionExecutor.hpp" +#include "tcuTestSessionExecutor.hpp" +#include "tcuCommandLine.hpp" +#include "tcuTestLog.hpp" +#include "tcuTestPackageRoot.hpp" +#include "tcuTestSessionExecutor.hpp" + +namespace tcu { + enum class EWATCHDOG { + WATCHDOG_TOTAL_TIME_LIMIT_SECS = 300, + WATCHDOG_INTERVAL_TIME_LIMIT_SECS = 30 + }; + + class ActsApp { + public: + ActsApp(Platform& platform, Archive& archive, TestLog& log, const CommandLine& cmdLine); + virtual ~ActsApp(void); + + bool iterate(void); + const TestRunStatus& getResult (void) const; + protected: + void cleanup (void); + + Platform& m_platform; + qpWatchDog* m_watchDog; + qpCrashHandler* m_crashHandler; + de::Mutex m_crashLock; + bool m_crashed; + + TestContext* m_testCtx; + TestPackageRoot* m_testRoot; + TestSessionExecutor* m_testExecutor; + }; +} // tcu + +#endif // _ActsApp_HPP \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.cpp b/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.cpp new file mode 100644 index 0000000000000000000000000000000000000000..adc7cf04e4872e2a62fc94863b76be85d7bd10ef --- /dev/null +++ b/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.cpp @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#include +#include +#include +#include "Khrgles2BaseFunc.h" +#include "ActsKhrgles20001TestSuite.h" + +namespace OHOS { + using namespace std; + using namespace testing::ext; + + time_t ActsKhrgles20001TestSuite::starttime; + time_t ActsKhrgles20001TestSuite::endtime; + FuncRunResult ActsKhrgles20001TestSuite::runResult; + + // Preset action of the test suite, which is executed before the first test case + void ActsKhrgles20001TestSuite::SetUpTestCase(void) + { + time(&starttime); + RegistPackage(); + runResult.numPassed = 0; + runResult.numFailed = 0; + runResult.numNotSupported = 0; + runResult.numWarnings = 0; + runResult.numWaived = 0; + } + // Test suite cleanup action, which is executed after the last test case + void ActsKhrgles20001TestSuite::TearDownTestCase(void) + { + time(&endtime); + printf("Test run totals --- Passed[%d]\n", runResult.numPassed); + printf("Test run totals --- Failed[%d]\n", runResult.numFailed); + printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported); + printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings); + printf("Test run totals --- Waved[%d]\n", runResult.numWaived); + printf("testmain end --- COST TIME[%lld]\n", (endtime-starttime)); + } + // Preset action of the test case + void ActsKhrgles20001TestSuite::SetUp() + { + } + // Cleanup action of the test case + void ActsKhrgles20001TestSuite::TearDown() + { + } +} + \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.h b/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.h new file mode 100644 index 0000000000000000000000000000000000000000..27f11f5ba909c806dcda1ff8c212ffc4f5afebdc --- /dev/null +++ b/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#ifndef KHRGLES2_TESTCASE_H +#define KHRGLES2_TESTCASE_H + + +#include +#include "Khrgles2BaseFunc.hpp" + +namespace OHOS { + class ActsKhrgles20001TestSuite : public testing::Test { + public: + static time_t starttime; + static time_t endtime; + static FuncRunResult runResult; + protected: + // Preset action of the test suite, which is executed before the first test case + static void SetUpTestCase(void); + // Test suite cleanup action, which is executed after the last test case + static void TearDownTestCase(void); + // Preset action of the test case + virtual void SetUp(); + // Cleanup action of the test case + virtual void TearDown(); + }; +} // namespace OHOS + +#endif // KHRGLES2_TESTCASE_H + \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.cpp b/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.cpp new file mode 100644 index 0000000000000000000000000000000000000000..17e6a22dedde61b3e1dd2d6ce86c4bddfe375414 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.cpp @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#include +#include +#include +#include "Khrgles2BaseFunc.h" +#include "ActsKhrgles2TestSuite.h" + + +namespace OHOS { + using namespace std; + using namespace testing::ext; + + time_t ActsKhrgles2TestSuite::starttime; + time_t ActsKhrgles2TestSuite::endtime; + FuncRunResult ActsKhrgles2TestSuite::runResult; + + // Preset action of the test suite, which is executed before the first test case + void ActsKhrgles2TestSuite::SetUpTestCase(void) + { + time(&starttime); + RegistPackage(); + runResult.numPassed = 0; + runResult.numFailed = 0; + runResult.numNotSupported = 0; + runResult.numWarnings = 0; + runResult.numWaived = 0; + } + // Test suite cleanup action, which is executed after the last test case + void ActsKhrgles2TestSuite::TearDownTestCase(void) + { + time(&endtime); + printf("Test run totals --- Passed[%d]\n", runResult.numPassed); + printf("Test run totals --- Failed[%d]\n", runResult.numFailed); + printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported); + printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings); + printf("Test run totals --- Waved[%d]\n", runResult.numWaived); + printf("testmain end --- COST TIME[%lld]\n", (endtime-starttime)); + } + // Preset action of the test case + void ActsKhrgles2TestSuite::SetUp() + { + } + // Cleanup action of the test case + void ActsKhrgles2TestSuite::TearDown() + { + } +} + \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.h b/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.h new file mode 100644 index 0000000000000000000000000000000000000000..c74f52877ba847e27020ae9bd5d9228ff94982cc --- /dev/null +++ b/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#ifndef KHRGLES2_TESTCASE_H +#define KHRGLES2_TESTCASE_H + + +#include +#include "Khrgles2BaseFunc.hpp" + +namespace OHOS { + class ActsKhrgles2TestSuite : public testing::Test { + public: + static time_t starttime; + static time_t endtime; + static FuncRunResult runResult; + protected: + // Preset action of the test suite, which is executed before the first test case + static void SetUpTestCase(void); + // Test suite cleanup action, which is executed after the last test case + static void TearDownTestCase(void); + // Preset action of the test case + virtual void SetUp(); + // Cleanup action of the test case + virtual void TearDown(); + }; +} // namespace OHOS + +#endif // KHRGLES2_TESTCASE_H + \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.cpp b/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ec1f50792ed13bdae52d2cc19b21b89f098bea5f --- /dev/null +++ b/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.cpp @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#include + +#include "tcuDefs.hpp" +#include "tcuCommandLine.hpp" +#include "tcuPlatform.hpp" +#include "ActsApp.hpp" +#include "tcuResource.hpp" +#include "tcuTestLog.hpp" +#include "tcuTestSessionExecutor.hpp" +#include "deUniquePtr.hpp" + +#include "external/openglcts/modules/common/glcConfigPackage.hpp" +#include "external/openglcts/modules/common/glcTestPackage.hpp" +#include "external/openglcts/modules/gles2/es2cTestPackage.hpp" +#include "external/openglcts/modules/gles32/es32cTestPackage.hpp" +#include "external/openglcts/modules/gles31/es31cTestPackage.hpp" +#include "external/openglcts/modules/gles3/es3cTestPackage.hpp" +#include "external/openglcts/modules/glesext/esextcTestPackage.hpp" +#include "external/openglcts/modules/common/glcSingleConfigTestPackage.hpp" +#include "modules/gles2/tes2TestPackage.hpp" +#include "modules/gles3/tes3TestPackage.hpp" +#include "modules/gles31/tes31TestPackage.hpp" + + +#include "ohos_context_i.h" +#include "Khrgles2BaseFunc.h" + +static tcu::TestPackage* createKhrgles2Package(tcu::TestContext& testCtx) +{ + return new es2cts::TestPackage(testCtx, "KHR-KHRGLES2"); +} + +void RegistPackage(void) +{ + tcu::TestPackageRegistry *registry = tcu::TestPackageRegistry::getSingleton(); + registry->registerPackage("KHR-GLES2", createKhrgles2Package); +} + +FuncRunResult RunTestKHRGLES(int argc, const char** argv) +{ + FuncRunResult runResult; + tcu::CommandLine cmdLine(argc, argv); + tcu::DirArchive archive(cmdLine.getArchiveDir()); + + de::UniquePtr platform(createOhosPlatform()); + de::UniquePtr app(new tcu::ActsApp(*platform, archive, tcutestlog, cmdLine)); + for (;;) { + if (!app->iterate()) { + break; + }; + }; + TestRunStatus result = app->getResult(); + runResult.isComplete = app->getResult().isComplete; + runResult.numPassed = app->getResult().numPassed; + runResult.numExecuted = app->getResult().numExecuted; + runResult.numFailed = app->getResult().numFailed; + runResult.numNotSupported = app->getResult().numNotSupported; + runResult.numWarnings = app->getResult().numWarnings; + runResult.numWaived = app->getResult().numWaived; + + return runResult; +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.h b/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.h new file mode 100644 index 0000000000000000000000000000000000000000..b8e363f5ce34c997b2579f9092089d415548c1a3 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#ifndef KHRGLES2_FUNC_H +#define KHRGLES2_FUNC_H + +struct FuncRunResult { + int numExecuted; // !< Total number of cases executed. + int numPassed; // !< Number of cases passed. + int numFailed; // !< Number of cases failed. + int numNotSupported; // !< Number of cases not supported. + int numWarnings; // !< Number of QualityWarning / CompatibilityWarning results. + int numWaived; // !< Number of waived tests. + bool isComplete; // !< Is run complete. +}; + +void RegistPackage(void); + +FuncRunResult RunTestKHRGLES(int argc, const char** argv); + +#endif \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/build0001/BUILD.gn b/graphic/vkgl/src/khrgles2/build0001/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..3aa412ba8d21fe63372c1087c593b2b18058089e --- /dev/null +++ b/graphic/vkgl/src/khrgles2/build0001/BUILD.gn @@ -0,0 +1,70 @@ +# Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. +# 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. + +import("//test/xts/acts/graphic/vkglcts/comm.gni") + +config("deqp_platform_ohos_config") { + cflags_cc = deqp_common_cflags_cc + + cflags_cc += [ + # "-Wno-conversion", + # "-Wno-unused-function", + "-Wno-unused-parameter", + ] + + defines = deqp_common_defines + + # defines -=["DE_PTR_SIZE=8"] + defines += [ + "DE_PTR_SIZE=4", + "_XOPEN_SOURCE=600", + ] +} + +ohos_static_library("libkhrgles2func0001") { + sources = common_src + sources += [ "../Khrgles2BaseFunc.cpp" ] + + include_dirs = common_include + deps = common_depends + external_deps = [ + "hilog_native:libhilog", + "multimedia_image_standard:image_native", + ] + lib_dirs = [ "//third_party/VK-GL-CTS/outlibs" ] + libs = [ "png" ] + configs = [ ":deqp_platform_ohos_config" ] + public_deps = [ "//foundation/ace/ace_engine/build/external_config/flutter/skia:ace_skia_ohos" ] +} + +ohos_moduletest_suite("ActsKhrgles2TestSuite0001") { + sources = [ + "../ActsKhrgles20001TestSuite.cpp", + "../core/Khrgles2internalformat_copy_tex_imageTestCase.cpp", + "../core/Khrgles2internalformat_renderbufferTestCase.cpp", + "../core/Khrgles2internalformat_texture2dTestCase.cpp", + "../shaders/Khrgles2shaders_aggressive_optimizationsTestCase.cpp", + "../shaders/Khrgles2shaders_negativeTestCase.cpp", + "../texture_3d/Khrgles2filtering_combinationsTestCase.cpp", + "../texture_3d/Khrgles2filtering_formatsTestCase.cpp", + "../texture_3d/Khrgles2filtering_sizesTestCase.cpp", + "../texture_3d/Khrgles2texture_3d_compressed_textureTestCase.cpp", + "../texture_3d/Khrgles2texture_3d_copy_sub_imageTestCase.cpp", + "../texture_3d/Khrgles2texture_3d_framebuffer_textureTestCase.cpp", + "../texture_3d/Khrgles2texture_3d_sub_imageTestCase.cpp", + ] + + include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ] + deps = [ ":libkhrgles2func0001" ] + cflags = [ "-Wno-error" ] +} diff --git a/graphic/vkgl/src/khrgles2/build0001/Test.json b/graphic/vkgl/src/khrgles2/build0001/Test.json new file mode 100644 index 0000000000000000000000000000000000000000..5925b83d1d5004c67728496326dc04b274c6d782 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/build0001/Test.json @@ -0,0 +1,38 @@ +{ + "description": "Config for ActsKhrgles2TestSuite0001 test cases", + "driver": { + "module-name": "ActsKhrgles2TestSuite0001", + "native-test-timeout": "120000", + "native-test-device-path": "/data/local/tmp", + "runtime-hint": "100s", + "type": "CppTest" + }, + "kits": [ + { + "pre-push" : [ + ], + "post-push" : [ + "chmod -R 777 /data/local/tmp/*", + "mkdir /data/local/tmp/gl_cts", + "tar zxvf /data/local/tmp/gl_cts.tar.gz -C /data/local/tmp/gl_cts", + "cp -r /data/local/tmp/gl_cts/data/gles2 /data/local/tmp", + "cp -r /data/local/tmp/gl_cts/data/gles3 /data/local/tmp", + "cp -r /data/local/tmp/gl_cts/data/gles31 /data/local/tmp" + ], + "push": [ + "ActsKhrgles2TestSuite0001->/data/local/tmp/ActsKhrgles2TestSuite0001", + "../../../common/common/librosen_context.z.so->/system/lib", + "gl_cts.tar.gz->/data/local/tmp/gl_cts.tar.gz" + ], + "type": "PushKit" + }, + { + "type": "ShellKit", + "run-command": [ + "remount", + "mkdir /data/test", + "cd /data/local/tmp" + ] + } + ] +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/build0001/logdefine.cpp b/graphic/vkgl/src/khrgles2/build0001/logdefine.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ec885b3f6be7a257450ce40c60c099e462d0ec4a --- /dev/null +++ b/graphic/vkgl/src/khrgles2/build0001/logdefine.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#include + +#include "tcuDefs.hpp" +#include "tcuCommandLine.hpp" +#include "tcuPlatform.hpp" +#include "ActsApp.hpp" +#include "tcuResource.hpp" +#include "tcuTestLog.hpp" +#include "tcuTestSessionExecutor.hpp" +#include "deUniquePtr.hpp" + +static tcu::TestLog tcutestlog("/data/local/tmp/ActsKhrgles2TestSuite0001.qpa", 0); \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_copy_tex_imageTestCase.cpp b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_copy_tex_imageTestCase.cpp new file mode 100644 index 0000000000000000000000000000000000000000..dd4b52e611ec2d6c1fc20740e4a34f0e85d1ec44 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_copy_tex_imageTestCase.cpp @@ -0,0 +1,387 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#include +#include +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000449, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.rgb", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000450, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgba start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.rgba", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgba Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgba end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000451, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.alpha start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.alpha", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.alpha Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.alpha end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000452, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.luminance", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000453, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance_alpha start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.luminance_alpha", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance_alpha Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance_alpha end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000454, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb5_a1 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.rgb5_a1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb5_a1 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb5_a1 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000455, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb565 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.rgb565", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb565 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb565 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000456, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgba4 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.rgba4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgba4 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgba4 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000457, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance4_alpha4_oes start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.luminance4_alpha4_oes", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance4_alpha4_oes Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance4_alpha4_oes end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000458, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance8_alpha8_oes start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.luminance8_alpha8_oes", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance8_alpha8_oes Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance8_alpha8_oes end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000459, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance8_oes start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.luminance8_oes", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance8_oes Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.luminance8_oes end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000460, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.alpha8_oes start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.alpha8_oes", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.alpha8_oes Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.alpha8_oes end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000461, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb10_a2 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.rgb10_a2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb10_a2 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb10_a2 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000462, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb10 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.copy_tex_image.rgb10", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb10 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.copy_tex_image.rgb10 end"; +} diff --git a/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_texture2dTestCase.cpp b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_texture2dTestCase.cpp new file mode 100644 index 0000000000000000000000000000000000000000..50fbc89d4068fc2a7c676de6fd2fb3e6f487c1af --- /dev/null +++ b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_texture2dTestCase.cpp @@ -0,0 +1,1017 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * 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. + */ + +#include +#include +#include "../Khrgles2BaseFunc.hpp" +#include "../ActsKhrgles20001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000412, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgba start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgba", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgba Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgba end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000413, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_byte_rgb start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_byte_rgb", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_byte_rgb Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_byte_rgb end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000414, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_4_4_4_4_rgba start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_4_4_4_4_rgba", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_4_4_4_4_rgba Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_4_4_4_4_rgba end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000415, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance_alpha start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance_alpha", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance_alpha Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance_alpha end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000416, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.luminance_unsigned_byte_luminance start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.luminance_unsigned_byte_luminance", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.luminance_unsigned_byte_luminance Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.luminance_unsigned_byte_luminance end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000417, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.alpha_unsigned_byte_alpha start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.alpha_unsigned_byte_alpha", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.alpha_unsigned_byte_alpha Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.alpha_unsigned_byte_alpha end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000418, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgba start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgba", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgba Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgba end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000419, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgb10_a2 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgb10_a2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgb10_a2 Unavaliable!"; + + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgb10_a2 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000420, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgb5_a1 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgb5_a1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgb5_a1 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_int_2_10_10_10_rev_rgb5_a1 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000421, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_int_2_10_10_10_rev_rgb start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_int_2_10_10_10_rev_rgb", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_int_2_10_10_10_rev_rgb Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_int_2_10_10_10_rev_rgb end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000422, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_short_depth_component start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_short_depth_component", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_short_depth_component Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_short_depth_component end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000423, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000424, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_stencil_unsigned_int_24_8_depth_stencil start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.depth_stencil_unsigned_int_24_8_depth_stencil", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_stencil_unsigned_int_24_8_depth_stencil Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_stencil_unsigned_int_24_8_depth_stencil end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000425, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_half_float_oes_rgb start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgb_half_float_oes_rgb", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_half_float_oes_rgb Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_half_float_oes_rgb end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000426, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_half_float_oes_rgba start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_half_float_oes_rgba", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_half_float_oes_rgba Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_half_float_oes_rgba end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000427, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_half_float_oes_rgb_linear start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgb_half_float_oes_rgb_linear", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_half_float_oes_rgb_linear Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_half_float_oes_rgb_linear end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000428, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_half_float_oes_rgba_linear start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_half_float_oes_rgba_linear", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_half_float_oes_rgba_linear Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_half_float_oes_rgba_linear end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000429, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_float_rgb32f start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgb_float_rgb32f", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_float_rgb32f Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_float_rgb32f end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000430, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_float_rgba32f start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_float_rgba32f", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_float_rgba32f Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_float_rgba32f end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000431, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_float_rgb32f_linear start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgb_float_rgb32f_linear", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_float_rgb32f_linear Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_float_rgb32f_linear end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000432, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_float_rgba32f_linear start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_float_rgba32f_linear", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_float_rgba32f_linear Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_float_rgba32f_linear end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000433, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgb5_a1 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgb5_a1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgb5_a1 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgb5_a1 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000434, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgba4 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgba4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgba4 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_byte_rgba4 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000435, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_byte_rgb565 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_byte_rgb565", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_byte_rgb565 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_byte_rgb565 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000436, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_4_4_4_4_rgba4 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_4_4_4_4_rgba4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_4_4_4_4_rgba4 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_4_4_4_4_rgba4 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000437, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_5_5_5_1_rgba start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_5_5_5_1_rgba", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_5_5_5_1_rgba Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_5_5_5_1_rgba end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000438, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_5_5_5_1_rgb5_a1 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_5_5_5_1_rgb5_a1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_5_5_5_1_rgb5_a1 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgba_unsigned_short_5_5_5_1_rgb5_a1 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000439, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_short_5_6_5_rgb start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_short_5_6_5_rgb", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_short_5_6_5_rgb Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_short_5_6_5_rgb end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000440, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_short_5_6_5_rgb565 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_short_5_6_5_rgb565", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_short_5_6_5_rgb565 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.rgb_unsigned_short_5_6_5_rgb565 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000441, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance8_alpha8_oes start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance8_alpha8_oes", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance8_alpha8_oes Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance8_alpha8_oes end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000442, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance4_alpha4_oes start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance4_alpha4_oes", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance4_alpha4_oes Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.luminance_alpha_unsigned_byte_luminance4_alpha4_oes end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000443, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.luminance_unsigned_byte_luminance8_oes start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.luminance_unsigned_byte_luminance8_oes", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.luminance_unsigned_byte_luminance8_oes Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.luminance_unsigned_byte_luminance8_oes end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000444, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.alpha_unsigned_byte_alpha8_oes start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.alpha_unsigned_byte_alpha8_oes", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.alpha_unsigned_byte_alpha8_oes Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.alpha_unsigned_byte_alpha8_oes end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000445, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component16 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component16", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component16 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component16 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000446, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_short_depth_component16 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_short_depth_component16", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_short_depth_component16 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + } + + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_short_depth_component16 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000447, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component24 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component24", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component24 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component24 end"; +} + +static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000448, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component32 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component32", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << + "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component32 Unavaliable!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + + GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.texture2d.depth_component_unsigned_int_depth_component32 end"; +}