From a5ca8cf4ad0f5812104bcad3a358511f0976ca82 Mon Sep 17 00:00:00 2001 From: wangshi Date: Tue, 5 Jul 2022 09:17:44 +0800 Subject: [PATCH] add depq2 testcase Signed-off-by: wangshi --- .../Deqpgles2fragment_ops_depthTestCase.cpp | 238 ++++++++++++++ ...eqpgles2functions_declarationsTestCase.cpp | 184 +++++++++++ .../Deqpgles2functions_miscTestCase.cpp | 292 ++++++++++++++++++ ...les2get_uniform_multiple_basicTestCase.cpp | 184 +++++++++++ ...t_uniform_multiple_basic_arrayTestCase.cpp | 265 ++++++++++++++++ ...multiple_nested_structs_arraysTestCase.cpp | 265 ++++++++++++++++ 6 files changed, 1428 insertions(+) create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2fragment_ops_depthTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2functions_declarationsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2functions_miscTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_basicTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_basic_arrayTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_nested_structs_arraysTestCase.cpp diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2fragment_ops_depthTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2fragment_ops_depthTestCase.cpp new file mode 100644 index 000000000..c7779ea19 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2fragment_ops_depthTestCase.cpp @@ -0,0 +1,238 @@ +/* + * 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 "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20012TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20012TestSuite, TestCase_011001, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_011001 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fra" + "gment_ops.depth.cmp_always", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20012TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20012TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20012TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20012TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20012TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_011001 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_011001 end"; +} + +static HWTEST_F(ActsDeqpgles20012TestSuite, TestCase_011002, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_011002 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fra" + "gment_ops.depth.cmp_never", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20012TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20012TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20012TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20012TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20012TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_011002 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_011002 end"; +} + +static HWTEST_F(ActsDeqpgles20012TestSuite, TestCase_011003, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_011003 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fra" + "gment_ops.depth.cmp_equal", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20012TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20012TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20012TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20012TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20012TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_011003 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_011003 end"; +} + +static HWTEST_F(ActsDeqpgles20012TestSuite, TestCase_011004, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_011004 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fragm" + "ent_ops.depth.cmp_not_equal", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20012TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20012TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20012TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20012TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20012TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_011004 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_011004 end"; +} + +static HWTEST_F(ActsDeqpgles20012TestSuite, TestCase_011005, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_011005 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fragm" + "ent_ops.depth.cmp_less_than", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20012TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20012TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20012TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20012TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20012TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_011005 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_011005 end"; +} + +static HWTEST_F(ActsDeqpgles20012TestSuite, TestCase_011006, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_011006 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fragmen" + "t_ops.depth.cmp_less_or_equal", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20012TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20012TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20012TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20012TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20012TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_011006 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_011006 end"; +} + +static HWTEST_F(ActsDeqpgles20012TestSuite, TestCase_011007, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_011007 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fragme" + "nt_ops.depth.cmp_greater_than", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20012TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20012TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20012TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20012TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20012TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_011007 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_011007 end"; +} + +static HWTEST_F(ActsDeqpgles20012TestSuite, TestCase_011008, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_011008 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fragment" + "_ops.depth.cmp_greater_or_equal", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20012TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20012TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20012TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20012TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20012TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_011008 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_011008 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functions_declarationsTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functions_declarationsTestCase.cpp new file mode 100644 index 000000000..d0f76c4e3 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functions_declarationsTestCase.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 "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002089, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002089 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.functio" + "ns.declarations.void_vs_no_void_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002089 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002089 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002090, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002090 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.function" + "s.declarations.void_vs_no_void_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002090 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002090 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002091, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002091 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.funct" + "ions.declarations.in_vs_no_in_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002091 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002091 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002092, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002092 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.functi" + "ons.declarations.in_vs_no_in_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002092 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002092 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002093, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002093 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.functions.decl" + "arations.default_vs_explicit_precision_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002093 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002093 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002094, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002094 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.functions.decla" + "rations.default_vs_explicit_precision_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002094 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002094 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functions_miscTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functions_miscTestCase.cpp new file mode 100644 index 000000000..64fdc0409 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functions_miscTestCase.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 "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002159, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002159 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.fun" + "ctions.misc.multi_arg_float_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002159 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002159 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002160, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002160 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.func" + "tions.misc.multi_arg_float_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002160 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002160 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002161, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002161 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.fu" + "nctions.misc.multi_arg_int_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002161 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002161 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002162, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002162 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.fun" + "ctions.misc.multi_arg_int_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002162 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002162 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002163, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002163 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.functi" + "ons.misc.argument_eval_order_1_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002163 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002163 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002164, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002164 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.functio" + "ns.misc.argument_eval_order_1_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002164 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002164 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002165, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002165 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.functi" + "ons.misc.argument_eval_order_2_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002165 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002165 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002166, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002166 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.functio" + "ns.misc.argument_eval_order_2_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002166 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002166 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002167, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002167 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.fun" + "ctions.misc.missing_returns_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002167 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002167 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002168, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002168 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.func" + "tions.misc.missing_returns_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002168 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002168 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_basicTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_basicTestCase.cpp new file mode 100644 index 000000000..3949fb33a --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_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 "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20015TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014300, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014300 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value." + "initial.get_uniform.multiple_basic.vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014300 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014300 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014301, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014301 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.i" + "nitial.get_uniform.multiple_basic.fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014301 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014301 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014302, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014302 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value" + ".initial.get_uniform.multiple_basic.both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014302 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014302 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014620, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014620 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assign" + "ed.by_pointer.get_uniform.multiple_basic.vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014620 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014620 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014621, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014621 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigne" + "d.by_pointer.get_uniform.multiple_basic.fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014621 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014621 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014622, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014622 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assig" + "ned.by_pointer.get_uniform.multiple_basic.both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014622 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014622 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_basic_arrayTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_basic_arrayTestCase.cpp new file mode 100644 index 000000000..ef061bfa5 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_basic_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 "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20015TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014303, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014303 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.ini" + "tial.get_uniform.multiple_basic_array.vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014303 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014303 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014304, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014304 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.init" + "ial.get_uniform.multiple_basic_array.fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014304 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014304 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014305, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014305 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.in" + "itial.get_uniform.multiple_basic_array.both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014305 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014305 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014623, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014623 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "by_pointer.get_uniform.multiple_basic_array.vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014623 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014623 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014624, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014624 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.b" + "y_pointer.get_uniform.multiple_basic_array.fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014624 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014624 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014625, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014625 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned" + ".by_pointer.get_uniform.multiple_basic_array.both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014625 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014625 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014927, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014927 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned" + ".by_value.get_uniform.multiple_basic_array.vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014927 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014927 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014928, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014928 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "by_value.get_uniform.multiple_basic_array.fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014928 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014928 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014929, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014929 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigne" + "d.by_value.get_uniform.multiple_basic_array.both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014929 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014929 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_nested_structs_arraysTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_nested_structs_arraysTestCase.cpp new file mode 100644 index 000000000..1c1d74901 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2get_uniform_multiple_nested_structs_arraysTestCase.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 "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20015TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014306, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014306 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.initial." + "get_uniform.multiple_nested_structs_arrays.vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014306 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014306 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014307, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014307 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.initial.g" + "et_uniform.multiple_nested_structs_arrays.fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014307 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014307 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014308, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014308 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.initial" + ".get_uniform.multiple_nested_structs_arrays.both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014308 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014308 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014626, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014626 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_po" + "inter.get_uniform.multiple_nested_structs_arrays.vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014626 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014626 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014627, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014627 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_poi" + "nter.get_uniform.multiple_nested_structs_arrays.fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014627 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014627 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014628, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014628 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_p" + "ointer.get_uniform.multiple_nested_structs_arrays.both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014628 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014628 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014930, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014930 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_v" + "alue.get_uniform.multiple_nested_structs_arrays.vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014930 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014930 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014931, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014931 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_va" + "lue.get_uniform.multiple_nested_structs_arrays.fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014931 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014931 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014932, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014932 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_" + "value.get_uniform.multiple_nested_structs_arrays.both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014932 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014932 end"; +} -- GitLab