add khrglesext

Signed-off-by: Nduanying <duanying@kaihongdigi.com>

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

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

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

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

graphic/vkgl/src/khrglesext/KhrglesextBaseFunc.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 "KhrglesextBaseFunc.h"
+
+static tcu::TestPackage* createKhrglesextPackage(tcu::TestContext& testCtx)
+{
+    return new esextcts::ESEXTTestPackage(testCtx, "KHR-KHRGLESEXT");
+}
+void RegistPackage(void)
+{
+    tcu::TestPackageRegistry *registry = tcu::TestPackageRegistry::getSingleton();
+    registry->registerPackage("KHR-GLESEXT", createKhrglesextPackage);
+}
+
+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/khrglesext/KhrglesextBaseFunc.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 KHRGLESEXT_FUNC_H
+#define KHRGLESEXT_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 // KHRGLESEXT_FUNC_H
\ No newline at end of file

graphic/vkgl/src/khrglesext/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("libkhrglesextfunc0001") {
+  sources = common_src
+  sources += [ "../KhrglesextBaseFunc.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("ActsKhrglesextTestSuite0001") {
+  sources = [
+    "../ActsKhrglesext0001TestSuite.cpp",
+    "../disjoint_timer_query/KhrglesextKHR-GLESEXT_disjoint_timer_queryTestCase.cpp",
+    "../draw_elements_base_vertex_tests/KhrglesextKHR-GLESEXT_draw_elements_base_vertex_testsTestCase.cpp",
+    "../ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_textureTestCase.cpp",
+    "../ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_texturelodTestCase.cpp",
+    "../ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_texturelodoffsetTestCase.cpp",
+    "../ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_textureoffsetTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_adjacencyTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_apiTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_blittingTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_clippingTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_constant_variablesTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_inputTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_layered_fboTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_layered_framebufferTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_layered_renderingTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_layered_rendering_boundary_conditionTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_layered_rendering_fbo_no_attachmentTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_limitsTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_linkingTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_nonarray_inputTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_outputTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_primitive_counterTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_primitive_queriesTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_program_resourceTestCase.cpp",
+    "../geometry_shader/Khrglesextgeometry_shader_qualifiersTestCase.cpp",
+    "../geometry_shader/Khrglesextrendering_renderingTestCase.cpp",
+    "../gpu_shader5/KhrglesextKHR-GLESEXT_gpu_shader5TestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_compilation_and_linking_errorsTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_singleTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_tessellation_control_to_tessellation_evaluationTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_tessellation_invarianceTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_point_modeTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_quads_tessellationTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_tc_barriersTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_tessellationTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_triangles_tessellationTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_vertexTestCase.cpp",
+    "../tessellation_shader/Khrglesexttessellation_shader_windingTestCase.cpp",
+    "../texture_border_clamp/KhrglesextKHR-GLESEXT_texture_border_clampTestCase.cpp",
+    "../texture_buffer/KhrglesextKHR-GLESEXT_texture_bufferTestCase.cpp",
+    "../texture_cube_map_array/KhrglesextKHR-GLESEXT_texture_cube_map_arrayTestCase.cpp",
+    "../viewport_array/KhrglesextKHR-GLESEXT_viewport_arrayTestCase.cpp",
+  ]
+
+  include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ]
+
+  deps = [ ":libkhrglesextfunc0001" ]
+
+  cflags = [ "-Wno-error" ]
+}

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

+{
+    "description": "Config for ActsKhrglesextTestSuite0001 test cases",
+    "driver": {
+        "module-name": "ActsKhrglesextTestSuite0001",
+        "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": [
+                "ActsKhrglesextTestSuite0001->/data/local/tmp/ActsKhrglesextTestSuite0001",
+                "../../../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/khrglesext/build0001/logdefine.cpp

+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "tcuDefs.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuPlatform.hpp"
+#include "ActsApp.h"
+#include "tcuResource.hpp"
+#include "tcuTestLog.hpp"
+#include "tcuTestSessionExecutor.hpp"
+#include "deUniquePtr.hpp"

graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_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 "../KhrglesextBaseFunc.h"
+#include "../ActsKhrglesext0001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000099, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000099 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.lin"
+        "king.incomplete_program_objects",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::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";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000100, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000100 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_sha"
+        "der.linking.incomplete_gs",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::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(ActsKhrglesext0001TestSuite, TestCase_000101, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000101 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.linki"
+        "ng.invalid_arrayed_input_variables",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::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(ActsKhrglesext0001TestSuite, TestCase_000102, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000102 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.link"
+        "ing.vs_gs_variable_type_mismatch",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::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(ActsKhrglesext0001TestSuite, TestCase_000103, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000103 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.linkin"
+        "g.vs_gs_variable_qualifier_mismatch",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::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";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000104, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000104 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.linking."
+        "vs_gs_arrayed_variable_size_mismatch",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::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(ActsKhrglesext0001TestSuite, TestCase_000105, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000105 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.l"
+        "inking.fragcoord_redeclaration",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::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(ActsKhrglesext0001TestSuite, TestCase_000106, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000106 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shade"
+        "r.linking.location_aliasing",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::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(ActsKhrglesext0001TestSuite, TestCase_000107, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000107 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.link"
+        "ing.more_ACs_in_GS_than_supported",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::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";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000108, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000108 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.linki"
+        "ng.more_ACBs_in_GS_than_supported",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000108 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000108 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000109, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000109 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.linkin"
+        "g.geometry_shader_compilation_fail",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000109 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000109 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000110, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000110 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.linking.mo"
+        "re_input_vertices_in_GS_than_available",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000110 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000110 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000111, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000111 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.geometry_shader.linking"
+        ".tf_capture_from_gs_and_vs_variables",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000111 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000111 end";
+}

graphic/vkgl/src/khrglesext/viewport_array/KhrglesextKHR-GLESEXT_viewport_arrayTestCase.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 "../KhrglesextBaseFunc.h"
+#include "../ActsKhrglesext0001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000302, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000302 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewpo"
+        "rt_array.api_errors",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000302 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000302 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000303, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000303 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewp"
+        "ort_array.queries",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000303 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000303 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000304, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000304 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewpor"
+        "t_array.viewport_api",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000304 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000304 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000305, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000305 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewpor"
+        "t_array.scissor_api",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000305 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000305 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000306, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000306 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_"
+        "array.depth_range_api",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000306 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000306 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000307, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000307 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_arr"
+        "ay.scissor_test_state_api",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000307 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000307 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000308, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000308 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_array.draw_to_"
+        "single_layer_with_multiple_viewports",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000308 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000308 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000309, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000309 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_arr"
+        "ay.dynamic_viewport_index",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000309 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000309 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000310, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000310 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_array.draw_muli"
+        "tple_viewports_with_single_invocation",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000310 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000310 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000311, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000311 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_array"
+        ".viewport_index_subroutine",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000311 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000311 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000312, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000312 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_ar"
+        "ray.draw_multiple_layers",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000312 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000312 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000313, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000313 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewp"
+        "ort_array.scissor",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000313 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000313 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000314, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000314 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_arr"
+        "ay.scissor_zero_dimension",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000314 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000314 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000315, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000315 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport"
+        "_array.scissor_clear",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000315 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000315 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000316, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000316 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewpor"
+        "t_array.depth_range",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000316 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000316 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000317, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000317 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_arr"
+        "ay.depth_range_depth_test",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000317 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000317 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000318, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000318 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.viewport_"
+        "array.provoking_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000318 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000318 end";
+}