add depq2 testcase

Signed-off-by: Nwangshi <wangshi@kaihongdigi.com>

graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_builtinTestCase.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 "../Deqpgles2BaseFunc.h"
+#include "../ActsDeqpgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000447, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000447 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepr"
+        "ocessor.builtin.line_and_file_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000447 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000447 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000448, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000448 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepro"
+        "cessor.builtin.line_and_file_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000448 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000448 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000449, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000449 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepro"
+        "cessor.builtin.line_defined_2_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000449 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000449 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000450, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000450 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproc"
+        "essor.builtin.line_defined_2_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000450 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000450 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000451, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000451 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prep"
+        "rocessor.builtin.empty_line_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000451 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000451 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000452, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000452 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepr"
+        "ocessor.builtin.empty_line_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000452 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000452 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000453, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000453 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproce"
+        "ssor.builtin.invalid_line_file_1_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000453 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000453 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000454, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000454 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproces"
+        "sor.builtin.invalid_line_file_1_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000454 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000454 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000455, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000455 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproce"
+        "ssor.builtin.invalid_line_file_3_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000455 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000455 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000456, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000456 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproces"
+        "sor.builtin.invalid_line_file_3_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000456 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000456 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000457, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000457 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproce"
+        "ssor.builtin.invalid_line_file_4_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000457 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000457 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000458, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000458 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproces"
+        "sor.builtin.invalid_line_file_4_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000458 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000458 end";
+}

graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_definitionsTestCase.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 "../Deqpgles2BaseFunc.h"
+#include "../ActsDeqpgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000149, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000149 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor."
+        "definitions.define_value_and_function_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000149 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000149 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000150, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000150 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.d"
+        "efinitions.define_value_and_function_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000150 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000150 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000151, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000151 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.def"
+        "initions.undefine_object_invalid_syntax_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000151 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000151 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000152, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000152 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.defi"
+        "nitions.undefine_object_invalid_syntax_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000152 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000152 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000153, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000153 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor."
+        "definitions.undefine_invalid_object_3_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000153 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000153 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000154, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000154 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.d"
+        "efinitions.undefine_invalid_object_3_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000154 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000154 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000155, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000155 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor."
+        "definitions.undefine_invalid_object_4_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000155 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000155 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000156, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000156 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.d"
+        "efinitions.undefine_invalid_object_4_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000156 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000156 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000157, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000157 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproces"
+        "sor.definitions.undefine_function_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000157 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000157 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000158, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000158 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocess"
+        "or.definitions.undefine_function_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000158 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000158 end";
+}

graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_function_definitionsTestCase.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 "../Deqpgles2BaseFunc.h"
+#include "../ActsDeqpgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000209, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000209 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.functio"
+        "n_definitions.same_object_and_function_param_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000209 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000209 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000210, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000210 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.function"
+        "_definitions.same_object_and_function_param_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000210 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000210 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000211, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000211 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocesso"
+        "r.function_definitions.complex_func_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000211 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000211 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000212, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000212 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor"
+        ".function_definitions.complex_func_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000212 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000212 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000213, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000213 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.function_"
+        "definitions.function_definition_with_comments_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000213 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000213 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000214, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000214 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.function_d"
+        "efinitions.function_definition_with_comments_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000214 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000214 end";
+}

graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_function_redefinitionsTestCase.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 "../Deqpgles2BaseFunc.h"
+#include "../ActsDeqpgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000225, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000225 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.funct"
+        "ion_redefinitions.function_redefinition_1_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000225 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000225 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000226, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000226 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.functi"
+        "on_redefinitions.function_redefinition_1_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000226 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000226 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000227, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000227 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.funct"
+        "ion_redefinitions.function_redefinition_2_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000227 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000227 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000228, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000228 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.functi"
+        "on_redefinitions.function_redefinition_2_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000228 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000228 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000229, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000229 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.funct"
+        "ion_redefinitions.function_redefinition_3_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000229 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000229 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000230, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000230 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.functi"
+        "on_redefinitions.function_redefinition_3_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000230 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000230 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000231, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000231 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.function_red"
+        "efinitions.invalid_function_redefinition_param_1_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000231 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000231 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000232, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000232 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.function_rede"
+        "finitions.invalid_function_redefinition_param_1_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000232 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000232 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000233, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000233 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.function_red"
+        "efinitions.invalid_function_redefinition_param_2_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000233 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000233 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000234, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000234 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.function_rede"
+        "finitions.invalid_function_redefinition_param_2_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000234 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000234 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000235, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000235 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.function_red"
+        "efinitions.invalid_function_redefinition_param_3_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000235 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000235 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000236, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000236 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.function_rede"
+        "finitions.invalid_function_redefinition_param_3_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000236 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000236 end";
+}

graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_invalid_definitionsTestCase.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 "../Deqpgles2BaseFunc.h"
+#include "../ActsDeqpgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000159, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000159 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.in"
+        "valid_definitions.define_non_identifier_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000159 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000159 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000160, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000160 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.inv"
+        "alid_definitions.define_non_identifier_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000160 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000160 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000161, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000161 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.inv"
+        "alid_definitions.undef_non_identifier_1_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000161 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000161 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000162, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000162 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.inva"
+        "lid_definitions.undef_non_identifier_1_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000162 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000162 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000163, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000163 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.inv"
+        "alid_definitions.undef_non_identifier_2_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000163 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000163 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000164, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000164 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor.inva"
+        "lid_definitions.undef_non_identifier_2_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000164 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000164 end";
+}

graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_pragmasTestCase.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 "../Deqpgles2BaseFunc.h"
+#include "../ActsDeqpgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000459, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000459 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.pr"
+        "eprocessor.pragmas.pragma_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000459 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000459 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000460, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000460 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.pre"
+        "processor.pragmas.pragma_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000460 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000460 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000461, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000461 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproc"
+        "essor.pragmas.pragma_macro_exp_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000461 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000461 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000462, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000462 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preproce"
+        "ssor.pragmas.pragma_macro_exp_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000462 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000462 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000463, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000463 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocesso"
+        "r.pragmas.pragma_unrecognized_debug_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000463 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000463 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000464, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000464 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor"
+        ".pragmas.pragma_unrecognized_debug_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000464 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000464 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000465, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000465 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocesso"
+        "r.pragmas.pragma_unrecognized_token_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000465 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000465 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000466, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000466 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.preprocessor"
+        ".pragmas.pragma_unrecognized_token_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000466 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000466 end";
+}

graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_recursionTestCase.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 "../Deqpgles2BaseFunc.h"
+#include "../ActsDeqpgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000215, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000215 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepr"
+        "ocessor.recursion.recursion_1_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000215 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000215 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000216, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000216 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepro"
+        "cessor.recursion.recursion_1_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000216 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000216 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000217, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000217 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepr"
+        "ocessor.recursion.recursion_2_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000217 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000217 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000218, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000218 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepro"
+        "cessor.recursion.recursion_2_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000218 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000218 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000219, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000219 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepr"
+        "ocessor.recursion.recursion_3_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000219 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000219 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000220, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000220 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepro"
+        "cessor.recursion.recursion_3_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000220 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000220 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000221, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000221 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepr"
+        "ocessor.recursion.recursion_4_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000221 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000221 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000222, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000222 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepro"
+        "cessor.recursion.recursion_4_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000222 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000222 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000223, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000223 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepr"
+        "ocessor.recursion.recursion_5_vertex",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000223 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000223 end";
+}
+
+static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000224, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_000224 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "dEQP-GLES2.functional.shaders.prepro"
+        "cessor.recursion.recursion_5_fragment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_000224 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_000224 end";
+}