From fe420438d7e1e8e14dda77239d48efec5113ec31 Mon Sep 17 00:00:00 2001 From: xiongchong Date: Tue, 28 Jun 2022 14:39:26 +0800 Subject: [PATCH] add test Signed-off-by: xiongchong --- ...Khrgles3indexing_uniform_arrayTestCase.cpp | 886 ++++++++++++++++++ .../Khrgles3name_hiding_basicTestCase.cpp | 184 ++++ .../Khrgles3random_basic_arraysTestCase.cpp | 292 ++++++ .../Khrgles3random_basic_typesTestCase.cpp | 292 ++++++ .../Khrgles3random_nested_structsTestCase.cpp | 292 ++++++ ...s3random_nested_structs_arraysTestCase.cpp | 292 ++++++ .../Khrgles3random_scalar_typesTestCase.cpp | 292 ++++++ .../Khrgles3random_vector_typesTestCase.cpp | 292 ++++++ ...ock_single_nested_struct_arrayTestCase.cpp | 265 ++++++ ...form_block_single_struct_arrayTestCase.cpp | 265 ++++++ 10 files changed, 3352 insertions(+) create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3indexing_uniform_arrayTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3name_hiding_basicTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3random_basic_arraysTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3random_basic_typesTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3random_nested_structsTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3random_nested_structs_arraysTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3random_scalar_typesTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3random_vector_typesTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3uniform_block_single_nested_struct_arrayTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles3/shaders/Khrgles3uniform_block_single_struct_arrayTestCase.cpp diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3indexing_uniform_arrayTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3indexing_uniform_arrayTestCase.cpp new file mode 100644 index 000000000..2efb5ab16 --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3indexing_uniform_arrayTestCase.cpp @@ -0,0 +1,886 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000089, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000089 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifo" + "rm_array.float_static_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000089 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000089 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000090, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000090 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifor" + "m_array.float_static_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000090 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000090 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000091, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000091 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifor" + "m_array.float_dynamic_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000091 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000091 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000092, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000092 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform" + "_array.float_dynamic_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000092 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000092 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000093, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000093 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_" + "array.float_static_loop_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000093 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000093 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000094, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000094 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_a" + "rray.float_static_loop_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000094 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000094 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000095, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000095 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_" + "array.float_dynamic_loop_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000095 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000095 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000096, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000096 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_a" + "rray.float_dynamic_loop_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000096 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000096 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000097, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000097 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifo" + "rm_array.vec2_static_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000097 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000097 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000098, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000098 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifor" + "m_array.vec2_static_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000098 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000098 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000099, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000099 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifo" + "rm_array.vec2_dynamic_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000099 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000099 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000100, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000100 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifor" + "m_array.vec2_dynamic_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000100 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000100 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000101, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000101 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform" + "_array.vec2_static_loop_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000101 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000101 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000102, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000102 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_" + "array.vec2_static_loop_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000102 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000102 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000103, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000103 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_" + "array.vec2_dynamic_loop_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000103 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000103 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000104, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000104 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_a" + "rray.vec2_dynamic_loop_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000104 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000104 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000105, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000105 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifo" + "rm_array.vec3_static_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000105 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000105 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000106, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000106 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifor" + "m_array.vec3_static_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000106 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000106 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000107, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000107 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifo" + "rm_array.vec3_dynamic_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000107 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000107 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000108, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000108 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifor" + "m_array.vec3_dynamic_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000108 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000108 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000109, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000109 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform" + "_array.vec3_static_loop_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000109 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000109 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000110, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000110 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_" + "array.vec3_static_loop_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000110 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000110 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000111, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000111 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_" + "array.vec3_dynamic_loop_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000111 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000111 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000112, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000112 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_a" + "rray.vec3_dynamic_loop_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000112 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000112 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000113, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000113 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifo" + "rm_array.vec4_static_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000113 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000113 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000114, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000114 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifor" + "m_array.vec4_static_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000114 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000114 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000115, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000115 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifo" + "rm_array.vec4_dynamic_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000115 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000115 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000116, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000116 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.unifor" + "m_array.vec4_dynamic_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000116 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000116 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000117, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000117 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform" + "_array.vec4_static_loop_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000117 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000117 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000118, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000118 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_" + "array.vec4_static_loop_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000118 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000118 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000119, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000119 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_" + "array.vec4_dynamic_loop_read_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000119 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000119 end"; +} + +static HWTEST_F(ActsKhrgles30001TestSuite, TestCase_000120, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000120 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.indexing.uniform_a" + "rray.vec4_dynamic_loop_read_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000120 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000120 end"; +} diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3name_hiding_basicTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3name_hiding_basicTestCase.cpp new file mode 100644 index 000000000..745c60fd3 --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3name_hiding_basicTestCase.cpp @@ -0,0 +1,184 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30002TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001396, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001396 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.name_hidin" + "g.basic.hidden_name_1_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001396 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001396 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001397, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001397 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.name_hiding" + ".basic.hidden_name_1_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001397 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001397 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001398, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001398 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.name_hidin" + "g.basic.hidden_name_2_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001398 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001398 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001399, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001399 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.name_hiding" + ".basic.hidden_name_2_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001399 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001399 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001400, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001400 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.name_hidin" + "g.basic.hidden_name_3_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001400 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001400 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001401, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001401 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.name_hiding" + ".basic.hidden_name_3_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001401 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001401 end"; +} diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_basic_arraysTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_basic_arraysTestCase.cpp new file mode 100644 index 000000000..81e4e1d8b --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_basic_arraysTestCase.cpp @@ -0,0 +1,292 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002203, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002203 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.0", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002203 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002203 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002204, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002204 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002204 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002204 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002205, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002205 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002205 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002205 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002206, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002206 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.3", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002206 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002206 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002207, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002207 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002207 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002207 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002208, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002208 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.5", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002208 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002208 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002209, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002209 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.6", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002209 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002209 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002210, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002210 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.7", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002210 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002210 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002211, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002211 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.8", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002211 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002211 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002212, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002212 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_arrays.9", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002212 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002212 end"; +} diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_basic_typesTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_basic_typesTestCase.cpp new file mode 100644 index 000000000..3300a324e --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_basic_typesTestCase.cpp @@ -0,0 +1,292 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002193, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002193 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.0", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002193 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002193 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002194, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002194 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002194 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002194 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002195, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002195 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002195 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002195 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002196, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002196 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.3", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002196 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002196 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002197, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002197 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002197 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002197 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002198, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002198 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.5", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002198 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002198 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002199, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002199 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.6", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002199 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002199 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002200, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002200 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.7", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002200 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002200 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002201, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002201 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.8", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002201 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002201 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002202, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002202 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.basic_types.9", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002202 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002202 end"; +} diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_nested_structsTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_nested_structsTestCase.cpp new file mode 100644 index 000000000..598415a1e --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_nested_structsTestCase.cpp @@ -0,0 +1,292 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002223, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002223 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.0", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002223 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002223 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002224, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002224 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002224 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002224 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002225, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002225 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002225 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002225 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002226, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002226 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.3", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002226 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002226 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002227, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002227 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002227 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002227 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002228, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002228 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.5", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002228 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002228 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002229, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002229 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.6", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002229 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002229 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002230, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002230 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.7", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002230 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002230 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002231, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002231 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.8", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002231 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002231 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002232, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002232 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_b" + "lock.random.nested_structs.9", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002232 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002232 end"; +} diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_nested_structs_arraysTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_nested_structs_arraysTestCase.cpp new file mode 100644 index 000000000..23541b99c --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_nested_structs_arraysTestCase.cpp @@ -0,0 +1,292 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002233, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002233 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.0", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002233 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002233 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002234, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002234 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002234 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002234 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002235, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002235 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002235 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002235 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002236, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002236 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.3", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002236 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002236 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002237, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002237 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002237 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002237 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002238, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002238 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.5", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002238 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002238 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002239, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002239 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.6", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002239 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002239 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002240, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002240 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.7", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002240 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002240 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002241, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002241 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.8", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002241 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002241 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002242, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002242 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block" + ".random.nested_structs_arrays.9", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002242 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002242 end"; +} diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_scalar_typesTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_scalar_typesTestCase.cpp new file mode 100644 index 000000000..4d8abe312 --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_scalar_typesTestCase.cpp @@ -0,0 +1,292 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002173, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002173 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.0", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002173 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002173 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002174, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002174 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002174 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002174 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002175, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002175 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002175 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002175 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002176, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002176 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.3", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002176 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002176 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002177, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002177 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002177 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002177 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002178, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002178 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.5", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002178 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002178 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002179, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002179 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.6", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002179 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002179 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002180, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002180 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.7", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002180 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002180 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002181, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002181 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.8", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002181 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002181 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002182, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002182 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.scalar_types.9", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002182 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002182 end"; +} diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_vector_typesTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_vector_typesTestCase.cpp new file mode 100644 index 000000000..f78879689 --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3random_vector_typesTestCase.cpp @@ -0,0 +1,292 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002183, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002183 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.0", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002183 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002183 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002184, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002184 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002184 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002184 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002185, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002185 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002185 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002185 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002186, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002186 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.3", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002186 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002186 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002187, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002187 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002187 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002187 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002188, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002188 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.5", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002188 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002188 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002189, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002189 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.6", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002189 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002189 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002190, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002190 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.7", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002190 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002190 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002191, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002191 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.8", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002191 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002191 end"; +} + +static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002192, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002192 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_" + "block.random.vector_types.9", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002192 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002192 end"; +} diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3uniform_block_single_nested_struct_arrayTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3uniform_block_single_nested_struct_arrayTestCase.cpp new file mode 100644 index 000000000..49e28a5b5 --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3uniform_block_single_nested_struct_arrayTestCase.cpp @@ -0,0 +1,265 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30002TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001995, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001995 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_ne" + "sted_struct_array.per_block_buffer_shared", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001995 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001995 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001996, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001996 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_nested_st" + "ruct_array.per_block_buffer_shared_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001996 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001996 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001997, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001997 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_ne" + "sted_struct_array.per_block_buffer_packed", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001997 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001997 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001998, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001998 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_nested_st" + "ruct_array.per_block_buffer_packed_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001998 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001998 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001999, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001999 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_ne" + "sted_struct_array.per_block_buffer_std140", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001999 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001999 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_002000, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002000 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_nested_st" + "ruct_array.per_block_buffer_std140_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002000 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002000 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_002001, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002001 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_nested_s" + "truct_array.single_buffer_shared_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002001 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002001 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_002002, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002002 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_nested_s" + "truct_array.single_buffer_packed_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002002 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002002 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_002003, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002003 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_nested_s" + "truct_array.single_buffer_std140_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002003 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002003 end"; +} diff --git a/graphic/vkgl/src/khrgles3/shaders/Khrgles3uniform_block_single_struct_arrayTestCase.cpp b/graphic/vkgl/src/khrgles3/shaders/Khrgles3uniform_block_single_struct_arrayTestCase.cpp new file mode 100644 index 000000000..8a61f8fad --- /dev/null +++ b/graphic/vkgl/src/khrgles3/shaders/Khrgles3uniform_block_single_struct_arrayTestCase.cpp @@ -0,0 +1,265 @@ +/* + * 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 +#include "../Khrgles3BaseFunc.h" +#include "../ActsKhrgles30002TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001977, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001977 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.singl" + "e_struct_array.per_block_buffer_shared", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001977 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001977 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001978, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001978 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_struct" + "_array.per_block_buffer_shared_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001978 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001978 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001979, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001979 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.singl" + "e_struct_array.per_block_buffer_packed", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001979 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001979 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001980, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001980 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_struct" + "_array.per_block_buffer_packed_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001980 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001980 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001981, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001981 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.singl" + "e_struct_array.per_block_buffer_std140", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001981 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001981 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001982, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001982 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_struct" + "_array.per_block_buffer_std140_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001982 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001982 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001983, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001983 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_stru" + "ct_array.single_buffer_shared_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001983 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001983 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001984, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001984 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_stru" + "ct_array.single_buffer_packed_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001984 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001984 end"; +} + +static HWTEST_F(ActsKhrgles30002TestSuite, TestCase_001985, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_001985 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES3.shaders.uniform_block.single_stru" + "ct_array.single_buffer_std140_instance_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles30002TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles30002TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles30002TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles30002TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles30002TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_001985 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_001985 end"; +} -- GitLab