!3873 add khrgles32 testcase pr2

Merge pull request !3873 from rvaluelife/master

graphic/vkgl/src/khrgles32/ActsKhrgles320001TestSuite.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 <gtest/gtest.h>
+#include <ctime>
+#include "Khrgles32BaseFunc.h"
+#include "ActsKhrgles320001TestSuite.h"
+
+namespace OHOS {
+    using namespace std;
+    using namespace testing::ext;
+
+    time_t ActsKhrgles320001TestSuite::starttime;
+    time_t ActsKhrgles320001TestSuite::endtime;
+    FuncRunResult ActsKhrgles320001TestSuite::runResult;
+
+    // Preset action of the test suite, which is executed before the first test case
+    void ActsKhrgles320001TestSuite::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 ActsKhrgles320001TestSuite::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 ActsKhrgles320001TestSuite::SetUp()
+    {
+    }
+    // Cleanup action of the test case
+    void ActsKhrgles320001TestSuite::TearDown()
+    {
+    }
+}
\ No newline at end of file

graphic/vkgl/src/khrgles32/ActsKhrgles320001TestSuite.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 KHRGLES32_TESTCASE_H
+#define KHRGLES32_TESTCASE_H
+
+#include <gtest/gtest.h>
+#include "Khrgles32BaseFunc.h"
+
+namespace OHOS {
+    class ActsKhrgles320001TestSuite : 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 // KHRGLES32_TESTCASE_H
\ No newline at end of file

graphic/vkgl/src/khrgles32/ActsKhrgles320002TestSuite.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 <gtest/gtest.h>
+#include <ctime>
+#include "Khrgles32BaseFunc.h"
+#include "ActsKhrgles320002TestSuite.h"
+
+namespace OHOS {
+    using namespace std;
+    using namespace testing::ext;
+
+    time_t ActsKhrgles320002TestSuite::starttime;
+    time_t ActsKhrgles320002TestSuite::endtime;
+    FuncRunResult ActsKhrgles320002TestSuite::runResult;
+
+    // Preset action of the test suite, which is executed before the first test case
+    void ActsKhrgles320002TestSuite::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 ActsKhrgles320002TestSuite::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 ActsKhrgles320002TestSuite::SetUp()
+    {
+    }
+    // Cleanup action of the test case
+    void ActsKhrgles320002TestSuite::TearDown()
+    {
+    }
+}
\ No newline at end of file

graphic/vkgl/src/khrgles32/ActsKhrgles320002TestSuite.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 KHRGLES32_TESTCASE_H
+#define KHRGLES32_TESTCASE_H
+
+#include <gtest/gtest.h>
+#include "Khrgles32BaseFunc.h"
+
+namespace OHOS {
+    class ActsKhrgles320002TestSuite : 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 // KHRGLES32_TESTCASE_H
\ No newline at end of file

graphic/vkgl/src/khrgles32/ActsKhrgles32TestSuite.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 <gtest/gtest.h>
+#include <ctime>
+#include "Khrgles32BaseFunc.h"
+#include "ActsKhrgles32TestSuite.h"
+
+namespace OHOS {
+    using namespace std;
+    using namespace testing::ext;
+
+    time_t ActsKhrgles32TestSuite::starttime;
+    time_t ActsKhrgles32TestSuite::endtime;
+    FuncRunResult ActsKhrgles32TestSuite::runResult;
+
+    // Preset action of the test suite, which is executed before the first test case
+    void ActsKhrgles32TestSuite::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 ActsKhrgles32TestSuite::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 ActsKhrgles32TestSuite::SetUp()
+    {
+    }
+    // Cleanup action of the test case
+    void ActsKhrgles32TestSuite::TearDown()
+    {
+    }
+}
\ No newline at end of file

graphic/vkgl/src/khrgles32/ActsKhrgles32TestSuite.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 KHRGLES32_TESTCASE_H
+#define KHRGLES32_TESTCASE_H
+
+#include <gtest/gtest.h>
+#include "Khrgles32BaseFunc.h"
+
+namespace OHOS {
+    class ActsKhrgles32TestSuite : 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 // KHRGLES32_TESTCASE_H
\ No newline at end of file

graphic/vkgl/src/khrgles32/Khrgles32BaseFunc.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 "tcuDefs.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuPlatform.hpp"
+#include "ActsApp.h"
+#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 "Khrgles32BaseFunc.h"
+
+static tcu::TestPackage* createKhrgles32Package(tcu::TestContext& testCtx)
+{
+    return new es32cts::ES32TestPackage(testCtx, "KHR-KHRGLES32");
+}
+void RegistPackage(void)
+{
+    tcu::TestPackageRegistry *registry = tcu::TestPackageRegistry::getSingleton();
+    registry->registerPackage("KHR-GLES32", createKhrgles32Package);
+}
+
+FuncRunResult RunTestKHRGLES(int argc, const char** argv)
+{
+    FuncRunResult runResult;
+    try {
+        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;
+            };
+        };
+        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;
+    } catch (const std::exception &e) {
+        tcu::die("%s", e.what());
+    };
+    return runResult;
+}
\ No newline at end of file

graphic/vkgl/src/khrgles32/Khrgles32BaseFunc.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 KHRGLES32_FUNC_H
+#define KHRGLES32_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 // KHRGLES32_FUNC_H
\ No newline at end of file

graphic/vkgl/src/khrgles32/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("libkhrgles32func0001") {
+  sources = common_src
+  sources += [ "../Khrgles32BaseFunc.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("ActsKhrgles32TestSuite0001") {
+  sources = [
+    "../ActsKhrgles320001TestSuite.cpp",
+    "../core/Khrgles32core_constant_expressionsTestCase.cpp",
+    "../core/Khrgles32core_draw_buffers_indexedTestCase.cpp",
+    "../core/Khrgles32core_gpu_shader5TestCase.cpp",
+    "../core/Khrgles32core_texture_border_clampTestCase.cpp",
+    "../core/Khrgles32core_texture_bufferTestCase.cpp",
+    "../core/Khrgles32core_texture_cube_map_arrayTestCase.cpp",
+    "../core/Khrgles32geometry_shader_adjacencyTestCase.cpp",
+    "../core/Khrgles32geometry_shader_apiTestCase.cpp",
+    "../core/Khrgles32geometry_shader_blittingTestCase.cpp",
+    "../core/Khrgles32geometry_shader_clippingTestCase.cpp",
+    "../core/Khrgles32geometry_shader_constant_variablesTestCase.cpp",
+    "../core/Khrgles32geometry_shader_inputTestCase.cpp",
+    "../core/Khrgles32geometry_shader_layered_fboTestCase.cpp",
+    "../core/Khrgles32geometry_shader_layered_framebufferTestCase.cpp",
+    "../core/Khrgles32geometry_shader_layered_renderingTestCase.cpp",
+    "../core/Khrgles32geometry_shader_layered_rendering_boundary_conditionTestCase.cpp",
+    "../core/Khrgles32geometry_shader_layered_rendering_fbo_no_attachmentTestCase.cpp",
+    "../core/Khrgles32geometry_shader_limitsTestCase.cpp",
+    "../core/Khrgles32geometry_shader_linkingTestCase.cpp",
+    "../core/Khrgles32geometry_shader_nonarray_inputTestCase.cpp",
+    "../core/Khrgles32geometry_shader_outputTestCase.cpp",
+    "../core/Khrgles32geometry_shader_primitive_counterTestCase.cpp",
+    "../core/Khrgles32geometry_shader_primitive_queriesTestCase.cpp",
+    "../core/Khrgles32geometry_shader_program_resourceTestCase.cpp",
+    "../core/Khrgles32geometry_shader_qualifiersTestCase.cpp",
+    "../core/Khrgles32rendering_renderingTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_compilation_and_linking_errorsTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_singleTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_tessellation_control_to_tessellation_evaluationTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_tessellation_invarianceTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_tessellation_shader_point_modeTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_tessellation_shader_quads_tessellationTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_tessellation_shader_tc_barriersTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_tessellation_shader_tessellationTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_tessellation_shader_triangles_tessellationTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_vertexTestCase.cpp",
+    "../core/Khrgles32tessellation_shader_windingTestCase.cpp",
+    "../info/Khrgles32KHR-GLES32_infoTestCase.cpp",
+    "../shaders/Khrgles32shaders_aggressive_optimizationsTestCase.cpp",
+    "../shaders/Khrgles32shaders_negativeTestCase.cpp",
+    "../shaders/Khrgles32shaders_shader_integer_mixTestCase.cpp",
+  ]
+
+  include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ]
+
+  deps = [ ":libkhrgles32func0001" ]
+
+  cflags = [ "-Wno-error" ]
+}

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

+{
+    "description": "Config for ActsKhrgles32TestSuite0001 test cases",
+    "driver": {
+        "module-name": "ActsKhrgles32TestSuite0001",
+        "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": [
+                "ActsKhrgles32TestSuite0001->/data/local/tmp/ActsKhrgles32TestSuite0001",
+                "../../../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/khrgles32/build0002/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("libkhrgles32func0002") {
+  sources = common_src
+  sources += [ "../Khrgles32BaseFunc.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("ActsKhrgles32TestSuite0002") {
+  sources = [
+    "../ActsKhrgles320002TestSuite.cpp",
+    "../core/Khrgles32compressed_format_apiTestCase.cpp",
+    "../core/Khrgles32compressed_format_formatTestCase.cpp",
+    "../core/Khrgles32core_copy_imageTestCase.cpp",
+    "../core/Khrgles32core_framebuffer_completenessTestCase.cpp",
+    "../core/Khrgles32core_nearest_edgeTestCase.cpp",
+    "../core/Khrgles32core_separable_programs_tfTestCase.cpp",
+    "../core/Khrgles32core_shader_macrosTestCase.cpp",
+    "../core/Khrgles32core_texture_compatibilityTestCase.cpp",
+    "../core/Khrgles32ext_texture_shadow_lod_textureTestCase.cpp",
+    "../core/Khrgles32ext_texture_shadow_lod_texturelodTestCase.cpp",
+    "../core/Khrgles32ext_texture_shadow_lod_texturelodoffsetTestCase.cpp",
+    "../core/Khrgles32ext_texture_shadow_lod_textureoffsetTestCase.cpp",
+    "../core/Khrgles32internalformat_copy_tex_imageTestCase.cpp",
+    "../core/Khrgles32internalformat_renderbufferTestCase.cpp",
+    "../core/Khrgles32internalformat_texture2dTestCase.cpp",
+  ]
+
+  include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ]
+
+  deps = [ ":libkhrgles32func0002" ]
+
+  cflags = [ "-Wno-error" ]
+}

graphic/vkgl/src/khrgles32/build0002/Test.json

+{
+    "description": "Config for ActsKhrgles32TestSuite0002 test cases",
+    "driver": {
+        "module-name": "ActsKhrgles32TestSuite0002",
+        "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": [
+                "ActsKhrgles32TestSuite0002->/data/local/tmp/ActsKhrgles32TestSuite0002",
+                "../../../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/khrgles32/core/Khrgles32ext_texture_shadow_lod_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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320002TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001132, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001132 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod"
+        ".texture.sampler2darrayshadow_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001132 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001132 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001133, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001133 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod.t"
+        "exture.sampler2darrayshadow_bias_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001133 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001133 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001134, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001134 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod"
+        ".texture.samplercubearrayshadow_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001134 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001134 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001135, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001135 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod."
+        "texture.samplercubearrayshadow_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001135 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001135 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001136, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001136 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod.te"
+        "xture.samplercubearrayshadow_bias_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001136 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001136 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32ext_texture_shadow_lod_texturelodTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320002TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001140, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001140 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod"
+        ".texturelod.sampler2darrayshadow_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001140 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001140 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001141, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001141 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod."
+        "texturelod.sampler2darrayshadow_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001141 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001141 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001142, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001142 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lo"
+        "d.texturelod.samplercubeshadow_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001142 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001142 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001143, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001143 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod"
+        ".texturelod.samplercubeshadow_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001143 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001143 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001144, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001144 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod.t"
+        "exturelod.samplercubearrayshadow_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001144 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001144 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32ext_texture_shadow_lod_texturelodoffsetTestCase.cpp

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-#include <climits>
 #include <gtest/gtest.h>
 #include "../Khrgles32BaseFunc.h"
 #include "../ActsKhrgles320002TestSuite.h"

graphic/vkgl/src/khrgles32/core/Khrgles32ext_texture_shadow_lod_textureoffsetTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320002TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001137, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001137 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod.t"
+        "extureoffset.sampler2darrayshadow_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001137 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001137 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001138, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001138 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod.te"
+        "xtureoffset.sampler2darrayshadow_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001138 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001138 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001139, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001139 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.ext_texture_shadow_lod.text"
+        "ureoffset.sampler2darrayshadow_bias_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001139 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001139 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_adjacencyTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000029, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000029 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.ad"
+        "jacency.adjacency_non_indiced_lines",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000029 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000029 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000030, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000030 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader."
+        "adjacency.adjacency_indiced_lines",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000030 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000030 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000031, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000031 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.adjac"
+        "ency.adjacency_non_indiced_line_strip",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000031 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000031 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000032, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000032 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.adj"
+        "acency.adjacency_indiced_line_strip",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000032 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000032 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000033, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000033 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.adja"
+        "cency.adjacency_non_indiced_triangles",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000033 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000033 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000034, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000034 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.ad"
+        "jacency.adjacency_indiced_triangles",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000034 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000034 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000035, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000035 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.adjacen"
+        "cy.adjacency_non_indiced_triangle_strip",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000035 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000035 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000036, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000036 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.adjac"
+        "ency.adjacency_indiced_triangle_strip",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000036 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000036 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_apiTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000140, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000140 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sha"
+        "der.api.createShaderProgramv",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000140 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000140 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000141, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000141 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometr"
+        "y_shader.api.shader_type",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000141 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000141 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000142, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000142 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry"
+        "_shader.api.getProgramiv",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000142 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000142 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000143, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000143 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry"
+        "_shader.api.getProgramiv2",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000143 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000143 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000144, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000144 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry"
+        "_shader.api.getProgramiv3",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000144 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000144 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000145, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000145 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_"
+        "shader.api.fs_gs_draw_call",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000145 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000145 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000146, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000146 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sh"
+        "ader.api.max_image_uniforms",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000146 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000146 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000147, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000147 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shade"
+        "r.api.max_shader_storage_blocks",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000147 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000147 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000148, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000148 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sh"
+        "ader.api.max_atomic_counters",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000148 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000148 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000149, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000149 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader"
+        ".api.max_atomic_counter_buffers",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000149 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000149 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000150, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000150 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.api"
+        ".pipeline_program_without_active_vs",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000150 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000150 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000151, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000151 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader"
+        ".api.incompatible_draw_call_mode",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000151 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000151 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000152, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000152 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader."
+        "api.insufficient_emitted_vertices",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000152 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000152 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000153, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000153 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.a"
+        "pi.program_pipeline_vs_gs_capture",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000153 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000153 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000154, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000154 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.api.draw_"
+        "primitives_do_not_match_output_primitives",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000154 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000154 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000155, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000155 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader."
+        "api.draw_calls_while_tf_is_paused",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000155 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000155 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_blittingTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000097, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000097 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shad"
+        "er.blitting.layered_nonlayered",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000097 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000097 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000098, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000098 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shad"
+        "er.blitting.nonlayered_layered",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000098 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000098 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000099, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000099 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sha"
+        "der.blitting.layered_layered",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000099 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000099 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_clippingTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000096, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000096 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry"
+        "_shader.clipping.clipping",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000096 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000096 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_constant_variablesTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000117, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000117 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.co"
+        "nstant_variables.constant_variables",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000117 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000117 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_inputTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000072, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000072 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shad"
+        "er.input.gl_in_array_contents",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000072 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000072 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000073, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000073 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sha"
+        "der.input.gl_in_array_length",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000073 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000073 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000074, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000074 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sha"
+        "der.input.gl_pointsize_value",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000074 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000074 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000075, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000075 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sh"
+        "ader.input.gl_position_value",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000075 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000075 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_layered_fboTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000157, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000157 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sh"
+        "ader.layered_fbo.layered_fbo",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000157 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000157 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000158, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000158 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.l"
+        "ayered_fbo.layered_fbo_attachments",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000158 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000158 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000159, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000159 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.la"
+        "yered_fbo.fb_texture_invalid_target",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000159 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000159 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000160, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000160 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.layere"
+        "d_fbo.fb_texture_no_fbo_bound_to_target",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000160 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000160 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000161, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000161 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.laye"
+        "red_fbo.fb_texture_invalid_attachment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000161 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000161 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000162, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000162 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.la"
+        "yered_fbo.fb_texture_invalid_value",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000162 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000162 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000163, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000163 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.layer"
+        "ed_fbo.fb_texture_invalid_level_number",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000163 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000163 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000164, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000164 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.layered_fbo."
+        "fb_texture_argument_refers_to_buffer_texture",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000164 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000164 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_layered_framebufferTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000104, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000104 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.l"
+        "ayered_framebuffer.stencil_support",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000104 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000104 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000105, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000105 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader."
+        "layered_framebuffer.depth_support",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000105 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000105 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000106, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000106 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.la"
+        "yered_framebuffer.blending_support",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000106 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000106 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000107, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000107 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.lay"
+        "ered_framebuffer.clear_call_support",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000107 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000107 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_layered_renderingTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000095, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000095 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.l"
+        "ayered_rendering.layered_rendering",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000095 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000095 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_layered_rendering_boundary_conditionTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000100, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000100 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.layered_rendering_boundary_co"
+        "ndition.layered_rendering_boundary_condition_various_textures",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000100 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000100 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000101, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000101 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.layered_rendering_bound"
+        "ary_condition.layered_rendering_boundary_condition_no_gs",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000101 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000101 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000102, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000102 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.layered_rendering_boundary_co"
+        "ndition.layered_rendering_boundary_condition_no_default_layer",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000102 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000102 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000103, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000103 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.layered_rendering_boundary_c"
+        "ondition.layered_rendering_boundary_condition_no_layered_fbo",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000103 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000103 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_layered_rendering_fbo_no_attachmentTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000116, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000116 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.layered_rendering_f"
+        "bo_no_attachment.layered_rendering_fbo_no_attachment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000116 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000116 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_limitsTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000118, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000118 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shade"
+        "r.limits.max_uniform_components",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000118 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000118 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000119, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000119 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sha"
+        "der.limits.max_uniform_blocks",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000119 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000119 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000120, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000120 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shad"
+        "er.limits.max_input_components",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000120 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000120 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000121, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000121 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shade"
+        "r.limits.max_output_components",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000121 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000121 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000122, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000122 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shad"
+        "er.limits.max_output_vertices",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000122 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000122 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000123, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000123 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.limi"
+        "ts.max_output_components_single_point",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000123 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000123 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000124, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000124 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sha"
+        "der.limits.max_texture_units",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000124 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000124 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000125, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000125 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sh"
+        "ader.limits.max_invocations",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000125 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000125 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000126, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000126 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader."
+        "limits.max_combined_texture_units",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000126 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000126 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_linkingTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000127, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000127 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.l"
+        "inking.incomplete_program_objects",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000127 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000127 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000128, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000128 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_s"
+        "hader.linking.incomplete_gs",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000128 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000128 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000129, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000129 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.lin"
+        "king.invalid_arrayed_input_variables",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000129 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000129 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000130, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000130 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.li"
+        "nking.vs_gs_variable_type_mismatch",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000130 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000130 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000131, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000131 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.link"
+        "ing.vs_gs_variable_qualifier_mismatch",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000131 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000131 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000132, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000132 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.linkin"
+        "g.vs_gs_arrayed_variable_size_mismatch",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000132 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000132 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000133, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000133 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader"
+        ".linking.fragcoord_redeclaration",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000133 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000133 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000134, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000134 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_sha"
+        "der.linking.location_aliasing",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000134 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000134 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000135, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000135 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.li"
+        "nking.more_ACs_in_GS_than_supported",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000135 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000135 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000136, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000136 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.lin"
+        "king.more_ACBs_in_GS_than_supported",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000136 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000136 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000137, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000137 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.link"
+        "ing.geometry_shader_compilation_fail",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000137 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000137 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000138, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000138 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.linking."
+        "more_input_vertices_in_GS_than_available",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000138 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000138 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000139, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000139 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shader.linki"
+        "ng.tf_capture_from_gs_and_vs_variables",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000139 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000139 end";
+}

graphic/vkgl/src/khrgles32/core/Khrgles32geometry_shader_nonarray_inputTestCase.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 <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000071, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000071 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.geometry_shade"
+        "r.nonarray_input.nonarray_input",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000071 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000071 end";
+}