add glesexttestcase

Signed-off-by: Nliuguixian <liuguixian@kaihongdigi.com>

graphic/vkgl/src/khrglesext/disjoint_timer_query/KhrglesextKHR-GLESEXT_disjoint_timer_queryTestCase.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_000335, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000335 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.disjoint_t"
+        "imer_query.handle_reuse",
+        "--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_000335 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000335 end";
+}

graphic/vkgl/src/khrglesext/draw_elements_base_vertex_tests/KhrglesextKHR-GLESEXT_draw_elements_base_vertex_testsTestCase.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_000290, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000290 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_base_v"
+        "ertex_tests.basevertex_behavior1",
+        "--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_000290 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000290 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000291, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000291 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_base_v"
+        "ertex_tests.basevertex_behavior2",
+        "--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_000291 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000291 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000292, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000292 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_base"
+        "_vertex_tests.AEP_shader_stages",
+        "--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_000292 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000292 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000293, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000293 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_"
+        "base_vertex_tests.underflow",
+        "--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_000293 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000293 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000294, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000294 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_"
+        "base_vertex_tests.overflow",
+        "--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_000294 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000294 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000295, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000295 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_bas"
+        "e_vertex_tests.valid_active_tf",
+        "--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_000295 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000295 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000296, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000296 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_base_ve"
+        "rtex_tests.invalid_count_argument",
+        "--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_000296 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000296 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000297, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000297 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_base_vertex"
+        "_tests.invalid_instancecount_argument",
+        "--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_000297 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000297 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000298, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000298 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_base_v"
+        "ertex_tests.invalid_mode_argument",
+        "--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_000298 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000298 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000299, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000299 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_base_vert"
+        "ex_tests.invalid_primcount_argument",
+        "--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_000299 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000299 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000300, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000300 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_base_vert"
+        "ex_tests.invalid_start_end_arguments",
+        "--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_000300 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000300 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000301, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000301 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.draw_elements_base_v"
+        "ertex_tests.invalid_type_argument",
+        "--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_000301 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000301 end";
+}

graphic/vkgl/src/khrglesext/ext_texture_shadow_lod/Khrglesextext_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 "../KhrglesextBaseFunc.h"
+#include "../ActsKhrglesext0001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000319, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000319 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod."
+        "texture.sampler2darrayshadow_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_000319 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000319 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000320, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000320 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.t"
+        "exture.sampler2darrayshadow_fragment",
+        "--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_000320 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000320 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000321, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000321 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.tex"
+        "ture.sampler2darrayshadow_bias_fragment",
+        "--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_000321 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000321 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000322, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000322 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.t"
+        "exture.samplercubearrayshadow_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_000322 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000322 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000323, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000323 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.te"
+        "xture.samplercubearrayshadow_fragment",
+        "--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_000323 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000323 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000324, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000324 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.text"
+        "ure.samplercubearrayshadow_bias_fragment",
+        "--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_000324 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000324 end";
+}

graphic/vkgl/src/khrglesext/ext_texture_shadow_lod/Khrglesextext_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 "../KhrglesextBaseFunc.h"
+#include "../ActsKhrglesext0001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000328, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000328 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.t"
+        "exturelod.sampler2darrayshadow_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_000328 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000328 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000329, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000329 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.te"
+        "xturelod.sampler2darrayshadow_fragment",
+        "--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_000329 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000329 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000330, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000330 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod."
+        "texturelod.samplercubeshadow_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_000330 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000330 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000331, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000331 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.t"
+        "exturelod.samplercubeshadow_fragment",
+        "--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_000331 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000331 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000332, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000332 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.tex"
+        "turelod.samplercubearrayshadow_fragment",
+        "--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_000332 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000332 end";
+}

graphic/vkgl/src/khrglesext/ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_texturelodoffsetTestCase.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_000333, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000333 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.text"
+        "urelodoffset.sampler2darrayshadow_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_000333 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000333 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000334, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000334 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.textu"
+        "relodoffset.sampler2darrayshadow_fragment",
+        "--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_000334 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000334 end";
+}

graphic/vkgl/src/khrglesext/ext_texture_shadow_lod/Khrglesextext_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 "../KhrglesextBaseFunc.h"
+#include "../ActsKhrglesext0001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000325, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000325 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.tex"
+        "tureoffset.sampler2darrayshadow_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_000325 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000325 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000326, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000326 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.text"
+        "ureoffset.sampler2darrayshadow_fragment",
+        "--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_000326 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000326 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000327, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000327 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.ext_texture_shadow_lod.textur"
+        "eoffset.sampler2darrayshadow_bias_fragment",
+        "--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_000327 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000327 end";
+}

graphic/vkgl/src/khrglesext/texture_buffer/KhrglesextKHR-GLESEXT_texture_bufferTestCase.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_000274, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000274 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.textu"
+        "re_buffer_operations_buffer_load",
+        "--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_000274 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000274 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000275, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000275 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.text"
+        "ure_buffer_operations_cpu_writes",
+        "--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_000275 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000275 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000276, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000276 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.texture_b"
+        "uffer_operations_framebuffer_readback",
+        "--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_000276 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000276 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000277, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000277 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.texture_"
+        "buffer_operations_transform_feedback",
+        "--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_000277 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000277 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000278, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000278 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.textu"
+        "re_buffer_operations_image_store",
+        "--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_000278 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000278 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000279, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000279 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.textu"
+        "re_buffer_operations_ssbo_writes",
+        "--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_000279 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000279 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000280, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000280 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffe"
+        "r.texture_buffer_max_size",
+        "--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_000280 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000280 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000281, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000281 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.text"
+        "ure_buffer_texture_buffer_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_000281 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000281 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000282, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000282 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.te"
+        "xture_buffer_conv_int_to_float",
+        "--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_000282 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000282 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000283, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000283 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.te"
+        "xture_buffer_atomic_functions",
+        "--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_000283 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000283 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000284, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000284 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer"
+        ".texture_buffer_parameters",
+        "--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_000284 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000284 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000285, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000285 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buff"
+        "er.texture_buffer_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_000285 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000285 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000286, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000286 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.texture_buffer"
+        "_active_uniform_validation_fragment_shader",
+        "--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_000286 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000286 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000287, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000287 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.texture_buffer"
+        "_active_uniform_validation_compute_shader",
+        "--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_000287 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000287 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000288, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000288 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffer.te"
+        "xture_buffer_buffer_parameters",
+        "--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_000288 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000288 end";
+}
+
+static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000289, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000289 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLESEXT.texture_buffe"
+        "r.texture_buffer_precision",
+        "--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_000289 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000289 end";
+}