add khrgles2case

Signed-off-by: Nlilinjian <lilinjian@kaihongdigi.com>

graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_renderbufferTestCase.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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.hpp"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000463, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgba8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.rgba8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgba8 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgba8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000464, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.rgb8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb8 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000465, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index1_oes start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.stencil_index1_oes",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index1_oes Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index1_oes end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000466, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index4_oes start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.stencil_index4_oes",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index4_oes Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index4_oes end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000467, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.stencil_index8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index8 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.stencil_index8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000468, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component16 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.depth_component16",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component16 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component16 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000469, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component24 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.depth_component24",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component24 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component24 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000470, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component32 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.depth_component32",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component32 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth_component32 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000471, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth24_stencil8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.depth24_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth24_stencil8 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.depth24_stencil8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000472, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb5_a1 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.core.internalformat.renderbuffer.rgb5_a1",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb5_a1 Unavaliable!";
+    } else if (result.isComplete == true) {
+        EXPECT_TRUE(result.isComplete == true);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    
+    GTEST_LOG_(INFO) << "KHR-GLES2.core.internalformat.renderbuffer.rgb5_a1 end";
+}

graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_aggressive_optimizationsTestCase.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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000003, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_float_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_float_vert",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.sin_float_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_float_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000004, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_float_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_float_frag",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.sin_float_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_float_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000005, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_vert",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000006, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_frag",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec2_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000007, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_vert",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000008, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_frag",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.sin_vec3_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000009, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_float_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_float_vert",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.cos_float_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_float_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000010, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_float_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_float_frag",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.cos_float_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_float_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000011, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_vert",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000012, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_frag",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec2_frag end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000013, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_vert start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_vert",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_vert notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_vert end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000014, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_frag start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_frag",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_frag notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.aggressive_optimizations.cos_vec3_frag end";
+}

graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_negativeTestCase.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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000001, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.negative.initialize start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.negative.initialize",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.negative.initialize notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.negative.initialize end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000002, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.negative.constant_sequence start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.shaders.negative.constant_sequence",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.shaders.negative.constant_sequence notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.shaders.negative.constant_sequence end";
+}

graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_formatsTestCase.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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000015, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000016, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_linear",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000017, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_nearest start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_nearest",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_nearest notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_nearest end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000018, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_nearest start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_nearest",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_nearest notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_nearest end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000019, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_linear start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_linear",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_linear notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_nearest_mipmap_linear end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000020, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_linear start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_linear",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_linear notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.filtering.formats.rgba8_linear_mipmap_linear end";
+}

graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_copy_sub_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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000378, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.copy_sub_image.rgba start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.copy_sub_image.rgba",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.copy_sub_image.rgba notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.copy_sub_image.rgba end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000379, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.copy_sub_image.negative start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.copy_sub_image.negative",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.copy_sub_image.negative notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.copy_sub_image.negative end";
+}

graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_framebuffer_textureTestCase.cpp

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

graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_sub_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 <climits>
+#include <gtest/gtest.h>
+#include "../Khrgles2BaseFunc.hpp"
+#include "../ActsKhrgles20001TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000376, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.sub_image.rgba8 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.sub_image.rgba8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.sub_image.rgba8 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.sub_image.rgba8 end";
+}
+
+static HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000377, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.sub_image.negative start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case=KHR-GLES2.texture_3d.sub_image.negative",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles20001TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles20001TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles20001TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles20001TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles20001TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) <<
+            "KHR-GLES2.texture_3d.sub_image.negative notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    }
+    GTEST_LOG_(INFO) <<
+        "KHR-GLES2.texture_3d.sub_image.negative end";
+}