!3676 增加Acts vkgl测试库

Merge pull request !3676 from wshikh/master

graphic/vkgl/BUILD.gn

+# 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",
+  ]
+}

graphic/vkgl/comm.gni

+# 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")

graphic/vkgl/src/ActsApp.cpp

+/*
+ * 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<const CaseListFilter> 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<const CaseListFilter> 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

graphic/vkgl/src/ActsApp.h

+/*
+ * 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

graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#include <ctime>
+#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

graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.h

+/*
+ * 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 <gtest/gtest.h>
+#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

graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#include <ctime>
+#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

graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.h

+/*
+ * 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 <gtest/gtest.h>
+#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

graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.cpp

+/*
+ * 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 <cstdio>
+
+#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<tcu::Platform> platform(createOhosPlatform());
+    de::UniquePtr<tcu::ActsApp> 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

graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.h

+/*
+ * 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

graphic/vkgl/src/khrgles2/build0001/BUILD.gn

+# 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" ]
+}

graphic/vkgl/src/khrgles2/build0001/Test.json

+{
+    "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

graphic/vkgl/src/khrgles2/build0001/logdefine.cpp

+/*
+ * 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 <cstdio>
+
+#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

graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_copy_tex_imageTestCase.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#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";
+}

graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_renderbufferTestCase.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.hpp"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000463, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgba8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.rgba8",
+        "--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.renderbuffer.rgba8 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgba8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000464, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.rgb8",
+        "--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.renderbuffer.rgb8 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000465, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index1_oes start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.stencil_index1_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.renderbuffer.stencil_index1_oes Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index1_oes end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000466, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index4_oes start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.stencil_index4_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.renderbuffer.stencil_index4_oes Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index4_oes end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000467, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.stencil_index8",
+        "--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.renderbuffer.stencil_index8 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000468, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component16 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.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.renderbuffer.depth_component16 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component16 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000469, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component24 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.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.renderbuffer.depth_component24 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component24 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000470, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component32 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.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.renderbuffer.depth_component32 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component32 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000471, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth24_stencil8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.depth24_stencil8",
+        "--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.renderbuffer.depth24_stencil8 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth24_stencil8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000472, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb5_a1 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.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.renderbuffer.rgb5_a1 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb5_a1 end";
+}

graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_aggressive_optimizationsTestCase.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000003, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_float_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_float_vert",
+        "--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.shaders.aggressive_optimizations.sin_float_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_float_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000004, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_float_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_float_frag",
+        "--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.shaders.aggressive_optimizations.sin_float_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_float_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000005, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_vert",
+        "--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.shaders.aggressive_optimizations.sin_vec2_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000006, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_frag",
+        "--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.shaders.aggressive_optimizations.sin_vec2_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000007, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_vert",
+        "--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.shaders.aggressive_optimizations.sin_vec3_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000008, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_frag",
+        "--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.shaders.aggressive_optimizations.sin_vec3_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000009, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_float_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_float_vert",
+        "--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.shaders.aggressive_optimizations.cos_float_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_float_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000010, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_float_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_float_frag",
+        "--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.shaders.aggressive_optimizations.cos_float_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_float_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000011, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_vert",
+        "--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.shaders.aggressive_optimizations.cos_vec2_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000012, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_frag",
+        "--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.shaders.aggressive_optimizations.cos_vec2_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000013, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_vert",
+        "--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.shaders.aggressive_optimizations.cos_vec3_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000014, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_frag",
+        "--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.shaders.aggressive_optimizations.cos_vec3_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_frag end";
+}

graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_negativeTestCase.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000001, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.negative.initialize start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.negative.initialize",
+        "--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.shaders.negative.initialize notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.negative.initialize end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000002, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.negative.constant_sequence start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.negative.constant_sequence",
+        "--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.shaders.negative.constant_sequence notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.negative.constant_sequence end";
+}

graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_formatsTestCase.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000015, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest",
+        "--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.texture_3d.filtering.formats.rgba8_nearest notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000016, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_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.texture_3d.filtering.formats.rgba8_linear notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000017, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_nearest start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_nearest",
+        "--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.texture_3d.filtering.formats.rgba8_nearest_mipmap_nearest notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_nearest end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000018, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_nearest start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_nearest",
+        "--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.texture_3d.filtering.formats.rgba8_linear_mipmap_nearest notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_nearest end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000019, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_linear start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_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.texture_3d.filtering.formats.rgba8_nearest_mipmap_linear notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_linear end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000020, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_linear start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_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.texture_3d.filtering.formats.rgba8_linear_mipmap_linear notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_linear end";
+}

graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_copy_sub_imageTestCase.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000378, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.copy_sub_image.rgba start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.copy_sub_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.texture_3d.copy_sub_image.rgba notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.copy_sub_image.rgba end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000379, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.copy_sub_image.negative start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.copy_sub_image.negative",
+        "--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.texture_3d.copy_sub_image.negative notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.copy_sub_image.negative end";
+}

graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_framebuffer_textureTestCase.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000380, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.framebuffer_texture.rgba start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.framebuffer_texture.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.texture_3d.framebuffer_texture.rgba notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.framebuffer_texture.rgba end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000381, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.framebuffer_texture.negative start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.framebuffer_texture.negative",
+        "--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.texture_3d.framebuffer_texture.negative notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.framebuffer_texture.negative end";
+}

graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_sub_imageTestCase.cpp

+/*
+ * 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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000376, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.sub_image.rgba8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.sub_image.rgba8",
+        "--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.texture_3d.sub_image.rgba8 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.sub_image.rgba8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000377, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.sub_image.negative start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.sub_image.negative",
+        "--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.texture_3d.sub_image.negative notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.sub_image.negative end";
+}