add testcase

Signed-off-by: Njiangyuan <jiangyuan@kaihongdigi.com>

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

+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320002TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001028, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001028 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.cop"
+        "y_image.r32i_texture",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001028 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001028 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001029, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001029 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.copy"
+        "_image.r32ui_texture",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001029 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001029 end";
+}

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

+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000319, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000319 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.draw_b"
+        "uffers_indexed.coverage",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000319 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000319 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000320, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000320 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.draw_buff"
+        "ers_indexed.default_state",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000320 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000320 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000321, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000321 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.draw_b"
+        "uffers_indexed.set_get",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000321 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000321 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000322, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000322 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.draw_buf"
+        "fers_indexed.color_masks",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000322 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000322 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000323, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000323 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.draw_b"
+        "uffers_indexed.blending",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000323 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000323 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000324, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000324 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.draw_b"
+        "uffers_indexed.negative",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000324 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000324 end";
+}

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

+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320002TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001149, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001149 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_complet"
+        "eness.incomplete_missing_attachment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001149 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001149 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001150, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001150 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_comple"
+        "teness.incomplete_image_zero_width",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001150 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001150 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001151, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001151 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_comple"
+        "teness.incomplete_image_zero_height",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001151 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001151 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001152, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001152 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_complete"
+        "ness.incomplete_texture_3d_layer_oob",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001152 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001152 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001153, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001153 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_complete"
+        "ness.incomplete_texture_2d_layer_oob",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001153 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001153 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001154, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001154 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completen"
+        "ess.incomplete_texture_2d_mm_layer_oob",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001154 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001154 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001155, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001155 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completeness."
+        "mutable_nbl_texture_expect_mipmap_complete",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001155 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001155 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001156, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001156 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completeness"
+        ".mutable_nbl_texture_expect_cube_complete",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001156 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001156 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001157, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001157 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completen"
+        "ess.expect_renderable_internal_format",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001157 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001157 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001158, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001158 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_complete"
+        "ness.all_rbos_expect_same_numsamples",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001158 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001158 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001159, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001159 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completenes"
+        "s.rbo_and_texture_expect_zero_numsamples",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001159 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001159 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001160, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001160 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_comp"
+        "leteness.expect_equal_numsamples",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001160 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001160 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001161, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001161 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_"
+        "completeness.status_tracking",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001161 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001161 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001162, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001162 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completeness"
+        ".mutable_texture_missing_attachment_level",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001162 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001162 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001163, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001163 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completeness."
+        "immutable_texture_any_level_as_attachment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001163 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001163 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001164, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001164 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completeness.cube"
+        "_map_layered_attachment_valid_size_and_format",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001164 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001164 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001165, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001165 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completeness.cu"
+        "be_map_layered_attachment_different_formats",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001165 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001165 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001166, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001166 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.framebuffer_completeness.c"
+        "ube_map_layered_attachment_different_sizes",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001166 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001166 end";
+}

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

+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000165, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000165 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shade"
+        "r5.sampler_array_indexing",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000165 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000165 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000166, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000166 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shad"
+        "er5.images_array_indexing",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000166 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000166 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000167, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000167 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.a"
+        "tomic_counters_array_indexing",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000167 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000167 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000168, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000168 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5."
+        "uniform_blocks_array_indexing",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000168 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000168 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000169, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000169 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_sh"
+        "ader5.precise_qualifier",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000169 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000169 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000170, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000170 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_"
+        "shader5.fma_accuracy",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000170 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000170 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000171, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000171 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_sha"
+        "der5.fma_precision_float",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000171 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000171 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000172, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000172 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_sha"
+        "der5.fma_precision_vec2",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000172 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000172 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000173, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000173 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_sha"
+        "der5.fma_precision_vec3",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000173 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000173 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000174, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000174 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_sha"
+        "der5.fma_precision_vec4",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000174 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000174 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000175, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000175 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.tex"
+        "ture_gather_offset_color_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000175 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000175 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000176, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000176 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.te"
+        "xture_gather_offset_color_array",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000176 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000176 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000177, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000177 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5."
+        "texture_gather_offsets_color",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000177 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000177 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000178, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000178 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.tex"
+        "ture_gather_offset_depth_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000178 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000178 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000179, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000179 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.text"
+        "ure_gather_offset_depth_repeat_y",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000179 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000179 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000180, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000180 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.te"
+        "xture_gather_offset_depth_array",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000180 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000180 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000181, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000181 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5."
+        "texture_gather_offsets_depth",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000181 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000181 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000182, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000182 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.texture"
+        "_gather_offset_color_clamp_to_border",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000182 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000182 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000183, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000183 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.textur"
+        "e_gather_offset_color_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000183 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000183 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000184, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000184 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.textur"
+        "e_gather_offset_depth_clamp_border",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000184 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000184 end";
+}
+
+static HWTEST_F(ActsKhrgles320001TestSuite, TestCase_000185, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000185 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.gpu_shader5.textu"
+        "re_gather_offset_depth_clamp_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000185 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000185 end";
+}

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

+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320002TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001147, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001147 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.near"
+        "est_edge.offset_left",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001147 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001147 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001148, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001148 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.near"
+        "est_edge.offset_right",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001148 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001148 end";
+}

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

+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320002TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001026, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001026 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.separable_pr"
+        "ograms_tf.tessellation_active",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001026 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001026 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001027, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001027 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.separable_"
+        "programs_tf.geometry_active",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001027 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001027 end";
+}

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

+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320002TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001021, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001021 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.shader_macros."
+        "fragment_precision_high_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001021 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001021 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001022, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001022 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.shader_macros.f"
+        "ragment_precision_high_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001022 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001022 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001023, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001023 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.shader_macros.f"
+        "ragment_precision_high_geometry",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001023 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001023 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001024, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001024 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.shader_macros.fra"
+        "gment_precision_high_tess_control",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001024 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001024 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001025, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001025 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.shader_macros.f"
+        "ragment_precision_high_tess_eval",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001025 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001025 end";
+}

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

+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles32BaseFunc.h"
+#include "../ActsKhrgles320002TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001167, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001167 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibility."
+        "texsubimage_format_rgba4_unsigned_byte",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001167 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001167 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001168, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001168 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibility.t"
+        "exsubimage_format_rgb5_a1_unsigned_byte",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001168 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001168 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001169, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001169 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibility.tex"
+        "subimage_format_rgb5_a1_unsigned_int_10_a2",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001169 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001169 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001170, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001170 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibi"
+        "lity.texsubimage_format_r16f_float",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001170 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001170 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001171, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001171 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibil"
+        "ity.texsubimage_format_rg16f_float",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001171 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001171 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001172, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001172 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibil"
+        "ity.texsubimage_format_rgb16f_float",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001172 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001172 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001173, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001173 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibili"
+        "ty.texsubimage_format_rgba16f_float",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001173 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001173 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001174, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001174 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibility.tex"
+        "subimage_format_r11f_g11f_b10f_half_float",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001174 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001174 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001175, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001175 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibility."
+        "texsubimage_format_r11f_g11f_b10f_float",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001175 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001175 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001176, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001176 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibility"
+        ".texsubimage_format_rgb9_e5_half_float",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001176 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001176 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001177, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001177 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibili"
+        "ty.texsubimage_format_rgb9_e5_float",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001177 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001177 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001178, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001178 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibility."
+        "texsubimage_format_rgb565_unsigned_byte",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001178 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001178 end";
+}
+
+static HWTEST_F(ActsKhrgles320002TestSuite, TestCase_001179, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_001179 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES32.core.texture_compatibility.t"
+        "exsubimage_format_depth_component16_uint",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles320002TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles320002TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles320002TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles320002TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles320002TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_001179 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_001179 end";
+}