From eb70b7bf34a8f64ac14e00078425ce1a83fa3e80 Mon Sep 17 00:00:00 2001 From: bayanxing Date: Tue, 12 Jul 2022 22:42:57 +0800 Subject: [PATCH] add deqpgles3 Signed-off-by: bayanxing --- ...Deqpgles3all_features_fragmentTestCase.cpp | 296 +++++++++++++++++ .../Deqpgles3all_features_vertexTestCase.cpp | 304 +++++++++++++++++ ...3builtin_functions_exponentialTestCase.cpp | 248 ++++++++++++++ ...larations_invalid_declarationsTestCase.cpp | 240 ++++++++++++++ .../Deqpgles3format_unsizedTestCase.cpp | 280 ++++++++++++++++ ...les3functional_occlusion_queryTestCase.cpp | 272 +++++++++++++++ .../Deqpgles3functions_datatypesTestCase.cpp | 276 ++++++++++++++++ ...es3get_uniform_array_in_structTestCase.cpp | 228 +++++++++++++ ...pgles3get_uniform_basic_structTestCase.cpp | 228 +++++++++++++ ..._uniform_nested_structs_arraysTestCase.cpp | 228 +++++++++++++ ...es3get_uniform_struct_in_arrayTestCase.cpp | 228 +++++++++++++ ...s_do_while_constant_iterationsTestCase.cpp | 272 +++++++++++++++ ...ps_do_while_dynamic_iterationsTestCase.cpp | 272 +++++++++++++++ ...ps_do_while_uniform_iterationsTestCase.cpp | 272 +++++++++++++++ ...3loops_for_constant_iterationsTestCase.cpp | 280 ++++++++++++++++ ...s3loops_for_dynamic_iterationsTestCase.cpp | 280 ++++++++++++++++ ...s3loops_for_uniform_iterationsTestCase.cpp | 280 ++++++++++++++++ ...Deqpgles3matrix_post_incrementTestCase.cpp | 240 ++++++++++++++ ...Deqpgles3matrix_unary_additionTestCase.cpp | 240 ++++++++++++++ ...eqpgles3matrixcompmult_dynamicTestCase.cpp | 240 ++++++++++++++ .../Deqpgles3negative_api_shaderTestCase.cpp | 268 +++++++++++++++ .../Deqpgles3outerproduct_dynamicTestCase.cpp | 240 ++++++++++++++ ...processor_invalid_conditionalsTestCase.cpp | 256 ++++++++++++++ ...s3render_nested_structs_arraysTestCase.cpp | 216 ++++++++++++ .../Deqpgles3struct_localTestCase.cpp | 288 ++++++++++++++++ ...Deqpgles3swizzle_multi_channelTestCase.cpp | 276 ++++++++++++++++ ...gles3texture_functions_textureTestCase.cpp | 244 ++++++++++++++ .../Deqpgles3transpose_dynamicTestCase.cpp | 240 ++++++++++++++ .../Deqpgles3uniform_block_validTestCase.cpp | 288 ++++++++++++++++ .../Deqpgles3write_basicTestCase.cpp | 312 ++++++++++++++++++ 30 files changed, 7832 insertions(+) create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3all_features_fragmentTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3all_features_vertexTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3builtin_functions_exponentialTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3declarations_invalid_declarationsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3format_unsizedTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3functional_occlusion_queryTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3functions_datatypesTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_array_in_structTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_basic_structTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_nested_structs_arraysTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_struct_in_arrayTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_constant_iterationsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_dynamic_iterationsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_uniform_iterationsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_constant_iterationsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_dynamic_iterationsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_uniform_iterationsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrix_post_incrementTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrix_unary_additionTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrixcompmult_dynamicTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3negative_api_shaderTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3outerproduct_dynamicTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3preprocessor_invalid_conditionalsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3render_nested_structs_arraysTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3struct_localTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3swizzle_multi_channelTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3texture_functions_textureTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3transpose_dynamicTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3uniform_block_validTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles3/functional/Deqpgles3write_basicTestCase.cpp diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3all_features_fragmentTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3all_features_fragmentTestCase.cpp new file mode 100644 index 000000000..4395b31f2 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3all_features_fragmentTestCase.cpp @@ -0,0 +1,296 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30022TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021755, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.0"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021756, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.1"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021757, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.2"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021758, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.3"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021759, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.4"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021760, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.5"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021761, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.8"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021762, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.10"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021763, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.11"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021764, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.12"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021765, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.15"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021766, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.17"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021767, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.19"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021768, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.20"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021769, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.23"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021770, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.24"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021771, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.26"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021772, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.27"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021773, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.28"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021774, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.29"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021775, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.31"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021776, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.33"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021777, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.35"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021778, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.36"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021779, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.37"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021780, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.41"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021781, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.42"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021782, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.43"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021783, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.44"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021784, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.45"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021785, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.47"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021786, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.48"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021787, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.49"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021788, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.50"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021789, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.51"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021790, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.52"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021791, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.54"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021792, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.57"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021793, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.58"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021794, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.59"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021795, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.60"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021796, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.61"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021797, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.62"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021798, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.63"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021799, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.67"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021800, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.68"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021801, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.71"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021802, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.73"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021803, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.74"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021804, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.75"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021805, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.76"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021806, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.77"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021807, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.78"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021808, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.79"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021809, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.82"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021810, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.83"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021811, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.84"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021812, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.85"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021813, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.87"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021814, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.88"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021815, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.90"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021816, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.91"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021817, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.92"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021818, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.93"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021819, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.95"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021820, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.97"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021821, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.98"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021822, + "dEQP-GLES3.functional.shaders.", + "random.all_features.fragment.99"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3all_features_vertexTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3all_features_vertexTestCase.cpp new file mode 100644 index 000000000..4c0b62425 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3all_features_vertexTestCase.cpp @@ -0,0 +1,304 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30022TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021685, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.0"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021686, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.1"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021687, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.3"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021688, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.5"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021689, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.7"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021690, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.8"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021691, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.9"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021692, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.10"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021693, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.11"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021694, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.12"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021695, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.14"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021696, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.15"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021697, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.16"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021698, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.19"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021699, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.20"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021700, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.21"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021701, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.22"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021702, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.23"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021703, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.24"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021704, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.25"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021705, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.27"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021706, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.28"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021707, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.30"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021708, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.31"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021709, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.32"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021710, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.33"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021711, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.35"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021712, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.36"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021713, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.37"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021714, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.38"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021715, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.39"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021716, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.42"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021717, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.43"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021718, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.44"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021719, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.45"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021720, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.48"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021721, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.51"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021722, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.52"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021723, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.55"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021724, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.56"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021725, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.57"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021726, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.58"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021727, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.59"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021728, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.60"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021729, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.61"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021730, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.63"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021731, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.64"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021732, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.67"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021733, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.68"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021734, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.69"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021735, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.70"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021736, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.71"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021737, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.73"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021738, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.74"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021739, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.75"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021740, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.78"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021741, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.80"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021742, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.82"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021743, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.83"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021744, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.84"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021745, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.85"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021746, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.86"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021747, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.89"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021748, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.90"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021749, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.91"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021750, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.92"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021751, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.95"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021752, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.97"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021753, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.98"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021754, + "dEQP-GLES3.functional.shaders", + ".random.all_features.vertex.99"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3builtin_functions_exponentialTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3builtin_functions_exponentialTestCase.cpp new file mode 100644 index 000000000..c881c67ec --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3builtin_functions_exponentialTestCase.cpp @@ -0,0 +1,248 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30020TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019718, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.pow_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019719, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.pow_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019720, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.pow_vec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019721, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.pow_vec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019722, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.pow_vec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019723, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.pow_vec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019724, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.pow_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019725, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.pow_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019726, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.exp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019727, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.exp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019728, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.exp_vec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019729, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.exp_vec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019730, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.exp_vec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019731, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.exp_vec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019732, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.exp_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019733, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.exp_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019734, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.log_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019735, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.log_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019736, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.log_vec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019737, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.log_vec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019738, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.log_vec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019739, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.log_vec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019740, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.log_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019741, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.log_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019742, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.exp2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019743, + "dEQP-GLES3.functional.shaders.constant_expressions", + ".builtin_functions.exponential.exp2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019744, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.exp2_vec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019745, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.exp2_vec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019746, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.exp2_vec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019747, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.exp2_vec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019748, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.exp2_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019749, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.exp2_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019750, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.log2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019751, + "dEQP-GLES3.functional.shaders.constant_expressions", + ".builtin_functions.exponential.log2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019752, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.log2_vec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019753, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.log2_vec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019754, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.log2_vec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019755, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.log2_vec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019756, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.log2_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019757, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.log2_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019758, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.sqrt_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019759, + "dEQP-GLES3.functional.shaders.constant_expressions", + ".builtin_functions.exponential.sqrt_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019760, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.sqrt_vec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019761, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.sqrt_vec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019762, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.sqrt_vec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019763, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.sqrt_vec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019764, + "dEQP-GLES3.functional.shaders.constant_expressio", + "ns.builtin_functions.exponential.sqrt_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019765, + "dEQP-GLES3.functional.shaders.constant_expression", + "s.builtin_functions.exponential.sqrt_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019766, + "dEQP-GLES3.functional.shaders.constant_expressions.b", + "uiltin_functions.exponential.inversesqrt_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019767, + "dEQP-GLES3.functional.shaders.constant_expressions.bu", + "iltin_functions.exponential.inversesqrt_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019768, + "dEQP-GLES3.functional.shaders.constant_expressions.b", + "uiltin_functions.exponential.inversesqrt_vec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019769, + "dEQP-GLES3.functional.shaders.constant_expressions.bu", + "iltin_functions.exponential.inversesqrt_vec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019770, + "dEQP-GLES3.functional.shaders.constant_expressions.b", + "uiltin_functions.exponential.inversesqrt_vec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019771, + "dEQP-GLES3.functional.shaders.constant_expressions.bu", + "iltin_functions.exponential.inversesqrt_vec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019772, + "dEQP-GLES3.functional.shaders.constant_expressions.b", + "uiltin_functions.exponential.inversesqrt_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30020TestSuite, TestCase_019773, + "dEQP-GLES3.functional.shaders.constant_expressions.bu", + "iltin_functions.exponential.inversesqrt_vec4_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3declarations_invalid_declarationsTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3declarations_invalid_declarationsTestCase.cpp new file mode 100644 index 000000000..f32fb7996 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3declarations_invalid_declarationsTestCase.cpp @@ -0,0 +1,240 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30003TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002792, + "dEQP-GLES3.functional.shaders.declaratio", + "ns.invalid_declarations.in_in_vertex_main"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002793, + "dEQP-GLES3.functional.shaders.declaration", + "s.invalid_declarations.out_in_vertex_main"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002794, + "dEQP-GLES3.functional.shaders.declaration", + "s.invalid_declarations.in_in_fragment_main"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002795, + "dEQP-GLES3.functional.shaders.declarations", + ".invalid_declarations.out_in_fragment_main"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002796, + "dEQP-GLES3.functional.shaders.declarations.", + "invalid_declarations.uniform_in_vertex_main"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002797, + "dEQP-GLES3.functional.shaders.declarations.i", + "nvalid_declarations.uniform_in_fragment_main"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002798, + "dEQP-GLES3.functional.shaders.declarations.inv", + "alid_declarations.uniform_block_in_main_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002799, + "dEQP-GLES3.functional.shaders.declarations.inva", + "lid_declarations.uniform_block_in_main_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002800, + "dEQP-GLES3.functional.shaders.declaration", + "s.invalid_declarations.invariant_attribute"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002801, + "dEQP-GLES3.functional.shaders.declaratio", + "ns.invalid_declarations.invariant_uniform"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002802, + "dEQP-GLES3.functional.shaders.declarations.inval", + "id_declarations.invariant_uniform_block_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002803, + "dEQP-GLES3.functional.shaders.declarations.invali", + "d_declarations.invariant_uniform_block_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002804, + "dEQP-GLES3.functional.shaders.declarations.inval", + "id_declarations.invariant_uniform_block_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002805, + "dEQP-GLES3.functional.shaders.declarations.invali", + "d_declarations.invariant_uniform_block_2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002806, + "dEQP-GLES3.functional.shaders.declarations.invalid", + "_declarations.uniform_block_layout_qualifier_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002807, + "dEQP-GLES3.functional.shaders.declarations.invalid_", + "declarations.uniform_block_layout_qualifier_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002808, + "dEQP-GLES3.functional.shaders.declarations.invalid_dec", + "larations.uniform_block_member_layout_qualifier_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002809, + "dEQP-GLES3.functional.shaders.declarations.invalid_decl", + "arations.uniform_block_member_layout_qualifier_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002810, + "dEQP-GLES3.functional.shaders.declarations.invalid_dec", + "larations.uniform_block_nested_struct_definition_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002811, + "dEQP-GLES3.functional.shaders.declarations.invalid_decl", + "arations.uniform_block_nested_struct_definition_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002812, + "dEQP-GLES3.functional.shaders.declarations.in", + "valid_declarations.nested_uniform_block_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002813, + "dEQP-GLES3.functional.shaders.declarations.inv", + "alid_declarations.nested_uniform_block_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002814, + "dEQP-GLES3.functional.shaders.declarations.inva", + "lid_declarations.uniform_block_sampler_2d_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002815, + "dEQP-GLES3.functional.shaders.declarations.inval", + "id_declarations.uniform_block_sampler_2d_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002816, + "dEQP-GLES3.functional.shaders.declarations.inval", + "id_declarations.uniform_block_sampler_cube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002817, + "dEQP-GLES3.functional.shaders.declarations.invali", + "d_declarations.uniform_block_sampler_cube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002818, + "dEQP-GLES3.functional.shaders.declarations.invalid_dec", + "larations.uniform_block_missing_member_semicolon_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002819, + "dEQP-GLES3.functional.shaders.declarations.invalid_decl", + "arations.uniform_block_missing_member_semicolon_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002820, + "dEQP-GLES3.functional.shaders.declarations.invalid_de", + "clarations.uniform_block_missing_end_semicolon_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002821, + "dEQP-GLES3.functional.shaders.declarations.invalid_dec", + "larations.uniform_block_missing_end_semicolon_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002822, + "dEQP-GLES3.functional.shaders.declarations.invalid_dec", + "larations.uniform_block_duplicate_member_name_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002823, + "dEQP-GLES3.functional.shaders.declarations.invalid_decl", + "arations.uniform_block_duplicate_member_name_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002824, + "dEQP-GLES3.functional.shaders.declarations.invalid_dec", + "larations.uniform_block_duplicate_member_name_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002825, + "dEQP-GLES3.functional.shaders.declarations.invalid_decl", + "arations.uniform_block_duplicate_member_name_2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002826, + "dEQP-GLES3.functional.shaders.declarations.invalid_dec", + "larations.uniform_block_duplicate_member_name_3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002827, + "dEQP-GLES3.functional.shaders.declarations.invalid_decl", + "arations.uniform_block_duplicate_member_name_3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002828, + "dEQP-GLES3.functional.shaders.declarations.invalid_d", + "eclarations.uniform_block_duplicate_block_name_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002829, + "dEQP-GLES3.functional.shaders.declarations.invalid_de", + "clarations.uniform_block_duplicate_block_name_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002830, + "dEQP-GLES3.functional.shaders.declarations.invalid_decl", + "arations.uniform_block_duplicate_instance_name_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002831, + "dEQP-GLES3.functional.shaders.declarations.invalid_decla", + "rations.uniform_block_duplicate_instance_name_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002832, + "dEQP-GLES3.functional.shaders.declarations.invalid_decl", + "arations.uniform_block_duplicate_instance_name_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002833, + "dEQP-GLES3.functional.shaders.declarations.invalid_decla", + "rations.uniform_block_duplicate_instance_name_2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002834, + "dEQP-GLES3.functional.shaders.declarations.invalid_decl", + "arations.uniform_block_duplicate_instance_name_3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002835, + "dEQP-GLES3.functional.shaders.declarations.invalid_decla", + "rations.uniform_block_duplicate_instance_name_3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002836, + "dEQP-GLES3.functional.shaders.declarations.invalid_declar", + "ations.uniform_block_array_without_instance_name_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002837, + "dEQP-GLES3.functional.shaders.declarations.invalid_declara", + "tions.uniform_block_array_without_instance_name_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002838, + "dEQP-GLES3.functional.shaders.declarations.invalid_declar", + "ations.uniform_block_array_without_instance_name_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002839, + "dEQP-GLES3.functional.shaders.declarations.invalid_declara", + "tions.uniform_block_array_without_instance_name_2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002840, + "dEQP-GLES3.functional.shaders.declarations.", + "invalid_declarations.uniform_block_in_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002841, + "dEQP-GLES3.functional.shaders.declarations.i", + "nvalid_declarations.uniform_block_in_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002842, + "dEQP-GLES3.functional.shaders.declarations.i", + "nvalid_declarations.uniform_block_out_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002843, + "dEQP-GLES3.functional.shaders.declarations.in", + "valid_declarations.uniform_block_out_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002844, + "dEQP-GLES3.functional.shaders.declarations.in", + "valid_declarations.uniform_block_const_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30003TestSuite, TestCase_002845, + "dEQP-GLES3.functional.shaders.declarations.inv", + "alid_declarations.uniform_block_const_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3format_unsizedTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3format_unsizedTestCase.cpp new file mode 100644 index 000000000..c2ffcdd50 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3format_unsizedTestCase.cpp @@ -0,0 +1,280 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30022TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021823, + "dEQP-GLES3.functional.textur", + "e.format.unsized.alpha_2d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021824, + "dEQP-GLES3.functional.texture", + ".format.unsized.alpha_2d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021825, + "dEQP-GLES3.functional.texture", + ".format.unsized.alpha_cube_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021826, + "dEQP-GLES3.functional.texture.", + "format.unsized.alpha_cube_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021827, + "dEQP-GLES3.functional.texture.f", + "ormat.unsized.alpha_2d_array_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021828, + "dEQP-GLES3.functional.texture.fo", + "rmat.unsized.alpha_2d_array_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021829, + "dEQP-GLES3.functional.textur", + "e.format.unsized.alpha_3d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021830, + "dEQP-GLES3.functional.texture", + ".format.unsized.alpha_3d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021831, + "dEQP-GLES3.functional.texture.", + "format.unsized.luminance_2d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021832, + "dEQP-GLES3.functional.texture.f", + "ormat.unsized.luminance_2d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021833, + "dEQP-GLES3.functional.texture.f", + "ormat.unsized.luminance_cube_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021834, + "dEQP-GLES3.functional.texture.fo", + "rmat.unsized.luminance_cube_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021835, + "dEQP-GLES3.functional.texture.for", + "mat.unsized.luminance_2d_array_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021836, + "dEQP-GLES3.functional.texture.form", + "at.unsized.luminance_2d_array_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021837, + "dEQP-GLES3.functional.texture.", + "format.unsized.luminance_3d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021838, + "dEQP-GLES3.functional.texture.f", + "ormat.unsized.luminance_3d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021839, + "dEQP-GLES3.functional.texture.for", + "mat.unsized.luminance_alpha_2d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021840, + "dEQP-GLES3.functional.texture.form", + "at.unsized.luminance_alpha_2d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021841, + "dEQP-GLES3.functional.texture.form", + "at.unsized.luminance_alpha_cube_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021842, + "dEQP-GLES3.functional.texture.forma", + "t.unsized.luminance_alpha_cube_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021843, + "dEQP-GLES3.functional.texture.format", + ".unsized.luminance_alpha_2d_array_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021844, + "dEQP-GLES3.functional.texture.format.", + "unsized.luminance_alpha_2d_array_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021845, + "dEQP-GLES3.functional.texture.for", + "mat.unsized.luminance_alpha_3d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021846, + "dEQP-GLES3.functional.texture.form", + "at.unsized.luminance_alpha_3d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021847, + "dEQP-GLES3.functional.texture.format.u", + "nsized.rgb_unsigned_short_5_6_5_2d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021848, + "dEQP-GLES3.functional.texture.format.u", + "nsized.rgb_unsigned_short_5_6_5_2d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021849, + "dEQP-GLES3.functional.texture.format.un", + "sized.rgb_unsigned_short_5_6_5_cube_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021850, + "dEQP-GLES3.functional.texture.format.un", + "sized.rgb_unsigned_short_5_6_5_cube_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021851, + "dEQP-GLES3.functional.texture.format.unsi", + "zed.rgb_unsigned_short_5_6_5_2d_array_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021852, + "dEQP-GLES3.functional.texture.format.unsi", + "zed.rgb_unsigned_short_5_6_5_2d_array_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021853, + "dEQP-GLES3.functional.texture.format.u", + "nsized.rgb_unsigned_short_5_6_5_3d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021854, + "dEQP-GLES3.functional.texture.format.u", + "nsized.rgb_unsigned_short_5_6_5_3d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021855, + "dEQP-GLES3.functional.texture.form", + "at.unsized.rgb_unsigned_byte_2d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021856, + "dEQP-GLES3.functional.texture.forma", + "t.unsized.rgb_unsigned_byte_2d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021857, + "dEQP-GLES3.functional.texture.forma", + "t.unsized.rgb_unsigned_byte_cube_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021858, + "dEQP-GLES3.functional.texture.format", + ".unsized.rgb_unsigned_byte_cube_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021859, + "dEQP-GLES3.functional.texture.format.", + "unsized.rgb_unsigned_byte_2d_array_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021860, + "dEQP-GLES3.functional.texture.format.u", + "nsized.rgb_unsigned_byte_2d_array_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021861, + "dEQP-GLES3.functional.texture.form", + "at.unsized.rgb_unsigned_byte_3d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021862, + "dEQP-GLES3.functional.texture.forma", + "t.unsized.rgb_unsigned_byte_3d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021863, + "dEQP-GLES3.functional.texture.format.un", + "sized.rgba_unsigned_short_4_4_4_4_2d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021864, + "dEQP-GLES3.functional.texture.format.uns", + "ized.rgba_unsigned_short_4_4_4_4_2d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021865, + "dEQP-GLES3.functional.texture.format.uns", + "ized.rgba_unsigned_short_4_4_4_4_cube_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021866, + "dEQP-GLES3.functional.texture.format.unsi", + "zed.rgba_unsigned_short_4_4_4_4_cube_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021867, + "dEQP-GLES3.functional.texture.format.unsiz", + "ed.rgba_unsigned_short_4_4_4_4_2d_array_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021868, + "dEQP-GLES3.functional.texture.format.unsize", + "d.rgba_unsigned_short_4_4_4_4_2d_array_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021869, + "dEQP-GLES3.functional.texture.format.un", + "sized.rgba_unsigned_short_4_4_4_4_3d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021870, + "dEQP-GLES3.functional.texture.format.uns", + "ized.rgba_unsigned_short_4_4_4_4_3d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021871, + "dEQP-GLES3.functional.texture.format.un", + "sized.rgba_unsigned_short_5_5_5_1_2d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021872, + "dEQP-GLES3.functional.texture.format.uns", + "ized.rgba_unsigned_short_5_5_5_1_2d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021873, + "dEQP-GLES3.functional.texture.format.uns", + "ized.rgba_unsigned_short_5_5_5_1_cube_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021874, + "dEQP-GLES3.functional.texture.format.unsi", + "zed.rgba_unsigned_short_5_5_5_1_cube_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021875, + "dEQP-GLES3.functional.texture.format.unsiz", + "ed.rgba_unsigned_short_5_5_5_1_2d_array_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021876, + "dEQP-GLES3.functional.texture.format.unsize", + "d.rgba_unsigned_short_5_5_5_1_2d_array_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021877, + "dEQP-GLES3.functional.texture.format.un", + "sized.rgba_unsigned_short_5_5_5_1_3d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021878, + "dEQP-GLES3.functional.texture.format.uns", + "ized.rgba_unsigned_short_5_5_5_1_3d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021879, + "dEQP-GLES3.functional.texture.forma", + "t.unsized.rgba_unsigned_byte_2d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021880, + "dEQP-GLES3.functional.texture.forma", + "t.unsized.rgba_unsigned_byte_2d_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021881, + "dEQP-GLES3.functional.texture.format", + ".unsized.rgba_unsigned_byte_cube_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021882, + "dEQP-GLES3.functional.texture.format", + ".unsized.rgba_unsigned_byte_cube_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021883, + "dEQP-GLES3.functional.texture.format.u", + "nsized.rgba_unsigned_byte_2d_array_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021884, + "dEQP-GLES3.functional.texture.format.u", + "nsized.rgba_unsigned_byte_2d_array_npot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021885, + "dEQP-GLES3.functional.texture.forma", + "t.unsized.rgba_unsigned_byte_3d_pot"); + +static SHRINK_HWTEST_F(ActsDeqpgles30022TestSuite, TestCase_021886, + "dEQP-GLES3.functional.texture.forma", + "t.unsized.rgba_unsigned_byte_3d_npot"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3functional_occlusion_queryTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3functional_occlusion_queryTestCase.cpp new file mode 100644 index 000000000..1e6c7e423 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3functional_occlusion_queryTestCase.cpp @@ -0,0 +1,272 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30040TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039864, + "dEQP-GLES3.functional.", + "occlusion_query.scissor"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039865, + "dEQP-GLES3.functional.oc", + "clusion_query.depth_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039866, + "dEQP-GLES3.functional.oc", + "clusion_query.depth_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039867, + "dEQP-GLES3.functional.occ", + "lusion_query.stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039868, + "dEQP-GLES3.functional.occ", + "lusion_query.stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039869, + "dEQP-GLES3.functional.occlus", + "ion_query.scissor_depth_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039870, + "dEQP-GLES3.functional.occlus", + "ion_query.scissor_depth_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039871, + "dEQP-GLES3.functional.occlusi", + "on_query.scissor_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039872, + "dEQP-GLES3.functional.occlusi", + "on_query.scissor_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039873, + "dEQP-GLES3.functional.occlusio", + "n_query.depth_write_depth_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039874, + "dEQP-GLES3.functional.occlusion", + "_query.depth_write_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039875, + "dEQP-GLES3.functional.occlusion", + "_query.depth_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039876, + "dEQP-GLES3.functional.occlusion", + "_query.depth_clear_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039877, + "dEQP-GLES3.functional.occlusion", + "_query.depth_clear_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039878, + "dEQP-GLES3.functional.occlusion_", + "query.stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039879, + "dEQP-GLES3.functional.occlusion_qu", + "ery.scissor_depth_write_depth_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039880, + "dEQP-GLES3.functional.occlusion_que", + "ry.scissor_depth_write_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039881, + "dEQP-GLES3.functional.occlusion_que", + "ry.scissor_depth_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039882, + "dEQP-GLES3.functional.occlusion_que", + "ry.scissor_depth_clear_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039883, + "dEQP-GLES3.functional.occlusion_que", + "ry.scissor_depth_clear_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039884, + "dEQP-GLES3.functional.occlusion_quer", + "y.scissor_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039885, + "dEQP-GLES3.functional.occlusion_query", + ".depth_write_depth_clear_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039886, + "dEQP-GLES3.functional.occlusion_query", + ".depth_write_depth_clear_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039887, + "dEQP-GLES3.functional.occlusion_query.", + "depth_write_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039888, + "dEQP-GLES3.functional.occlusion_query.", + "depth_clear_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039889, + "dEQP-GLES3.functional.occlusion_query.sci", + "ssor_depth_write_depth_clear_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039890, + "dEQP-GLES3.functional.occlusion_query.sci", + "ssor_depth_write_depth_clear_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039891, + "dEQP-GLES3.functional.occlusion_query.scis", + "sor_depth_write_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039892, + "dEQP-GLES3.functional.occlusion_query.scis", + "sor_depth_clear_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039893, + "dEQP-GLES3.functional.occlusion_query.depth_", + "write_depth_clear_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039894, + "dEQP-GLES3.functional.occ", + "lusion_query.all_occluders"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039895, + "dEQP-GLES3.functional.occlusi", + "on_query.conservative_scissor"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039896, + "dEQP-GLES3.functional.occlusion", + "_query.conservative_depth_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039897, + "dEQP-GLES3.functional.occlusion", + "_query.conservative_depth_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039898, + "dEQP-GLES3.functional.occlusion_", + "query.conservative_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039899, + "dEQP-GLES3.functional.occlusion_", + "query.conservative_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039900, + "dEQP-GLES3.functional.occlusion_que", + "ry.conservative_scissor_depth_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039901, + "dEQP-GLES3.functional.occlusion_que", + "ry.conservative_scissor_depth_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039902, + "dEQP-GLES3.functional.occlusion_quer", + "y.conservative_scissor_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039903, + "dEQP-GLES3.functional.occlusion_quer", + "y.conservative_scissor_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039904, + "dEQP-GLES3.functional.occlusion_query", + ".conservative_depth_write_depth_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039905, + "dEQP-GLES3.functional.occlusion_query.", + "conservative_depth_write_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039906, + "dEQP-GLES3.functional.occlusion_query.", + "conservative_depth_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039907, + "dEQP-GLES3.functional.occlusion_query.", + "conservative_depth_clear_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039908, + "dEQP-GLES3.functional.occlusion_query.", + "conservative_depth_clear_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039909, + "dEQP-GLES3.functional.occlusion_query.c", + "onservative_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039910, + "dEQP-GLES3.functional.occlusion_query.con", + "servative_scissor_depth_write_depth_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039911, + "dEQP-GLES3.functional.occlusion_query.cons", + "ervative_scissor_depth_write_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039912, + "dEQP-GLES3.functional.occlusion_query.cons", + "ervative_scissor_depth_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039913, + "dEQP-GLES3.functional.occlusion_query.cons", + "ervative_scissor_depth_clear_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039914, + "dEQP-GLES3.functional.occlusion_query.cons", + "ervative_scissor_depth_clear_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039915, + "dEQP-GLES3.functional.occlusion_query.conse", + "rvative_scissor_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039916, + "dEQP-GLES3.functional.occlusion_query.conser", + "vative_depth_write_depth_clear_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039917, + "dEQP-GLES3.functional.occlusion_query.conser", + "vative_depth_write_depth_clear_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039918, + "dEQP-GLES3.functional.occlusion_query.conserv", + "ative_depth_write_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039919, + "dEQP-GLES3.functional.occlusion_query.conserv", + "ative_depth_clear_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039920, + "dEQP-GLES3.functional.occlusion_query.conservati", + "ve_scissor_depth_write_depth_clear_stencil_write"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039921, + "dEQP-GLES3.functional.occlusion_query.conservati", + "ve_scissor_depth_write_depth_clear_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039922, + "dEQP-GLES3.functional.occlusion_query.conservativ", + "e_scissor_depth_write_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039923, + "dEQP-GLES3.functional.occlusion_query.conservativ", + "e_scissor_depth_clear_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039924, + "dEQP-GLES3.functional.occlusion_query.conservative_", + "depth_write_depth_clear_stencil_write_stencil_clear"); + +static SHRINK_HWTEST_F(ActsDeqpgles30040TestSuite, TestCase_039925, + "dEQP-GLES3.functional.occlusion_", + "query.conservative_all_occluders"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3functions_datatypesTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3functions_datatypesTestCase.cpp new file mode 100644 index 000000000..06d415dc7 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3functions_datatypesTestCase.cpp @@ -0,0 +1,276 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30005TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004038, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.float_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004039, + "dEQP-GLES3.functional.shaders.funct", + "ions.datatypes.float_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004040, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.float_vec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004041, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.float_vec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004042, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.float_vec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004043, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.float_vec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004044, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004045, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004046, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.float_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004047, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.float_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004048, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.float_mat3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004049, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.float_mat3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004050, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.float_mat4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004051, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.float_mat4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004052, + "dEQP-GLES3.functional.shaders.fu", + "nctions.datatypes.int_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004053, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.int_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004054, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.int_ivec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004055, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.int_ivec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004056, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.int_ivec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004057, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.int_ivec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004058, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004059, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004060, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.uint_uint_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004061, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.uint_uint_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004062, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.uint_uvec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004063, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.uint_uvec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004064, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.uint_uvec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004065, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.uint_uvec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004066, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004067, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004068, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.bool_bool_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004069, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.bool_bool_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004070, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.bool_bvec2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004071, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.bool_bvec2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004072, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.bool_bvec3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004073, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.bool_bvec3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004074, + "dEQP-GLES3.functional.shaders.fun", + "ctions.datatypes.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004075, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004076, + "dEQP-GLES3.functional.shaders.", + "functions.datatypes.mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004077, + "dEQP-GLES3.functional.shaders.f", + "unctions.datatypes.mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004078, + "dEQP-GLES3.functional.shaders.f", + "unctions.datatypes.mat2x3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004079, + "dEQP-GLES3.functional.shaders.fu", + "nctions.datatypes.mat2x3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004080, + "dEQP-GLES3.functional.shaders.f", + "unctions.datatypes.mat2x4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004081, + "dEQP-GLES3.functional.shaders.fu", + "nctions.datatypes.mat2x4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004082, + "dEQP-GLES3.functional.shaders.f", + "unctions.datatypes.mat3x2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004083, + "dEQP-GLES3.functional.shaders.fu", + "nctions.datatypes.mat3x2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004084, + "dEQP-GLES3.functional.shaders.", + "functions.datatypes.mat3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004085, + "dEQP-GLES3.functional.shaders.f", + "unctions.datatypes.mat3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004086, + "dEQP-GLES3.functional.shaders.f", + "unctions.datatypes.mat3x4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004087, + "dEQP-GLES3.functional.shaders.fu", + "nctions.datatypes.mat3x4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004088, + "dEQP-GLES3.functional.shaders.f", + "unctions.datatypes.mat4x2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004089, + "dEQP-GLES3.functional.shaders.fu", + "nctions.datatypes.mat4x2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004090, + "dEQP-GLES3.functional.shaders.f", + "unctions.datatypes.mat4x3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004091, + "dEQP-GLES3.functional.shaders.fu", + "nctions.datatypes.mat4x3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004092, + "dEQP-GLES3.functional.shaders.", + "functions.datatypes.mat4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004093, + "dEQP-GLES3.functional.shaders.f", + "unctions.datatypes.mat4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004094, + "dEQP-GLES3.functional.shaders.func", + "tions.datatypes.float_struct_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004095, + "dEQP-GLES3.functional.shaders.funct", + "ions.datatypes.float_struct_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004096, + "dEQP-GLES3.functional.shaders.funct", + "ions.datatypes.struct_struct_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004097, + "dEQP-GLES3.functional.shaders.functi", + "ons.datatypes.struct_struct_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004098, + "dEQP-GLES3.functional.shaders.function", + "s.datatypes.struct_nested_struct_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004099, + "dEQP-GLES3.functional.shaders.functions", + ".datatypes.struct_nested_struct_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30005TestSuite, TestCase_004100, + "dEQP-GLES3.functional.shaders.functions.dat", + "atypes.struct_constructor_highp_in_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_array_in_structTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_array_in_structTestCase.cpp new file mode 100644 index 000000000..786b6ca17 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_array_in_structTestCase.cpp @@ -0,0 +1,228 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30038TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037084, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.array_in_struct.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037085, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.array_in_struct.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037086, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.array_in_struct.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037087, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.array_in_struct.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037088, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.array_in_struct.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037089, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.array_in_struct.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037090, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.array_in_struct.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037091, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.array_in_struct.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037092, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.array_in_struct.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037093, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.array_in_struct.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037094, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.array_in_struct.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037095, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.array_in_struct.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037096, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.array_in_struct.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037097, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.array_in_struct.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037098, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.array_in_struct.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037099, + "dEQP-GLES3.functional.uniform_api.value.initial.get_", + "uniform.array_in_struct.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037100, + "dEQP-GLES3.functional.uniform_api.value.initial.get_u", + "niform.array_in_struct.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037101, + "dEQP-GLES3.functional.uniform_api.value.initial.get", + "_uniform.array_in_struct.sampler2D_samplerCube_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037567, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.array_in_struct.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037568, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.array_in_struct.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037569, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.array_in_struct.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037570, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.array_in_struct.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037571, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.array_in_struct.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037572, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.array_in_struct.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037573, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.array_in_struct.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037574, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.array_in_struct.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037575, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.array_in_struct.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037576, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.array_in_struct.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037577, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.array_in_struct.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037578, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.array_in_struct.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037579, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.array_in_struct.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037580, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.array_in_struct.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037581, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.array_in_struct.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037582, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_pointe", + "r.get_uniform.array_in_struct.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037583, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_pointer", + ".get_uniform.array_in_struct.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037584, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_point", + "er.get_uniform.array_in_struct.sampler2D_samplerCube_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038020, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.array_in_struct.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038021, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.get_uniform.array_in_struct.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038022, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.array_in_struct.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038023, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.array_in_struct.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038024, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.get_uniform.array_in_struct.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038025, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.array_in_struct.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038026, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.array_in_struct.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038027, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.get_uniform.array_in_struct.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038028, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.array_in_struct.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038029, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.array_in_struct.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038030, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.get_uniform.array_in_struct.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038031, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.array_in_struct.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038032, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_value", + ".get_uniform.array_in_struct.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038033, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_value.", + "get_uniform.array_in_struct.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038034, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_valu", + "e.get_uniform.array_in_struct.sampler2D_samplerCube_both"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_basic_structTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_basic_structTestCase.cpp new file mode 100644 index 000000000..1589c2c73 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_basic_structTestCase.cpp @@ -0,0 +1,228 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30038TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037048, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.basic_struct.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037049, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.basic_struct.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037050, + "dEQP-GLES3.functional.uniform_api.value.init", + "ial.get_uniform.basic_struct.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037051, + "dEQP-GLES3.functional.uniform_api.value.init", + "ial.get_uniform.basic_struct.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037052, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.basic_struct.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037053, + "dEQP-GLES3.functional.uniform_api.value.ini", + "tial.get_uniform.basic_struct.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037054, + "dEQP-GLES3.functional.uniform_api.value.init", + "ial.get_uniform.basic_struct.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037055, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.basic_struct.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037056, + "dEQP-GLES3.functional.uniform_api.value.ini", + "tial.get_uniform.basic_struct.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037057, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.basic_struct.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037058, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.basic_struct.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037059, + "dEQP-GLES3.functional.uniform_api.value.init", + "ial.get_uniform.basic_struct.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037060, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.basic_struct.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037061, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.basic_struct.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037062, + "dEQP-GLES3.functional.uniform_api.value.init", + "ial.get_uniform.basic_struct.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037063, + "dEQP-GLES3.functional.uniform_api.value.initial.ge", + "t_uniform.basic_struct.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037064, + "dEQP-GLES3.functional.uniform_api.value.initial.get", + "_uniform.basic_struct.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037065, + "dEQP-GLES3.functional.uniform_api.value.initial.g", + "et_uniform.basic_struct.sampler2D_samplerCube_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037531, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.basic_struct.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037532, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.basic_struct.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037533, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_pointer.get_uniform.basic_struct.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037534, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_pointer.get_uniform.basic_struct.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037535, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.basic_struct.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037536, + "dEQP-GLES3.functional.uniform_api.value.assigned.", + "by_pointer.get_uniform.basic_struct.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037537, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_pointer.get_uniform.basic_struct.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037538, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.basic_struct.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037539, + "dEQP-GLES3.functional.uniform_api.value.assigned.", + "by_pointer.get_uniform.basic_struct.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037540, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.basic_struct.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037541, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.basic_struct.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037542, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_pointer.get_uniform.basic_struct.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037543, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.basic_struct.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037544, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.basic_struct.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037545, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_pointer.get_uniform.basic_struct.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037546, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poin", + "ter.get_uniform.basic_struct.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037547, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_point", + "er.get_uniform.basic_struct.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037548, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poi", + "nter.get_uniform.basic_struct.sampler2D_samplerCube_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037990, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.basic_struct.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037991, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.basic_struct.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037992, + "dEQP-GLES3.functional.uniform_api.value.assigned.", + "by_value.get_uniform.basic_struct.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037993, + "dEQP-GLES3.functional.uniform_api.value.assigned.", + "by_value.get_uniform.basic_struct.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037994, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.basic_struct.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037995, + "dEQP-GLES3.functional.uniform_api.value.assigned", + ".by_value.get_uniform.basic_struct.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037996, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.basic_struct.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037997, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.basic_struct.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037998, + "dEQP-GLES3.functional.uniform_api.value.assigned.", + "by_value.get_uniform.basic_struct.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037999, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.basic_struct.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038000, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.basic_struct.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038001, + "dEQP-GLES3.functional.uniform_api.value.assigned.", + "by_value.get_uniform.basic_struct.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038002, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_val", + "ue.get_uniform.basic_struct.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038003, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_valu", + "e.get_uniform.basic_struct.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038004, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_va", + "lue.get_uniform.basic_struct.sampler2D_samplerCube_both"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_nested_structs_arraysTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_nested_structs_arraysTestCase.cpp new file mode 100644 index 000000000..9f55a2b56 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_nested_structs_arraysTestCase.cpp @@ -0,0 +1,228 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30038TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037102, + "dEQP-GLES3.functional.uniform_api.value.initial.g", + "et_uniform.nested_structs_arrays.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037103, + "dEQP-GLES3.functional.uniform_api.value.initial.ge", + "t_uniform.nested_structs_arrays.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037104, + "dEQP-GLES3.functional.uniform_api.value.initial.", + "get_uniform.nested_structs_arrays.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037105, + "dEQP-GLES3.functional.uniform_api.value.initial.g", + "et_uniform.nested_structs_arrays.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037106, + "dEQP-GLES3.functional.uniform_api.value.initial.ge", + "t_uniform.nested_structs_arrays.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037107, + "dEQP-GLES3.functional.uniform_api.value.initial.", + "get_uniform.nested_structs_arrays.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037108, + "dEQP-GLES3.functional.uniform_api.value.initial.g", + "et_uniform.nested_structs_arrays.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037109, + "dEQP-GLES3.functional.uniform_api.value.initial.ge", + "t_uniform.nested_structs_arrays.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037110, + "dEQP-GLES3.functional.uniform_api.value.initial.", + "get_uniform.nested_structs_arrays.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037111, + "dEQP-GLES3.functional.uniform_api.value.initial.g", + "et_uniform.nested_structs_arrays.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037112, + "dEQP-GLES3.functional.uniform_api.value.initial.ge", + "t_uniform.nested_structs_arrays.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037113, + "dEQP-GLES3.functional.uniform_api.value.initial.", + "get_uniform.nested_structs_arrays.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037114, + "dEQP-GLES3.functional.uniform_api.value.initial.g", + "et_uniform.nested_structs_arrays.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037115, + "dEQP-GLES3.functional.uniform_api.value.initial.ge", + "t_uniform.nested_structs_arrays.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037116, + "dEQP-GLES3.functional.uniform_api.value.initial.", + "get_uniform.nested_structs_arrays.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037117, + "dEQP-GLES3.functional.uniform_api.value.initial.get_uni", + "form.nested_structs_arrays.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037118, + "dEQP-GLES3.functional.uniform_api.value.initial.get_unif", + "orm.nested_structs_arrays.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037119, + "dEQP-GLES3.functional.uniform_api.value.initial.get_un", + "iform.nested_structs_arrays.sampler2D_samplerCube_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037585, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poi", + "nter.get_uniform.nested_structs_arrays.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037586, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poin", + "ter.get_uniform.nested_structs_arrays.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037587, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_po", + "inter.get_uniform.nested_structs_arrays.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037588, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poi", + "nter.get_uniform.nested_structs_arrays.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037589, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poin", + "ter.get_uniform.nested_structs_arrays.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037590, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_po", + "inter.get_uniform.nested_structs_arrays.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037591, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poi", + "nter.get_uniform.nested_structs_arrays.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037592, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poin", + "ter.get_uniform.nested_structs_arrays.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037593, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_po", + "inter.get_uniform.nested_structs_arrays.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037594, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poi", + "nter.get_uniform.nested_structs_arrays.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037595, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poin", + "ter.get_uniform.nested_structs_arrays.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037596, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_po", + "inter.get_uniform.nested_structs_arrays.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037597, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poi", + "nter.get_uniform.nested_structs_arrays.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037598, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_poin", + "ter.get_uniform.nested_structs_arrays.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037599, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_po", + "inter.get_uniform.nested_structs_arrays.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037600, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_pointer.g", + "et_uniform.nested_structs_arrays.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037601, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_pointer.ge", + "t_uniform.nested_structs_arrays.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037602, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_pointer.", + "get_uniform.nested_structs_arrays.sampler2D_samplerCube_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038035, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_va", + "lue.get_uniform.nested_structs_arrays.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038036, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_val", + "ue.get_uniform.nested_structs_arrays.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038037, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_v", + "alue.get_uniform.nested_structs_arrays.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038038, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_va", + "lue.get_uniform.nested_structs_arrays.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038039, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_val", + "ue.get_uniform.nested_structs_arrays.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038040, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_v", + "alue.get_uniform.nested_structs_arrays.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038041, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_va", + "lue.get_uniform.nested_structs_arrays.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038042, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_val", + "ue.get_uniform.nested_structs_arrays.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038043, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_v", + "alue.get_uniform.nested_structs_arrays.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038044, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_va", + "lue.get_uniform.nested_structs_arrays.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038045, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_val", + "ue.get_uniform.nested_structs_arrays.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038046, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_v", + "alue.get_uniform.nested_structs_arrays.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038047, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_value.ge", + "t_uniform.nested_structs_arrays.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038048, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_value.get", + "_uniform.nested_structs_arrays.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038049, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_value.g", + "et_uniform.nested_structs_arrays.sampler2D_samplerCube_both"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_struct_in_arrayTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_struct_in_arrayTestCase.cpp new file mode 100644 index 000000000..393e2ebd6 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3get_uniform_struct_in_arrayTestCase.cpp @@ -0,0 +1,228 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30038TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037066, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.struct_in_array.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037067, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.struct_in_array.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037068, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.struct_in_array.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037069, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.struct_in_array.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037070, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.struct_in_array.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037071, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.struct_in_array.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037072, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.struct_in_array.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037073, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.struct_in_array.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037074, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.struct_in_array.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037075, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.struct_in_array.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037076, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.struct_in_array.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037077, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.struct_in_array.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037078, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.get_uniform.struct_in_array.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037079, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".get_uniform.struct_in_array.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037080, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.get_uniform.struct_in_array.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037081, + "dEQP-GLES3.functional.uniform_api.value.initial.get_", + "uniform.struct_in_array.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037082, + "dEQP-GLES3.functional.uniform_api.value.initial.get_u", + "niform.struct_in_array.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037083, + "dEQP-GLES3.functional.uniform_api.value.initial.get", + "_uniform.struct_in_array.sampler2D_samplerCube_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037549, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.struct_in_array.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037550, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.struct_in_array.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037551, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.struct_in_array.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037552, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.struct_in_array.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037553, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.struct_in_array.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037554, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.struct_in_array.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037555, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.struct_in_array.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037556, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.struct_in_array.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037557, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.struct_in_array.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037558, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.struct_in_array.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037559, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.struct_in_array.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037560, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.struct_in_array.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037561, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.get_uniform.struct_in_array.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037562, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.get_uniform.struct_in_array.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037563, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.get_uniform.struct_in_array.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037564, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_pointe", + "r.get_uniform.struct_in_array.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037565, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_pointer", + ".get_uniform.struct_in_array.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037566, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_point", + "er.get_uniform.struct_in_array.sampler2D_samplerCube_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038005, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.struct_in_array.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038006, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.get_uniform.struct_in_array.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038007, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.struct_in_array.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038008, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.struct_in_array.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038009, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.get_uniform.struct_in_array.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038010, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.struct_in_array.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038011, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.struct_in_array.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038012, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.get_uniform.struct_in_array.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038013, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.struct_in_array.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038014, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.get_uniform.struct_in_array.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038015, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.get_uniform.struct_in_array.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038016, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.get_uniform.struct_in_array.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038017, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_value", + ".get_uniform.struct_in_array.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038018, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_value.", + "get_uniform.struct_in_array.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038019, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_valu", + "e.get_uniform.struct_in_array.sampler2D_samplerCube_both"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_constant_iterationsTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_constant_iterationsTestCase.cpp new file mode 100644 index 000000000..e61a3a90b --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_constant_iterationsTestCase.cpp @@ -0,0 +1,272 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30008TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007091, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_constant_iterations.basic_lowp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007092, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.basic_lowp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007093, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.basic_lowp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007094, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.basic_lowp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007095, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.basic_mediump_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007096, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.basic_mediump_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007097, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.basic_mediump_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007098, + "dEQP-GLES3.functional.shaders.loops.do_while_c", + "onstant_iterations.basic_mediump_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007099, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_constant_iterations.basic_highp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007100, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.basic_highp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007101, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.basic_highp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007102, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.basic_highp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007103, + "dEQP-GLES3.functional.shaders.loops.do_wh", + "ile_constant_iterations.empty_body_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007104, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_constant_iterations.empty_body_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007105, + "dEQP-GLES3.functional.shaders.loops.do_while_constant_i", + "terations.infinite_with_unconditional_break_first_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007106, + "dEQP-GLES3.functional.shaders.loops.do_while_constant_it", + "erations.infinite_with_unconditional_break_first_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007107, + "dEQP-GLES3.functional.shaders.loops.do_while_constant_i", + "terations.infinite_with_unconditional_break_last_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007108, + "dEQP-GLES3.functional.shaders.loops.do_while_constant_it", + "erations.infinite_with_unconditional_break_last_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007109, + "dEQP-GLES3.functional.shaders.loops.do_while_consta", + "nt_iterations.infinite_with_conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007110, + "dEQP-GLES3.functional.shaders.loops.do_while_constan", + "t_iterations.infinite_with_conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007111, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.single_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007112, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.single_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007113, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.compound_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007114, + "dEQP-GLES3.functional.shaders.loops.do_while_c", + "onstant_iterations.compound_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007115, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.sequence_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007116, + "dEQP-GLES3.functional.shaders.loops.do_while_c", + "onstant_iterations.sequence_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007117, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.single_iteration_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007118, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.single_iteration_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007119, + "dEQP-GLES3.functional.shaders.loops.do_while_co", + "nstant_iterations.select_iteration_count_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007120, + "dEQP-GLES3.functional.shaders.loops.do_while_con", + "stant_iterations.select_iteration_count_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007121, + "dEQP-GLES3.functional.shaders.loops.do_while_c", + "onstant_iterations.conditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007122, + "dEQP-GLES3.functional.shaders.loops.do_while_co", + "nstant_iterations.conditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007123, + "dEQP-GLES3.functional.shaders.loops.do_while_co", + "nstant_iterations.unconditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007124, + "dEQP-GLES3.functional.shaders.loops.do_while_con", + "stant_iterations.unconditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007125, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_constant_iterations.only_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007126, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_constant_iterations.only_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007127, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_constant_iterations.double_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007128, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.double_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007129, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007130, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007131, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "constant_iterations.unconditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007132, + "dEQP-GLES3.functional.shaders.loops.do_while_c", + "onstant_iterations.unconditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007133, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_constant_iterations.pre_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007134, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_constant_iterations.pre_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007135, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_constant_iterations.post_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007136, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.post_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007137, + "dEQP-GLES3.functional.shaders.loops.do_while_c", + "onstant_iterations.mixed_break_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007138, + "dEQP-GLES3.functional.shaders.loops.do_while_co", + "nstant_iterations.mixed_break_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007139, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_constant_iterations.vector_counter_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007140, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.vector_counter_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007141, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_constant_iterations.101_iterations_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007142, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.101_iterations_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007143, + "dEQP-GLES3.functional.shaders.loops.do_w", + "hile_constant_iterations.sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007144, + "dEQP-GLES3.functional.shaders.loops.do_wh", + "ile_constant_iterations.sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007145, + "dEQP-GLES3.functional.shaders.loops.do_", + "while_constant_iterations.nested_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007146, + "dEQP-GLES3.functional.shaders.loops.do_w", + "hile_constant_iterations.nested_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007147, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_constant_iterations.nested_sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007148, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_constant_iterations.nested_sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007149, + "dEQP-GLES3.functional.shaders.loops.do_while_con", + "stant_iterations.nested_tricky_dataflow_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007150, + "dEQP-GLES3.functional.shaders.loops.do_while_cons", + "tant_iterations.nested_tricky_dataflow_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007151, + "dEQP-GLES3.functional.shaders.loops.do_while_con", + "stant_iterations.nested_tricky_dataflow_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007152, + "dEQP-GLES3.functional.shaders.loops.do_while_cons", + "tant_iterations.nested_tricky_dataflow_2_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_dynamic_iterationsTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_dynamic_iterationsTestCase.cpp new file mode 100644 index 000000000..458b7be24 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_dynamic_iterationsTestCase.cpp @@ -0,0 +1,272 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30008TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007215, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_dynamic_iterations.basic_lowp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007216, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.basic_lowp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007217, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.basic_lowp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007218, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.basic_lowp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007219, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.basic_mediump_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007220, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "dynamic_iterations.basic_mediump_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007221, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "dynamic_iterations.basic_mediump_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007222, + "dEQP-GLES3.functional.shaders.loops.do_while_d", + "ynamic_iterations.basic_mediump_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007223, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.basic_highp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007224, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.basic_highp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007225, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.basic_highp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007226, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "dynamic_iterations.basic_highp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007227, + "dEQP-GLES3.functional.shaders.loops.do_w", + "hile_dynamic_iterations.empty_body_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007228, + "dEQP-GLES3.functional.shaders.loops.do_wh", + "ile_dynamic_iterations.empty_body_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007229, + "dEQP-GLES3.functional.shaders.loops.do_while_dynamic_it", + "erations.infinite_with_unconditional_break_first_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007230, + "dEQP-GLES3.functional.shaders.loops.do_while_dynamic_ite", + "rations.infinite_with_unconditional_break_first_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007231, + "dEQP-GLES3.functional.shaders.loops.do_while_dynamic_i", + "terations.infinite_with_unconditional_break_last_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007232, + "dEQP-GLES3.functional.shaders.loops.do_while_dynamic_it", + "erations.infinite_with_unconditional_break_last_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007233, + "dEQP-GLES3.functional.shaders.loops.do_while_dynami", + "c_iterations.infinite_with_conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007234, + "dEQP-GLES3.functional.shaders.loops.do_while_dynamic", + "_iterations.infinite_with_conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007235, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.single_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007236, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.single_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007237, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.compound_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007238, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "dynamic_iterations.compound_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007239, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.sequence_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007240, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "dynamic_iterations.sequence_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007241, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.single_iteration_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007242, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.single_iteration_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007243, + "dEQP-GLES3.functional.shaders.loops.do_while_d", + "ynamic_iterations.select_iteration_count_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007244, + "dEQP-GLES3.functional.shaders.loops.do_while_dy", + "namic_iterations.select_iteration_count_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007245, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "dynamic_iterations.conditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007246, + "dEQP-GLES3.functional.shaders.loops.do_while_d", + "ynamic_iterations.conditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007247, + "dEQP-GLES3.functional.shaders.loops.do_while_d", + "ynamic_iterations.unconditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007248, + "dEQP-GLES3.functional.shaders.loops.do_while_dy", + "namic_iterations.unconditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007249, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_dynamic_iterations.only_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007250, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.only_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007251, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.double_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007252, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.double_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007253, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007254, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "dynamic_iterations.conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007255, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "dynamic_iterations.unconditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007256, + "dEQP-GLES3.functional.shaders.loops.do_while_d", + "ynamic_iterations.unconditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007257, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_dynamic_iterations.pre_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007258, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.pre_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007259, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_dynamic_iterations.post_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007260, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.post_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007261, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "dynamic_iterations.mixed_break_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007262, + "dEQP-GLES3.functional.shaders.loops.do_while_d", + "ynamic_iterations.mixed_break_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007263, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_dynamic_iterations.vector_counter_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007264, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.vector_counter_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007265, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_dynamic_iterations.101_iterations_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007266, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.101_iterations_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007267, + "dEQP-GLES3.functional.shaders.loops.do_", + "while_dynamic_iterations.sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007268, + "dEQP-GLES3.functional.shaders.loops.do_w", + "hile_dynamic_iterations.sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007269, + "dEQP-GLES3.functional.shaders.loops.do", + "_while_dynamic_iterations.nested_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007270, + "dEQP-GLES3.functional.shaders.loops.do_", + "while_dynamic_iterations.nested_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007271, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_dynamic_iterations.nested_sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007272, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_dynamic_iterations.nested_sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007273, + "dEQP-GLES3.functional.shaders.loops.do_while_dy", + "namic_iterations.nested_tricky_dataflow_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007274, + "dEQP-GLES3.functional.shaders.loops.do_while_dyn", + "amic_iterations.nested_tricky_dataflow_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007275, + "dEQP-GLES3.functional.shaders.loops.do_while_dy", + "namic_iterations.nested_tricky_dataflow_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007276, + "dEQP-GLES3.functional.shaders.loops.do_while_dyn", + "amic_iterations.nested_tricky_dataflow_2_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_uniform_iterationsTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_uniform_iterationsTestCase.cpp new file mode 100644 index 000000000..61a331f09 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_do_while_uniform_iterationsTestCase.cpp @@ -0,0 +1,272 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30008TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007153, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_uniform_iterations.basic_lowp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007154, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.basic_lowp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007155, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.basic_lowp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007156, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.basic_lowp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007157, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.basic_mediump_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007158, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "uniform_iterations.basic_mediump_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007159, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "uniform_iterations.basic_mediump_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007160, + "dEQP-GLES3.functional.shaders.loops.do_while_u", + "niform_iterations.basic_mediump_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007161, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.basic_highp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007162, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.basic_highp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007163, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.basic_highp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007164, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "uniform_iterations.basic_highp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007165, + "dEQP-GLES3.functional.shaders.loops.do_w", + "hile_uniform_iterations.empty_body_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007166, + "dEQP-GLES3.functional.shaders.loops.do_wh", + "ile_uniform_iterations.empty_body_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007167, + "dEQP-GLES3.functional.shaders.loops.do_while_uniform_it", + "erations.infinite_with_unconditional_break_first_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007168, + "dEQP-GLES3.functional.shaders.loops.do_while_uniform_ite", + "rations.infinite_with_unconditional_break_first_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007169, + "dEQP-GLES3.functional.shaders.loops.do_while_uniform_i", + "terations.infinite_with_unconditional_break_last_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007170, + "dEQP-GLES3.functional.shaders.loops.do_while_uniform_it", + "erations.infinite_with_unconditional_break_last_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007171, + "dEQP-GLES3.functional.shaders.loops.do_while_unifor", + "m_iterations.infinite_with_conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007172, + "dEQP-GLES3.functional.shaders.loops.do_while_uniform", + "_iterations.infinite_with_conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007173, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.single_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007174, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.single_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007175, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.compound_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007176, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "uniform_iterations.compound_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007177, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.sequence_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007178, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "uniform_iterations.sequence_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007179, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.single_iteration_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007180, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.single_iteration_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007181, + "dEQP-GLES3.functional.shaders.loops.do_while_u", + "niform_iterations.select_iteration_count_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007182, + "dEQP-GLES3.functional.shaders.loops.do_while_un", + "iform_iterations.select_iteration_count_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007183, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "uniform_iterations.conditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007184, + "dEQP-GLES3.functional.shaders.loops.do_while_u", + "niform_iterations.conditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007185, + "dEQP-GLES3.functional.shaders.loops.do_while_u", + "niform_iterations.unconditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007186, + "dEQP-GLES3.functional.shaders.loops.do_while_un", + "iform_iterations.unconditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007187, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_uniform_iterations.only_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007188, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.only_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007189, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.double_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007190, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.double_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007191, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007192, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "uniform_iterations.conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007193, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "uniform_iterations.unconditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007194, + "dEQP-GLES3.functional.shaders.loops.do_while_u", + "niform_iterations.unconditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007195, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_uniform_iterations.pre_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007196, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.pre_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007197, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_uniform_iterations.post_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007198, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.post_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007199, + "dEQP-GLES3.functional.shaders.loops.do_while_", + "uniform_iterations.mixed_break_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007200, + "dEQP-GLES3.functional.shaders.loops.do_while_u", + "niform_iterations.mixed_break_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007201, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_uniform_iterations.vector_counter_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007202, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.vector_counter_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007203, + "dEQP-GLES3.functional.shaders.loops.do_whi", + "le_uniform_iterations.101_iterations_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007204, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.101_iterations_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007205, + "dEQP-GLES3.functional.shaders.loops.do_", + "while_uniform_iterations.sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007206, + "dEQP-GLES3.functional.shaders.loops.do_w", + "hile_uniform_iterations.sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007207, + "dEQP-GLES3.functional.shaders.loops.do", + "_while_uniform_iterations.nested_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007208, + "dEQP-GLES3.functional.shaders.loops.do_", + "while_uniform_iterations.nested_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007209, + "dEQP-GLES3.functional.shaders.loops.do_whil", + "e_uniform_iterations.nested_sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007210, + "dEQP-GLES3.functional.shaders.loops.do_while", + "_uniform_iterations.nested_sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007211, + "dEQP-GLES3.functional.shaders.loops.do_while_un", + "iform_iterations.nested_tricky_dataflow_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007212, + "dEQP-GLES3.functional.shaders.loops.do_while_uni", + "form_iterations.nested_tricky_dataflow_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007213, + "dEQP-GLES3.functional.shaders.loops.do_while_un", + "iform_iterations.nested_tricky_dataflow_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30008TestSuite, TestCase_007214, + "dEQP-GLES3.functional.shaders.loops.do_while_uni", + "form_iterations.nested_tricky_dataflow_2_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_constant_iterationsTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_constant_iterationsTestCase.cpp new file mode 100644 index 000000000..919f2cd50 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_constant_iterationsTestCase.cpp @@ -0,0 +1,280 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30007TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006707, + "dEQP-GLES3.functional.shaders.loops.for_", + "constant_iterations.basic_lowp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006708, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.basic_lowp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006709, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.basic_lowp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006710, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.basic_lowp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006711, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.basic_mediump_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006712, + "dEQP-GLES3.functional.shaders.loops.for_con", + "stant_iterations.basic_mediump_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006713, + "dEQP-GLES3.functional.shaders.loops.for_con", + "stant_iterations.basic_mediump_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006714, + "dEQP-GLES3.functional.shaders.loops.for_cons", + "tant_iterations.basic_mediump_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006715, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.basic_highp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006716, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.basic_highp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006717, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.basic_highp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006718, + "dEQP-GLES3.functional.shaders.loops.for_con", + "stant_iterations.basic_highp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006719, + "dEQP-GLES3.functional.shaders.loops.fo", + "r_constant_iterations.empty_body_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006720, + "dEQP-GLES3.functional.shaders.loops.for", + "_constant_iterations.empty_body_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006721, + "dEQP-GLES3.functional.shaders.loops.for_constant_iter", + "ations.infinite_with_unconditional_break_first_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006722, + "dEQP-GLES3.functional.shaders.loops.for_constant_itera", + "tions.infinite_with_unconditional_break_first_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006723, + "dEQP-GLES3.functional.shaders.loops.for_constant_ite", + "rations.infinite_with_unconditional_break_last_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006724, + "dEQP-GLES3.functional.shaders.loops.for_constant_iter", + "ations.infinite_with_unconditional_break_last_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006725, + "dEQP-GLES3.functional.shaders.loops.for_constant_", + "iterations.infinite_with_conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006726, + "dEQP-GLES3.functional.shaders.loops.for_constant_i", + "terations.infinite_with_conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006727, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.single_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006728, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.single_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006729, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.compound_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006730, + "dEQP-GLES3.functional.shaders.loops.for_con", + "stant_iterations.compound_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006731, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.sequence_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006732, + "dEQP-GLES3.functional.shaders.loops.for_con", + "stant_iterations.sequence_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006733, + "dEQP-GLES3.functional.shaders.loops.for_", + "constant_iterations.no_iterations_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006734, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.no_iterations_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006735, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.single_iteration_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006736, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.single_iteration_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006737, + "dEQP-GLES3.functional.shaders.loops.for_cons", + "tant_iterations.select_iteration_count_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006738, + "dEQP-GLES3.functional.shaders.loops.for_const", + "ant_iterations.select_iteration_count_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006739, + "dEQP-GLES3.functional.shaders.loops.for_con", + "stant_iterations.conditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006740, + "dEQP-GLES3.functional.shaders.loops.for_cons", + "tant_iterations.conditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006741, + "dEQP-GLES3.functional.shaders.loops.for_cons", + "tant_iterations.unconditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006742, + "dEQP-GLES3.functional.shaders.loops.for_const", + "ant_iterations.unconditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006743, + "dEQP-GLES3.functional.shaders.loops.for_", + "constant_iterations.only_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006744, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.only_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006745, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.double_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006746, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.double_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006747, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006748, + "dEQP-GLES3.functional.shaders.loops.for_con", + "stant_iterations.conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006749, + "dEQP-GLES3.functional.shaders.loops.for_con", + "stant_iterations.unconditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006750, + "dEQP-GLES3.functional.shaders.loops.for_cons", + "tant_iterations.unconditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006751, + "dEQP-GLES3.functional.shaders.loops.for_", + "constant_iterations.pre_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006752, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.pre_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006753, + "dEQP-GLES3.functional.shaders.loops.for_", + "constant_iterations.post_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006754, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.post_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006755, + "dEQP-GLES3.functional.shaders.loops.for_con", + "stant_iterations.mixed_break_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006756, + "dEQP-GLES3.functional.shaders.loops.for_cons", + "tant_iterations.mixed_break_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006757, + "dEQP-GLES3.functional.shaders.loops.for_", + "constant_iterations.vector_counter_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006758, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.vector_counter_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006759, + "dEQP-GLES3.functional.shaders.loops.for_", + "constant_iterations.101_iterations_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006760, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.101_iterations_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006761, + "dEQP-GLES3.functional.shaders.loops.f", + "or_constant_iterations.sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006762, + "dEQP-GLES3.functional.shaders.loops.fo", + "r_constant_iterations.sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006763, + "dEQP-GLES3.functional.shaders.loops.", + "for_constant_iterations.nested_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006764, + "dEQP-GLES3.functional.shaders.loops.f", + "or_constant_iterations.nested_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006765, + "dEQP-GLES3.functional.shaders.loops.for_c", + "onstant_iterations.nested_sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006766, + "dEQP-GLES3.functional.shaders.loops.for_co", + "nstant_iterations.nested_sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006767, + "dEQP-GLES3.functional.shaders.loops.for_const", + "ant_iterations.nested_tricky_dataflow_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006768, + "dEQP-GLES3.functional.shaders.loops.for_consta", + "nt_iterations.nested_tricky_dataflow_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006769, + "dEQP-GLES3.functional.shaders.loops.for_const", + "ant_iterations.nested_tricky_dataflow_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006770, + "dEQP-GLES3.functional.shaders.loops.for_consta", + "nt_iterations.nested_tricky_dataflow_2_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_dynamic_iterationsTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_dynamic_iterationsTestCase.cpp new file mode 100644 index 000000000..3d25b83d4 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_dynamic_iterationsTestCase.cpp @@ -0,0 +1,280 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30007TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006835, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.basic_lowp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006836, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.basic_lowp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006837, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.basic_lowp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006838, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.basic_lowp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006839, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.basic_mediump_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006840, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.basic_mediump_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006841, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.basic_mediump_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006842, + "dEQP-GLES3.functional.shaders.loops.for_dyn", + "amic_iterations.basic_mediump_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006843, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.basic_highp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006844, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.basic_highp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006845, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.basic_highp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006846, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.basic_highp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006847, + "dEQP-GLES3.functional.shaders.loops.fo", + "r_dynamic_iterations.empty_body_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006848, + "dEQP-GLES3.functional.shaders.loops.for", + "_dynamic_iterations.empty_body_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006849, + "dEQP-GLES3.functional.shaders.loops.for_dynamic_iter", + "ations.infinite_with_unconditional_break_first_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006850, + "dEQP-GLES3.functional.shaders.loops.for_dynamic_itera", + "tions.infinite_with_unconditional_break_first_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006851, + "dEQP-GLES3.functional.shaders.loops.for_dynamic_iter", + "ations.infinite_with_unconditional_break_last_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006852, + "dEQP-GLES3.functional.shaders.loops.for_dynamic_itera", + "tions.infinite_with_unconditional_break_last_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006853, + "dEQP-GLES3.functional.shaders.loops.for_dynamic_", + "iterations.infinite_with_conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006854, + "dEQP-GLES3.functional.shaders.loops.for_dynamic_i", + "terations.infinite_with_conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006855, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.single_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006856, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.single_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006857, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.compound_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006858, + "dEQP-GLES3.functional.shaders.loops.for_dyn", + "amic_iterations.compound_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006859, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.sequence_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006860, + "dEQP-GLES3.functional.shaders.loops.for_dyn", + "amic_iterations.sequence_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006861, + "dEQP-GLES3.functional.shaders.loops.for", + "_dynamic_iterations.no_iterations_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006862, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.no_iterations_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006863, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.single_iteration_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006864, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.single_iteration_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006865, + "dEQP-GLES3.functional.shaders.loops.for_dyna", + "mic_iterations.select_iteration_count_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006866, + "dEQP-GLES3.functional.shaders.loops.for_dynam", + "ic_iterations.select_iteration_count_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006867, + "dEQP-GLES3.functional.shaders.loops.for_dyn", + "amic_iterations.conditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006868, + "dEQP-GLES3.functional.shaders.loops.for_dyna", + "mic_iterations.conditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006869, + "dEQP-GLES3.functional.shaders.loops.for_dyna", + "mic_iterations.unconditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006870, + "dEQP-GLES3.functional.shaders.loops.for_dynam", + "ic_iterations.unconditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006871, + "dEQP-GLES3.functional.shaders.loops.for", + "_dynamic_iterations.only_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006872, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.only_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006873, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.double_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006874, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.double_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006875, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006876, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006877, + "dEQP-GLES3.functional.shaders.loops.for_dy", + "namic_iterations.unconditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006878, + "dEQP-GLES3.functional.shaders.loops.for_dyn", + "amic_iterations.unconditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006879, + "dEQP-GLES3.functional.shaders.loops.for", + "_dynamic_iterations.pre_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006880, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.pre_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006881, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.post_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006882, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.post_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006883, + "dEQP-GLES3.functional.shaders.loops.for_dyn", + "amic_iterations.mixed_break_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006884, + "dEQP-GLES3.functional.shaders.loops.for_dyna", + "mic_iterations.mixed_break_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006885, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.vector_counter_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006886, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.vector_counter_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006887, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.101_iterations_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006888, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.101_iterations_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006889, + "dEQP-GLES3.functional.shaders.loops.f", + "or_dynamic_iterations.sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006890, + "dEQP-GLES3.functional.shaders.loops.fo", + "r_dynamic_iterations.sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006891, + "dEQP-GLES3.functional.shaders.loops.", + "for_dynamic_iterations.nested_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006892, + "dEQP-GLES3.functional.shaders.loops.f", + "or_dynamic_iterations.nested_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006893, + "dEQP-GLES3.functional.shaders.loops.for_", + "dynamic_iterations.nested_sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006894, + "dEQP-GLES3.functional.shaders.loops.for_d", + "ynamic_iterations.nested_sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006895, + "dEQP-GLES3.functional.shaders.loops.for_dynam", + "ic_iterations.nested_tricky_dataflow_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006896, + "dEQP-GLES3.functional.shaders.loops.for_dynami", + "c_iterations.nested_tricky_dataflow_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006897, + "dEQP-GLES3.functional.shaders.loops.for_dynam", + "ic_iterations.nested_tricky_dataflow_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006898, + "dEQP-GLES3.functional.shaders.loops.for_dynami", + "c_iterations.nested_tricky_dataflow_2_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_uniform_iterationsTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_uniform_iterationsTestCase.cpp new file mode 100644 index 000000000..bea189cc1 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3loops_for_uniform_iterationsTestCase.cpp @@ -0,0 +1,280 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30007TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006771, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.basic_lowp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006772, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.basic_lowp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006773, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.basic_lowp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006774, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.basic_lowp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006775, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.basic_mediump_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006776, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.basic_mediump_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006777, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.basic_mediump_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006778, + "dEQP-GLES3.functional.shaders.loops.for_uni", + "form_iterations.basic_mediump_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006779, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.basic_highp_int_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006780, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.basic_highp_int_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006781, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.basic_highp_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006782, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.basic_highp_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006783, + "dEQP-GLES3.functional.shaders.loops.fo", + "r_uniform_iterations.empty_body_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006784, + "dEQP-GLES3.functional.shaders.loops.for", + "_uniform_iterations.empty_body_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006785, + "dEQP-GLES3.functional.shaders.loops.for_uniform_iter", + "ations.infinite_with_unconditional_break_first_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006786, + "dEQP-GLES3.functional.shaders.loops.for_uniform_itera", + "tions.infinite_with_unconditional_break_first_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006787, + "dEQP-GLES3.functional.shaders.loops.for_uniform_iter", + "ations.infinite_with_unconditional_break_last_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006788, + "dEQP-GLES3.functional.shaders.loops.for_uniform_itera", + "tions.infinite_with_unconditional_break_last_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006789, + "dEQP-GLES3.functional.shaders.loops.for_uniform_", + "iterations.infinite_with_conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006790, + "dEQP-GLES3.functional.shaders.loops.for_uniform_i", + "terations.infinite_with_conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006791, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.single_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006792, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.single_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006793, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.compound_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006794, + "dEQP-GLES3.functional.shaders.loops.for_uni", + "form_iterations.compound_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006795, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.sequence_statement_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006796, + "dEQP-GLES3.functional.shaders.loops.for_uni", + "form_iterations.sequence_statement_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006797, + "dEQP-GLES3.functional.shaders.loops.for", + "_uniform_iterations.no_iterations_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006798, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.no_iterations_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006799, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.single_iteration_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006800, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.single_iteration_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006801, + "dEQP-GLES3.functional.shaders.loops.for_unif", + "orm_iterations.select_iteration_count_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006802, + "dEQP-GLES3.functional.shaders.loops.for_unifo", + "rm_iterations.select_iteration_count_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006803, + "dEQP-GLES3.functional.shaders.loops.for_uni", + "form_iterations.conditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006804, + "dEQP-GLES3.functional.shaders.loops.for_unif", + "orm_iterations.conditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006805, + "dEQP-GLES3.functional.shaders.loops.for_unif", + "orm_iterations.unconditional_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006806, + "dEQP-GLES3.functional.shaders.loops.for_unifo", + "rm_iterations.unconditional_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006807, + "dEQP-GLES3.functional.shaders.loops.for", + "_uniform_iterations.only_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006808, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.only_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006809, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.double_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006810, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.double_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006811, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.conditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006812, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.conditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006813, + "dEQP-GLES3.functional.shaders.loops.for_un", + "iform_iterations.unconditional_break_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006814, + "dEQP-GLES3.functional.shaders.loops.for_uni", + "form_iterations.unconditional_break_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006815, + "dEQP-GLES3.functional.shaders.loops.for", + "_uniform_iterations.pre_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006816, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.pre_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006817, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.post_increment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006818, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.post_increment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006819, + "dEQP-GLES3.functional.shaders.loops.for_uni", + "form_iterations.mixed_break_continue_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006820, + "dEQP-GLES3.functional.shaders.loops.for_unif", + "orm_iterations.mixed_break_continue_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006821, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.vector_counter_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006822, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.vector_counter_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006823, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.101_iterations_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006824, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.101_iterations_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006825, + "dEQP-GLES3.functional.shaders.loops.f", + "or_uniform_iterations.sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006826, + "dEQP-GLES3.functional.shaders.loops.fo", + "r_uniform_iterations.sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006827, + "dEQP-GLES3.functional.shaders.loops.", + "for_uniform_iterations.nested_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006828, + "dEQP-GLES3.functional.shaders.loops.f", + "or_uniform_iterations.nested_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006829, + "dEQP-GLES3.functional.shaders.loops.for_", + "uniform_iterations.nested_sequence_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006830, + "dEQP-GLES3.functional.shaders.loops.for_u", + "niform_iterations.nested_sequence_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006831, + "dEQP-GLES3.functional.shaders.loops.for_unifo", + "rm_iterations.nested_tricky_dataflow_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006832, + "dEQP-GLES3.functional.shaders.loops.for_unifor", + "m_iterations.nested_tricky_dataflow_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006833, + "dEQP-GLES3.functional.shaders.loops.for_unifo", + "rm_iterations.nested_tricky_dataflow_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30007TestSuite, TestCase_006834, + "dEQP-GLES3.functional.shaders.loops.for_unifor", + "m_iterations.nested_tricky_dataflow_2_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrix_post_incrementTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrix_post_incrementTestCase.cpp new file mode 100644 index 000000000..0ea4c82a7 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrix_post_incrementTestCase.cpp @@ -0,0 +1,240 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30017TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016122, + "dEQP-GLES3.functional.shaders.matrix.", + "post_increment.lowp_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016123, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.lowp_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016124, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.mediump_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016125, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.mediump_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016126, + "dEQP-GLES3.functional.shaders.matrix.", + "post_increment.highp_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016127, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.highp_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016128, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.lowp_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016129, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.lowp_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016130, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.mediump_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016131, + "dEQP-GLES3.functional.shaders.matrix.pos", + "t_increment.mediump_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016132, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.highp_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016133, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.highp_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016134, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.lowp_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016135, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.lowp_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016136, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.mediump_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016137, + "dEQP-GLES3.functional.shaders.matrix.pos", + "t_increment.mediump_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016138, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.highp_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016139, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.highp_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016140, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.lowp_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016141, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.lowp_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016142, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.mediump_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016143, + "dEQP-GLES3.functional.shaders.matrix.pos", + "t_increment.mediump_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016144, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.highp_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016145, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.highp_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016146, + "dEQP-GLES3.functional.shaders.matrix.", + "post_increment.lowp_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016147, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.lowp_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016148, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.mediump_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016149, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.mediump_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016150, + "dEQP-GLES3.functional.shaders.matrix.", + "post_increment.highp_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016151, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.highp_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016152, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.lowp_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016153, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.lowp_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016154, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.mediump_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016155, + "dEQP-GLES3.functional.shaders.matrix.pos", + "t_increment.mediump_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016156, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.highp_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016157, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.highp_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016158, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.lowp_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016159, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.lowp_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016160, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.mediump_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016161, + "dEQP-GLES3.functional.shaders.matrix.pos", + "t_increment.mediump_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016162, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.highp_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016163, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.highp_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016164, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.lowp_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016165, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.lowp_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016166, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.mediump_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016167, + "dEQP-GLES3.functional.shaders.matrix.pos", + "t_increment.mediump_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016168, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.highp_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016169, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.highp_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016170, + "dEQP-GLES3.functional.shaders.matrix.", + "post_increment.lowp_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016171, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.lowp_mat4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016172, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.mediump_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016173, + "dEQP-GLES3.functional.shaders.matrix.po", + "st_increment.mediump_mat4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016174, + "dEQP-GLES3.functional.shaders.matrix.", + "post_increment.highp_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016175, + "dEQP-GLES3.functional.shaders.matrix.p", + "ost_increment.highp_mat4_float_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrix_unary_additionTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrix_unary_additionTestCase.cpp new file mode 100644 index 000000000..bff80121f --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrix_unary_additionTestCase.cpp @@ -0,0 +1,240 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30016TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015906, + "dEQP-GLES3.functional.shaders.matrix.", + "unary_addition.lowp_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015907, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.lowp_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015908, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.mediump_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015909, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.mediump_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015910, + "dEQP-GLES3.functional.shaders.matrix.", + "unary_addition.highp_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015911, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.highp_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015912, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.lowp_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015913, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.lowp_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015914, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.mediump_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015915, + "dEQP-GLES3.functional.shaders.matrix.una", + "ry_addition.mediump_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015916, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.highp_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015917, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.highp_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015918, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.lowp_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015919, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.lowp_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015920, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.mediump_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015921, + "dEQP-GLES3.functional.shaders.matrix.una", + "ry_addition.mediump_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015922, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.highp_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015923, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.highp_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015924, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.lowp_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015925, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.lowp_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015926, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.mediump_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015927, + "dEQP-GLES3.functional.shaders.matrix.una", + "ry_addition.mediump_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015928, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.highp_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015929, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.highp_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015930, + "dEQP-GLES3.functional.shaders.matrix.", + "unary_addition.lowp_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015931, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.lowp_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015932, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.mediump_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015933, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.mediump_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015934, + "dEQP-GLES3.functional.shaders.matrix.", + "unary_addition.highp_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015935, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.highp_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015936, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.lowp_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015937, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.lowp_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015938, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.mediump_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015939, + "dEQP-GLES3.functional.shaders.matrix.una", + "ry_addition.mediump_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015940, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.highp_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015941, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.highp_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015942, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.lowp_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015943, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.lowp_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015944, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.mediump_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015945, + "dEQP-GLES3.functional.shaders.matrix.una", + "ry_addition.mediump_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015946, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.highp_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015947, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.highp_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015948, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.lowp_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015949, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.lowp_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015950, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.mediump_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015951, + "dEQP-GLES3.functional.shaders.matrix.una", + "ry_addition.mediump_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015952, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.highp_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015953, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.highp_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015954, + "dEQP-GLES3.functional.shaders.matrix.", + "unary_addition.lowp_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015955, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.lowp_mat4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015956, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.mediump_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015957, + "dEQP-GLES3.functional.shaders.matrix.un", + "ary_addition.mediump_mat4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015958, + "dEQP-GLES3.functional.shaders.matrix.", + "unary_addition.highp_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015959, + "dEQP-GLES3.functional.shaders.matrix.u", + "nary_addition.highp_mat4_float_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrixcompmult_dynamicTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrixcompmult_dynamicTestCase.cpp new file mode 100644 index 000000000..32d675740 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3matrixcompmult_dynamicTestCase.cpp @@ -0,0 +1,240 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30016TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015708, + "dEQP-GLES3.functional.shaders.matrix.mat", + "rixcompmult.dynamic.lowp_mat2_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015709, + "dEQP-GLES3.functional.shaders.matrix.matr", + "ixcompmult.dynamic.lowp_mat2_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015710, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.mediump_mat2_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015711, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.mediump_mat2_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015712, + "dEQP-GLES3.functional.shaders.matrix.matr", + "ixcompmult.dynamic.highp_mat2_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015713, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.highp_mat2_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015714, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.lowp_mat2x3_mat2x3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015715, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.lowp_mat2x3_mat2x3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015716, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.mediump_mat2x3_mat2x3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015717, + "dEQP-GLES3.functional.shaders.matrix.matrixco", + "mpmult.dynamic.mediump_mat2x3_mat2x3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015718, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.highp_mat2x3_mat2x3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015719, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.highp_mat2x3_mat2x3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015720, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.lowp_mat2x4_mat2x4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015721, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.lowp_mat2x4_mat2x4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015722, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.mediump_mat2x4_mat2x4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015723, + "dEQP-GLES3.functional.shaders.matrix.matrixco", + "mpmult.dynamic.mediump_mat2x4_mat2x4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015724, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.highp_mat2x4_mat2x4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015725, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.highp_mat2x4_mat2x4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015726, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.lowp_mat3x2_mat3x2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015727, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.lowp_mat3x2_mat3x2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015728, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.mediump_mat3x2_mat3x2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015729, + "dEQP-GLES3.functional.shaders.matrix.matrixco", + "mpmult.dynamic.mediump_mat3x2_mat3x2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015730, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.highp_mat3x2_mat3x2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015731, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.highp_mat3x2_mat3x2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015732, + "dEQP-GLES3.functional.shaders.matrix.mat", + "rixcompmult.dynamic.lowp_mat3_mat3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015733, + "dEQP-GLES3.functional.shaders.matrix.matr", + "ixcompmult.dynamic.lowp_mat3_mat3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015734, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.mediump_mat3_mat3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015735, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.mediump_mat3_mat3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015736, + "dEQP-GLES3.functional.shaders.matrix.matr", + "ixcompmult.dynamic.highp_mat3_mat3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015737, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.highp_mat3_mat3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015738, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.lowp_mat3x4_mat3x4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015739, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.lowp_mat3x4_mat3x4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015740, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.mediump_mat3x4_mat3x4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015741, + "dEQP-GLES3.functional.shaders.matrix.matrixco", + "mpmult.dynamic.mediump_mat3x4_mat3x4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015742, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.highp_mat3x4_mat3x4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015743, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.highp_mat3x4_mat3x4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015744, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.lowp_mat4x2_mat4x2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015745, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.lowp_mat4x2_mat4x2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015746, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.mediump_mat4x2_mat4x2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015747, + "dEQP-GLES3.functional.shaders.matrix.matrixco", + "mpmult.dynamic.mediump_mat4x2_mat4x2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015748, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.highp_mat4x2_mat4x2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015749, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.highp_mat4x2_mat4x2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015750, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.lowp_mat4x3_mat4x3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015751, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.lowp_mat4x3_mat4x3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015752, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.mediump_mat4x3_mat4x3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015753, + "dEQP-GLES3.functional.shaders.matrix.matrixco", + "mpmult.dynamic.mediump_mat4x3_mat4x3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015754, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.highp_mat4x3_mat4x3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015755, + "dEQP-GLES3.functional.shaders.matrix.matrixc", + "ompmult.dynamic.highp_mat4x3_mat4x3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015756, + "dEQP-GLES3.functional.shaders.matrix.mat", + "rixcompmult.dynamic.lowp_mat4_mat4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015757, + "dEQP-GLES3.functional.shaders.matrix.matr", + "ixcompmult.dynamic.lowp_mat4_mat4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015758, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.mediump_mat4_mat4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015759, + "dEQP-GLES3.functional.shaders.matrix.matrix", + "compmult.dynamic.mediump_mat4_mat4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015760, + "dEQP-GLES3.functional.shaders.matrix.matr", + "ixcompmult.dynamic.highp_mat4_mat4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015761, + "dEQP-GLES3.functional.shaders.matrix.matri", + "xcompmult.dynamic.highp_mat4_mat4_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3negative_api_shaderTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3negative_api_shaderTestCase.cpp new file mode 100644 index 000000000..300bbe368 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3negative_api_shaderTestCase.cpp @@ -0,0 +1,268 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30043TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042059, + "dEQP-GLES3.functional.negat", + "ive_api.shader.create_shader"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042060, + "dEQP-GLES3.functional.negat", + "ive_api.shader.shader_source"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042061, + "dEQP-GLES3.functional.negati", + "ve_api.shader.compile_shader"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042062, + "dEQP-GLES3.functional.negat", + "ive_api.shader.delete_shader"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042063, + "dEQP-GLES3.functional.negat", + "ive_api.shader.shader_binary"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042064, + "dEQP-GLES3.functional.negat", + "ive_api.shader.attach_shader"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042065, + "dEQP-GLES3.functional.negat", + "ive_api.shader.detach_shader"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042066, + "dEQP-GLES3.functional.negat", + "ive_api.shader.link_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042067, + "dEQP-GLES3.functional.nega", + "tive_api.shader.use_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042068, + "dEQP-GLES3.functional.negati", + "ve_api.shader.delete_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042069, + "dEQP-GLES3.functional.negativ", + "e_api.shader.validate_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042070, + "dEQP-GLES3.functional.negative", + "_api.shader.get_program_binary"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042071, + "dEQP-GLES3.functional.negati", + "ve_api.shader.program_binary"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042072, + "dEQP-GLES3.functional.negative", + "_api.shader.program_parameteri"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042073, + "dEQP-GLES3.functional.negat", + "ive_api.shader.gen_samplers"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042074, + "dEQP-GLES3.functional.negat", + "ive_api.shader.bind_sampler"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042075, + "dEQP-GLES3.functional.negati", + "ve_api.shader.delete_samplers"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042076, + "dEQP-GLES3.functional.negative_a", + "pi.shader.get_sampler_parameteriv"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042077, + "dEQP-GLES3.functional.negative_a", + "pi.shader.get_sampler_parameterfv"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042078, + "dEQP-GLES3.functional.negative", + "_api.shader.sampler_parameteri"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042079, + "dEQP-GLES3.functional.negative", + "_api.shader.sampler_parameteriv"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042080, + "dEQP-GLES3.functional.negative", + "_api.shader.sampler_parameterf"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042081, + "dEQP-GLES3.functional.negative", + "_api.shader.sampler_parameterfv"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042082, + "dEQP-GLES3.functional.negative", + "_api.shader.get_attrib_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042083, + "dEQP-GLES3.functional.negative_", + "api.shader.get_uniform_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042084, + "dEQP-GLES3.functional.negative_", + "api.shader.bind_attrib_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042085, + "dEQP-GLES3.functional.negative_", + "api.shader.uniform_block_binding"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042086, + "dEQP-GLES3.functional.negative_ap", + "i.shader.uniformf_invalid_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042087, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformf_incompatible_type"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042088, + "dEQP-GLES3.functional.negative_ap", + "i.shader.uniformf_invalid_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042089, + "dEQP-GLES3.functional.negative_ap", + "i.shader.uniformfv_invalid_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042090, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformfv_incompatible_type"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042091, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformfv_invalid_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042092, + "dEQP-GLES3.functional.negative_a", + "pi.shader.uniformfv_invalid_count"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042093, + "dEQP-GLES3.functional.negative_ap", + "i.shader.uniformi_invalid_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042094, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformi_incompatible_type"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042095, + "dEQP-GLES3.functional.negative_ap", + "i.shader.uniformi_invalid_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042096, + "dEQP-GLES3.functional.negative_ap", + "i.shader.uniformiv_invalid_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042097, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformiv_incompatible_type"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042098, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformiv_invalid_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042099, + "dEQP-GLES3.functional.negative_a", + "pi.shader.uniformiv_invalid_count"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042100, + "dEQP-GLES3.functional.negative_ap", + "i.shader.uniformui_invalid_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042101, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformui_incompatible_type"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042102, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformui_invalid_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042103, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformuiv_invalid_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042104, + "dEQP-GLES3.functional.negative_api.", + "shader.uniformuiv_incompatible_type"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042105, + "dEQP-GLES3.functional.negative_api", + ".shader.uniformuiv_invalid_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042106, + "dEQP-GLES3.functional.negative_ap", + "i.shader.uniformuiv_invalid_count"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042107, + "dEQP-GLES3.functional.negative_api.sh", + "ader.uniform_matrixfv_invalid_program"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042108, + "dEQP-GLES3.functional.negative_api.sha", + "der.uniform_matrixfv_incompatible_type"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042109, + "dEQP-GLES3.functional.negative_api.sh", + "ader.uniform_matrixfv_invalid_location"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042110, + "dEQP-GLES3.functional.negative_api.s", + "hader.uniform_matrixfv_invalid_count"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042111, + "dEQP-GLES3.functional.negative_a", + "pi.shader.gen_transform_feedbacks"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042112, + "dEQP-GLES3.functional.negative_a", + "pi.shader.bind_transform_feedback"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042113, + "dEQP-GLES3.functional.negative_api", + ".shader.delete_transform_feedbacks"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042114, + "dEQP-GLES3.functional.negative_ap", + "i.shader.begin_transform_feedback"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042115, + "dEQP-GLES3.functional.negative_ap", + "i.shader.pause_transform_feedback"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042116, + "dEQP-GLES3.functional.negative_ap", + "i.shader.resume_transform_feedback"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042117, + "dEQP-GLES3.functional.negative_a", + "pi.shader.end_transform_feedback"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042118, + "dEQP-GLES3.functional.negative_api.s", + "hader.get_transform_feedback_varying"); + +static SHRINK_HWTEST_F(ActsDeqpgles30043TestSuite, TestCase_042119, + "dEQP-GLES3.functional.negative_api", + ".shader.transform_feedback_varyings"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3outerproduct_dynamicTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3outerproduct_dynamicTestCase.cpp new file mode 100644 index 000000000..a23eb13ea --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3outerproduct_dynamicTestCase.cpp @@ -0,0 +1,240 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30016TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015762, + "dEQP-GLES3.functional.shaders.matrix.out", + "erproduct.dynamic.lowp_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015763, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.lowp_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015764, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.mediump_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015765, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.mediump_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015766, + "dEQP-GLES3.functional.shaders.matrix.out", + "erproduct.dynamic.highp_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015767, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.highp_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015768, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.lowp_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015769, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.lowp_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015770, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.mediump_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015771, + "dEQP-GLES3.functional.shaders.matrix.outerp", + "roduct.dynamic.mediump_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015772, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.highp_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015773, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.highp_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015774, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.lowp_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015775, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.lowp_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015776, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.mediump_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015777, + "dEQP-GLES3.functional.shaders.matrix.outerp", + "roduct.dynamic.mediump_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015778, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.highp_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015779, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.highp_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015780, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.lowp_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015781, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.lowp_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015782, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.mediump_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015783, + "dEQP-GLES3.functional.shaders.matrix.outerp", + "roduct.dynamic.mediump_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015784, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.highp_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015785, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.highp_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015786, + "dEQP-GLES3.functional.shaders.matrix.out", + "erproduct.dynamic.lowp_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015787, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.lowp_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015788, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.mediump_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015789, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.mediump_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015790, + "dEQP-GLES3.functional.shaders.matrix.out", + "erproduct.dynamic.highp_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015791, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.highp_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015792, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.lowp_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015793, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.lowp_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015794, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.mediump_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015795, + "dEQP-GLES3.functional.shaders.matrix.outerp", + "roduct.dynamic.mediump_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015796, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.highp_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015797, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.highp_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015798, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.lowp_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015799, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.lowp_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015800, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.mediump_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015801, + "dEQP-GLES3.functional.shaders.matrix.outerp", + "roduct.dynamic.mediump_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015802, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.highp_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015803, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.highp_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015804, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.lowp_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015805, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.lowp_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015806, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.mediump_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015807, + "dEQP-GLES3.functional.shaders.matrix.outerp", + "roduct.dynamic.mediump_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015808, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.highp_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015809, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.highp_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015810, + "dEQP-GLES3.functional.shaders.matrix.out", + "erproduct.dynamic.lowp_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015811, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.lowp_mat4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015812, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.mediump_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015813, + "dEQP-GLES3.functional.shaders.matrix.outer", + "product.dynamic.mediump_mat4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015814, + "dEQP-GLES3.functional.shaders.matrix.out", + "erproduct.dynamic.highp_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015815, + "dEQP-GLES3.functional.shaders.matrix.oute", + "rproduct.dynamic.highp_mat4_float_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3preprocessor_invalid_conditionalsTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3preprocessor_invalid_conditionalsTestCase.cpp new file mode 100644 index 000000000..7ded4b904 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3preprocessor_invalid_conditionalsTestCase.cpp @@ -0,0 +1,256 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30002TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001024, + "dEQP-GLES3.functional.shaders.preproces", + "sor.invalid_conditionals.empty_if_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001025, + "dEQP-GLES3.functional.shaders.preprocess", + "or.invalid_conditionals.empty_if_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001026, + "dEQP-GLES3.functional.shaders.preprocesso", + "r.invalid_conditionals.empty_ifdef_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001027, + "dEQP-GLES3.functional.shaders.preprocessor", + ".invalid_conditionals.empty_ifdef_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001028, + "dEQP-GLES3.functional.shaders.preprocesso", + "r.invalid_conditionals.empty_ifndef_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001029, + "dEQP-GLES3.functional.shaders.preprocessor", + ".invalid_conditionals.empty_ifndef_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001030, + "dEQP-GLES3.functional.shaders.preprocessor", + ".invalid_conditionals.invalid_ifdef_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001031, + "dEQP-GLES3.functional.shaders.preprocessor.", + "invalid_conditionals.invalid_ifdef_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001032, + "dEQP-GLES3.functional.shaders.preprocessor", + ".invalid_conditionals.invalid_ifndef_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001033, + "dEQP-GLES3.functional.shaders.preprocessor.", + "invalid_conditionals.invalid_ifndef_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001034, + "dEQP-GLES3.functional.shaders.preprocessor.", + "invalid_conditionals.empty_if_defined_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001035, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.empty_if_defined_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001036, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.unterminated_if_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001037, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.unterminated_if_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001038, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.unterminated_if_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001039, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.unterminated_if_2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001040, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.unterminated_ifdef_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001041, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.unterminated_ifdef_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001042, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.unterminated_ifndef_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001043, + "dEQP-GLES3.functional.shaders.preprocessor.inv", + "alid_conditionals.unterminated_ifndef_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001044, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.unterminated_else_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001045, + "dEQP-GLES3.functional.shaders.preprocessor.inv", + "alid_conditionals.unterminated_else_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001046, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.unterminated_else_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001047, + "dEQP-GLES3.functional.shaders.preprocessor.inv", + "alid_conditionals.unterminated_else_2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001048, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.unterminated_elif_1_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001049, + "dEQP-GLES3.functional.shaders.preprocessor.inv", + "alid_conditionals.unterminated_elif_1_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001050, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.unterminated_elif_2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001051, + "dEQP-GLES3.functional.shaders.preprocessor.inv", + "alid_conditionals.unterminated_elif_2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001052, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.unterminated_elif_3_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001053, + "dEQP-GLES3.functional.shaders.preprocessor.inv", + "alid_conditionals.unterminated_elif_3_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001054, + "dEQP-GLES3.functional.shaders.preprocessor.", + "invalid_conditionals.elif_after_else_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001055, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.elif_after_else_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001056, + "dEQP-GLES3.functional.shaders.preprocessor.", + "invalid_conditionals.else_without_if_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001057, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.else_without_if_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001058, + "dEQP-GLES3.functional.shaders.preprocessor.", + "invalid_conditionals.elif_without_if_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001059, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.elif_without_if_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001060, + "dEQP-GLES3.functional.shaders.preprocessor.", + "invalid_conditionals.endif_without_if_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001061, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.endif_without_if_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001062, + "dEQP-GLES3.functional.shaders.preprocessor.", + "invalid_conditionals.else_after_else_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001063, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.else_after_else_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001064, + "dEQP-GLES3.functional.shaders.preprocessor.inv", + "alid_conditionals.nested_elif_without_if_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001065, + "dEQP-GLES3.functional.shaders.preprocessor.inva", + "lid_conditionals.nested_elif_without_if_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001066, + "dEQP-GLES3.functional.shaders.preproces", + "sor.invalid_conditionals.if_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001067, + "dEQP-GLES3.functional.shaders.preprocess", + "or.invalid_conditionals.if_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001068, + "dEQP-GLES3.functional.shaders.preprocessor.", + "invalid_conditionals.tokens_after_if_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001069, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.tokens_after_if_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001070, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.tokens_after_elif_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001071, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.tokens_after_elif_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001072, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.tokens_after_else_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001073, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.tokens_after_else_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001074, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.tokens_after_endif_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001075, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.tokens_after_endif_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001076, + "dEQP-GLES3.functional.shaders.preprocessor.i", + "nvalid_conditionals.tokens_after_ifdef_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001077, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.tokens_after_ifdef_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001078, + "dEQP-GLES3.functional.shaders.preprocessor.in", + "valid_conditionals.tokens_after_ifndef_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001079, + "dEQP-GLES3.functional.shaders.preprocessor.inv", + "alid_conditionals.tokens_after_ifndef_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001080, + "dEQP-GLES3.functional.shaders.preprocessor.inval", + "id_conditionals.unterminated_nested_blocks_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30002TestSuite, TestCase_001081, + "dEQP-GLES3.functional.shaders.preprocessor.invali", + "d_conditionals.unterminated_nested_blocks_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3render_nested_structs_arraysTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3render_nested_structs_arraysTestCase.cpp new file mode 100644 index 000000000..eb841cd34 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3render_nested_structs_arraysTestCase.cpp @@ -0,0 +1,216 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30038TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037285, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".render.nested_structs_arrays.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037286, + "dEQP-GLES3.functional.uniform_api.value.initial.", + "render.nested_structs_arrays.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037287, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.render.nested_structs_arrays.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037288, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.render.nested_structs_arrays.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037289, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".render.nested_structs_arrays.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037290, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.render.nested_structs_arrays.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037291, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.render.nested_structs_arrays.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037292, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".render.nested_structs_arrays.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037293, + "dEQP-GLES3.functional.uniform_api.value.initi", + "al.render.nested_structs_arrays.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037294, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".render.nested_structs_arrays.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037295, + "dEQP-GLES3.functional.uniform_api.value.initial.", + "render.nested_structs_arrays.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037296, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.render.nested_structs_arrays.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037297, + "dEQP-GLES3.functional.uniform_api.value.initial", + ".render.nested_structs_arrays.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037298, + "dEQP-GLES3.functional.uniform_api.value.initial.", + "render.nested_structs_arrays.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037299, + "dEQP-GLES3.functional.uniform_api.value.initia", + "l.render.nested_structs_arrays.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037807, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.render.nested_structs_arrays.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037808, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_po", + "inter.render.nested_structs_arrays.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037809, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.render.nested_structs_arrays.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037810, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.render.nested_structs_arrays.mat4_mat2_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037811, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.render.nested_structs_arrays.mat4_mat2_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037812, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.render.nested_structs_arrays.mat4_mat2_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037813, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.render.nested_structs_arrays.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037814, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.render.nested_structs_arrays.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037815, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_pointer.render.nested_structs_arrays.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037816, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.render.nested_structs_arrays.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037817, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_po", + "inter.render.nested_structs_arrays.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037818, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.render.nested_structs_arrays.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037819, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_p", + "ointer.render.nested_structs_arrays.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037820, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_po", + "inter.render.nested_structs_arrays.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037821, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "pointer.render.nested_structs_arrays.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037822, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_pointe", + "r.render.nested_structs_arrays.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037823, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_pointer", + ".render.nested_structs_arrays.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_037824, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_point", + "er.render.nested_structs_arrays.sampler2D_samplerCube_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038182, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.render.nested_structs_arrays.float_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038183, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_v", + "alue.render.nested_structs_arrays.float_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038184, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.render.nested_structs_arrays.float_vec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038185, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.render.nested_structs_arrays.int_ivec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038186, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.render.nested_structs_arrays.int_ivec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038187, + "dEQP-GLES3.functional.uniform_api.value.assigned.b", + "y_value.render.nested_structs_arrays.int_ivec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038188, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.render.nested_structs_arrays.uint_uvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038189, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_v", + "alue.render.nested_structs_arrays.uint_uvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038190, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.render.nested_structs_arrays.uint_uvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038191, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_", + "value.render.nested_structs_arrays.bool_bvec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038192, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_v", + "alue.render.nested_structs_arrays.bool_bvec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038193, + "dEQP-GLES3.functional.uniform_api.value.assigned.by", + "_value.render.nested_structs_arrays.bool_bvec4_both"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038194, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_value", + ".render.nested_structs_arrays.sampler2D_samplerCube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038195, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_value.", + "render.nested_structs_arrays.sampler2D_samplerCube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30038TestSuite, TestCase_038196, + "dEQP-GLES3.functional.uniform_api.value.assigned.by_valu", + "e.render.nested_structs_arrays.sampler2D_samplerCube_both"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3struct_localTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3struct_localTestCase.cpp new file mode 100644 index 000000000..09c91e262 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3struct_localTestCase.cpp @@ -0,0 +1,288 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30017TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016448, + "dEQP-GLES3.functional.shade", + "rs.struct.local.basic_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016449, + "dEQP-GLES3.functional.shader", + "s.struct.local.basic_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016450, + "dEQP-GLES3.functional.shader", + "s.struct.local.nested_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016451, + "dEQP-GLES3.functional.shaders", + ".struct.local.nested_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016452, + "dEQP-GLES3.functional.shaders.s", + "truct.local.array_member_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016453, + "dEQP-GLES3.functional.shaders.st", + "ruct.local.array_member_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016454, + "dEQP-GLES3.functional.shaders.struct.l", + "ocal.array_member_dynamic_index_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016455, + "dEQP-GLES3.functional.shaders.struct.lo", + "cal.array_member_dynamic_index_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016456, + "dEQP-GLES3.functional.shaders.s", + "truct.local.struct_array_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016457, + "dEQP-GLES3.functional.shaders.st", + "ruct.local.struct_array_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016458, + "dEQP-GLES3.functional.shaders.struct.l", + "ocal.struct_array_dynamic_index_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016459, + "dEQP-GLES3.functional.shaders.struct.lo", + "cal.struct_array_dynamic_index_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016460, + "dEQP-GLES3.functional.shaders.stru", + "ct.local.nested_struct_array_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016461, + "dEQP-GLES3.functional.shaders.struc", + "t.local.nested_struct_array_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016462, + "dEQP-GLES3.functional.shaders.struct.loca", + "l.nested_struct_array_dynamic_index_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016463, + "dEQP-GLES3.functional.shaders.struct.local", + ".nested_struct_array_dynamic_index_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016464, + "dEQP-GLES3.functional.shaders", + ".struct.local.parameter_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016465, + "dEQP-GLES3.functional.shaders.", + "struct.local.parameter_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016466, + "dEQP-GLES3.functional.shaders.struc", + "t.local.parameter_inout_lowp_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016467, + "dEQP-GLES3.functional.shaders.struct", + ".local.parameter_inout_lowp_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016468, + "dEQP-GLES3.functional.shaders.struct", + ".local.parameter_inout_mediump_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016469, + "dEQP-GLES3.functional.shaders.struct.", + "local.parameter_inout_mediump_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016470, + "dEQP-GLES3.functional.shaders.struc", + "t.local.parameter_inout_highp_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016471, + "dEQP-GLES3.functional.shaders.struct", + ".local.parameter_inout_highp_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016472, + "dEQP-GLES3.functional.shaders.str", + "uct.local.parameter_nested_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016473, + "dEQP-GLES3.functional.shaders.stru", + "ct.local.parameter_nested_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016474, + "dEQP-GLES3.functional.shaders.stru", + "ct.local.parameter_out_lowp_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016475, + "dEQP-GLES3.functional.shaders.struc", + "t.local.parameter_out_lowp_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016476, + "dEQP-GLES3.functional.shaders.struc", + "t.local.parameter_out_mediump_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016477, + "dEQP-GLES3.functional.shaders.struct", + ".local.parameter_out_mediump_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016478, + "dEQP-GLES3.functional.shaders.stru", + "ct.local.parameter_out_highp_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016479, + "dEQP-GLES3.functional.shaders.struc", + "t.local.parameter_out_highp_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016480, + "dEQP-GLES3.functional.shader", + "s.struct.local.return_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016481, + "dEQP-GLES3.functional.shaders", + ".struct.local.return_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016482, + "dEQP-GLES3.functional.shaders.s", + "truct.local.return_nested_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016483, + "dEQP-GLES3.functional.shaders.st", + "ruct.local.return_nested_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016484, + "dEQP-GLES3.functional.shaders.struct", + ".local.conditional_assignment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016485, + "dEQP-GLES3.functional.shaders.struct.", + "local.conditional_assignment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016486, + "dEQP-GLES3.functional.shaders.st", + "ruct.local.loop_assignment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016487, + "dEQP-GLES3.functional.shaders.str", + "uct.local.loop_assignment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016488, + "dEQP-GLES3.functional.shaders.struct", + ".local.dynamic_loop_assignment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016489, + "dEQP-GLES3.functional.shaders.struct.", + "local.dynamic_loop_assignment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016490, + "dEQP-GLES3.functional.shaders.struct.lo", + "cal.nested_conditional_assignment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016491, + "dEQP-GLES3.functional.shaders.struct.loc", + "al.nested_conditional_assignment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016492, + "dEQP-GLES3.functional.shaders.struct", + ".local.nested_loop_assignment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016493, + "dEQP-GLES3.functional.shaders.struct.", + "local.nested_loop_assignment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016494, + "dEQP-GLES3.functional.shaders.struct.loc", + "al.nested_dynamic_loop_assignment_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016495, + "dEQP-GLES3.functional.shaders.struct.loca", + "l.nested_dynamic_loop_assignment_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016496, + "dEQP-GLES3.functional.shaders.str", + "uct.local.loop_struct_array_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016497, + "dEQP-GLES3.functional.shaders.stru", + "ct.local.loop_struct_array_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016498, + "dEQP-GLES3.functional.shaders.struct.", + "local.loop_nested_struct_array_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016499, + "dEQP-GLES3.functional.shaders.struct.l", + "ocal.loop_nested_struct_array_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016500, + "dEQP-GLES3.functional.shaders.struct.", + "local.dynamic_loop_struct_array_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016501, + "dEQP-GLES3.functional.shaders.struct.l", + "ocal.dynamic_loop_struct_array_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016502, + "dEQP-GLES3.functional.shaders.struct.loca", + "l.dynamic_loop_nested_struct_array_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016503, + "dEQP-GLES3.functional.shaders.struct.local", + ".dynamic_loop_nested_struct_array_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016504, + "dEQP-GLES3.functional.shaders.", + "struct.local.basic_equal_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016505, + "dEQP-GLES3.functional.shaders.s", + "truct.local.basic_equal_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016506, + "dEQP-GLES3.functional.shaders.st", + "ruct.local.basic_not_equal_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016507, + "dEQP-GLES3.functional.shaders.str", + "uct.local.basic_not_equal_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016508, + "dEQP-GLES3.functional.shaders.s", + "truct.local.nested_equal_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016509, + "dEQP-GLES3.functional.shaders.st", + "ruct.local.nested_equal_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016510, + "dEQP-GLES3.functional.shaders.str", + "uct.local.nested_not_equal_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016511, + "dEQP-GLES3.functional.shaders.stru", + "ct.local.nested_not_equal_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016512, + "dEQP-GLES3.functional.shaders.struc", + "t.local.array_member_equality_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016513, + "dEQP-GLES3.functional.shaders.struct", + ".local.array_member_equality_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3swizzle_multi_channelTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3swizzle_multi_channelTestCase.cpp new file mode 100644 index 000000000..c0dc7cecc --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3swizzle_multi_channelTestCase.cpp @@ -0,0 +1,276 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30026TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025217, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.alpha_all_red"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025218, + "dEQP-GLES3.functional.texture.swi", + "zzle.multi_channel.alpha_all_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025219, + "dEQP-GLES3.functional.texture.swi", + "zzle.multi_channel.alpha_all_blue"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025220, + "dEQP-GLES3.functional.texture.swi", + "zzle.multi_channel.alpha_all_alpha"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025221, + "dEQP-GLES3.functional.texture.swi", + "zzle.multi_channel.alpha_all_zero"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025222, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.alpha_all_one"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025223, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.alpha_bgra"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025224, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.alpha_abgr"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025225, + "dEQP-GLES3.functional.texture.swizzle", + ".multi_channel.alpha_one_one_red_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025226, + "dEQP-GLES3.functional.texture.swiz", + "zle.multi_channel.luminance_all_red"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025227, + "dEQP-GLES3.functional.texture.swizz", + "le.multi_channel.luminance_all_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025228, + "dEQP-GLES3.functional.texture.swizz", + "le.multi_channel.luminance_all_blue"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025229, + "dEQP-GLES3.functional.texture.swizz", + "le.multi_channel.luminance_all_alpha"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025230, + "dEQP-GLES3.functional.texture.swizz", + "le.multi_channel.luminance_all_zero"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025231, + "dEQP-GLES3.functional.texture.swiz", + "zle.multi_channel.luminance_all_one"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025232, + "dEQP-GLES3.functional.texture.swi", + "zzle.multi_channel.luminance_bgra"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025233, + "dEQP-GLES3.functional.texture.swi", + "zzle.multi_channel.luminance_abgr"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025234, + "dEQP-GLES3.functional.texture.swizzle.m", + "ulti_channel.luminance_one_one_red_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025235, + "dEQP-GLES3.functional.texture.swizzle", + ".multi_channel.luminance_alpha_all_red"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025236, + "dEQP-GLES3.functional.texture.swizzle.", + "multi_channel.luminance_alpha_all_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025237, + "dEQP-GLES3.functional.texture.swizzle.", + "multi_channel.luminance_alpha_all_blue"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025238, + "dEQP-GLES3.functional.texture.swizzle.", + "multi_channel.luminance_alpha_all_alpha"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025239, + "dEQP-GLES3.functional.texture.swizzle.", + "multi_channel.luminance_alpha_all_zero"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025240, + "dEQP-GLES3.functional.texture.swizzle", + ".multi_channel.luminance_alpha_all_one"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025241, + "dEQP-GLES3.functional.texture.swizzl", + "e.multi_channel.luminance_alpha_bgra"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025242, + "dEQP-GLES3.functional.texture.swizzl", + "e.multi_channel.luminance_alpha_abgr"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025243, + "dEQP-GLES3.functional.texture.swizzle.mult", + "i_channel.luminance_alpha_one_one_red_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025244, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.red_all_red"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025245, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.red_all_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025246, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.red_all_blue"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025247, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.red_all_alpha"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025248, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.red_all_zero"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025249, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.red_all_one"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025250, + "dEQP-GLES3.functional.texture.", + "swizzle.multi_channel.red_bgra"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025251, + "dEQP-GLES3.functional.texture.", + "swizzle.multi_channel.red_abgr"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025252, + "dEQP-GLES3.functional.texture.swizzl", + "e.multi_channel.red_one_one_red_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025253, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.rg_all_red"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025254, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rg_all_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025255, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.rg_all_blue"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025256, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rg_all_alpha"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025257, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.rg_all_zero"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025258, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.rg_all_one"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025259, + "dEQP-GLES3.functional.texture", + ".swizzle.multi_channel.rg_bgra"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025260, + "dEQP-GLES3.functional.texture", + ".swizzle.multi_channel.rg_abgr"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025261, + "dEQP-GLES3.functional.texture.swizzl", + "e.multi_channel.rg_one_one_red_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025262, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.rgb_all_red"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025263, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rgb_all_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025264, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rgb_all_blue"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025265, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rgb_all_alpha"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025266, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rgb_all_zero"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025267, + "dEQP-GLES3.functional.texture.s", + "wizzle.multi_channel.rgb_all_one"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025268, + "dEQP-GLES3.functional.texture.", + "swizzle.multi_channel.rgb_bgra"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025269, + "dEQP-GLES3.functional.texture.", + "swizzle.multi_channel.rgb_abgr"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025270, + "dEQP-GLES3.functional.texture.swizzl", + "e.multi_channel.rgb_one_one_red_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025271, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rgba_all_red"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025272, + "dEQP-GLES3.functional.texture.swi", + "zzle.multi_channel.rgba_all_green"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025273, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rgba_all_blue"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025274, + "dEQP-GLES3.functional.texture.swi", + "zzle.multi_channel.rgba_all_alpha"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025275, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rgba_all_zero"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025276, + "dEQP-GLES3.functional.texture.sw", + "izzle.multi_channel.rgba_all_one"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025277, + "dEQP-GLES3.functional.texture.", + "swizzle.multi_channel.rgba_bgra"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025278, + "dEQP-GLES3.functional.texture.", + "swizzle.multi_channel.rgba_abgr"); + +static SHRINK_HWTEST_F(ActsDeqpgles30026TestSuite, TestCase_025279, + "dEQP-GLES3.functional.texture.swizzle", + ".multi_channel.rgba_one_one_red_green"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3texture_functions_textureTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3texture_functions_textureTestCase.cpp new file mode 100644 index 000000000..771d8e1ae --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3texture_functions_textureTestCase.cpp @@ -0,0 +1,244 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30017TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016825, + "dEQP-GLES3.functional.shaders.texture_f", + "unctions.texture.sampler2d_fixed_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016826, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.sampler2d_fixed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016827, + "dEQP-GLES3.functional.shaders.texture_f", + "unctions.texture.sampler2d_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016828, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.sampler2d_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016829, + "dEQP-GLES3.functional.shaders.textur", + "e_functions.texture.isampler2d_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016830, + "dEQP-GLES3.functional.shaders.texture", + "_functions.texture.isampler2d_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016831, + "dEQP-GLES3.functional.shaders.textur", + "e_functions.texture.usampler2d_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016832, + "dEQP-GLES3.functional.shaders.texture", + "_functions.texture.usampler2d_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016833, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.sampler2d_bias_fixed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016834, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.sampler2d_bias_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016835, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.isampler2d_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016836, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.usampler2d_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016837, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.samplercube_fixed_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016838, + "dEQP-GLES3.functional.shaders.texture_fun", + "ctions.texture.samplercube_fixed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016839, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.samplercube_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016840, + "dEQP-GLES3.functional.shaders.texture_fun", + "ctions.texture.samplercube_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016841, + "dEQP-GLES3.functional.shaders.texture", + "_functions.texture.isamplercube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016842, + "dEQP-GLES3.functional.shaders.texture_", + "functions.texture.isamplercube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016843, + "dEQP-GLES3.functional.shaders.texture", + "_functions.texture.usamplercube_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016844, + "dEQP-GLES3.functional.shaders.texture_", + "functions.texture.usamplercube_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016845, + "dEQP-GLES3.functional.shaders.texture_funct", + "ions.texture.samplercube_bias_fixed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016846, + "dEQP-GLES3.functional.shaders.texture_funct", + "ions.texture.samplercube_bias_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016847, + "dEQP-GLES3.functional.shaders.texture_fun", + "ctions.texture.isamplercube_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016848, + "dEQP-GLES3.functional.shaders.texture_fun", + "ctions.texture.usamplercube_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016849, + "dEQP-GLES3.functional.shaders.texture_fun", + "ctions.texture.sampler2darray_fixed_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016850, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.sampler2darray_fixed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016851, + "dEQP-GLES3.functional.shaders.texture_fun", + "ctions.texture.sampler2darray_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016852, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.sampler2darray_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016853, + "dEQP-GLES3.functional.shaders.texture_f", + "unctions.texture.isampler2darray_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016854, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.isampler2darray_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016855, + "dEQP-GLES3.functional.shaders.texture_f", + "unctions.texture.usampler2darray_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016856, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.usampler2darray_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016857, + "dEQP-GLES3.functional.shaders.texture_functio", + "ns.texture.sampler2darray_bias_fixed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016858, + "dEQP-GLES3.functional.shaders.texture_functio", + "ns.texture.sampler2darray_bias_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016859, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.isampler2darray_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016860, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.usampler2darray_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016861, + "dEQP-GLES3.functional.shaders.texture_f", + "unctions.texture.sampler3d_fixed_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016862, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.sampler3d_fixed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016863, + "dEQP-GLES3.functional.shaders.texture_f", + "unctions.texture.sampler3d_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016864, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.sampler3d_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016865, + "dEQP-GLES3.functional.shaders.textur", + "e_functions.texture.isampler3d_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016866, + "dEQP-GLES3.functional.shaders.texture", + "_functions.texture.isampler3d_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016867, + "dEQP-GLES3.functional.shaders.textur", + "e_functions.texture.usampler3d_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016868, + "dEQP-GLES3.functional.shaders.texture", + "_functions.texture.usampler3d_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016869, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.sampler3d_bias_fixed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016870, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.sampler3d_bias_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016871, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.isampler3d_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016872, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.usampler3d_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016873, + "dEQP-GLES3.functional.shaders.texture_f", + "unctions.texture.sampler2dshadow_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016874, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.sampler2dshadow_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016875, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.sampler2dshadow_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016876, + "dEQP-GLES3.functional.shaders.texture_fu", + "nctions.texture.samplercubeshadow_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016877, + "dEQP-GLES3.functional.shaders.texture_fun", + "ctions.texture.samplercubeshadow_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016878, + "dEQP-GLES3.functional.shaders.texture_funct", + "ions.texture.samplercubeshadow_bias_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30017TestSuite, TestCase_016879, + "dEQP-GLES3.functional.shaders.texture_func", + "tions.texture.sampler2darrayshadow_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3transpose_dynamicTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3transpose_dynamicTestCase.cpp new file mode 100644 index 000000000..f9952f8f5 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3transpose_dynamicTestCase.cpp @@ -0,0 +1,240 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30016TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015816, + "dEQP-GLES3.functional.shaders.matrix.t", + "ranspose.dynamic.lowp_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015817, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.lowp_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015818, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.mediump_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015819, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.mediump_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015820, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.highp_mat2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015821, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.highp_mat2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015822, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.lowp_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015823, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.lowp_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015824, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.mediump_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015825, + "dEQP-GLES3.functional.shaders.matrix.trans", + "pose.dynamic.mediump_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015826, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.highp_mat2x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015827, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.highp_mat2x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015828, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.lowp_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015829, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.lowp_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015830, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.mediump_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015831, + "dEQP-GLES3.functional.shaders.matrix.trans", + "pose.dynamic.mediump_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015832, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.highp_mat2x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015833, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.highp_mat2x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015834, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.lowp_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015835, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.lowp_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015836, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.mediump_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015837, + "dEQP-GLES3.functional.shaders.matrix.trans", + "pose.dynamic.mediump_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015838, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.highp_mat3x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015839, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.highp_mat3x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015840, + "dEQP-GLES3.functional.shaders.matrix.t", + "ranspose.dynamic.lowp_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015841, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.lowp_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015842, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.mediump_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015843, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.mediump_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015844, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.highp_mat3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015845, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.highp_mat3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015846, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.lowp_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015847, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.lowp_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015848, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.mediump_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015849, + "dEQP-GLES3.functional.shaders.matrix.trans", + "pose.dynamic.mediump_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015850, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.highp_mat3x4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015851, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.highp_mat3x4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015852, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.lowp_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015853, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.lowp_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015854, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.mediump_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015855, + "dEQP-GLES3.functional.shaders.matrix.trans", + "pose.dynamic.mediump_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015856, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.highp_mat4x2_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015857, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.highp_mat4x2_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015858, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.lowp_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015859, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.lowp_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015860, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.mediump_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015861, + "dEQP-GLES3.functional.shaders.matrix.trans", + "pose.dynamic.mediump_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015862, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.highp_mat4x3_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015863, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.highp_mat4x3_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015864, + "dEQP-GLES3.functional.shaders.matrix.t", + "ranspose.dynamic.lowp_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015865, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.lowp_mat4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015866, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.mediump_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015867, + "dEQP-GLES3.functional.shaders.matrix.tran", + "spose.dynamic.mediump_mat4_float_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015868, + "dEQP-GLES3.functional.shaders.matrix.tr", + "anspose.dynamic.highp_mat4_float_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30016TestSuite, TestCase_015869, + "dEQP-GLES3.functional.shaders.matrix.tra", + "nspose.dynamic.highp_mat4_float_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3uniform_block_validTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3uniform_block_validTestCase.cpp new file mode 100644 index 000000000..0950947a9 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3uniform_block_validTestCase.cpp @@ -0,0 +1,288 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30006TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005020, + "dEQP-GLES3.functional.shaders.uniform_blo", + "ck.valid.repeat_interface_qualifier_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005021, + "dEQP-GLES3.functional.shaders.uniform_bloc", + "k.valid.repeat_interface_qualifier_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005022, + "dEQP-GLES3.functional.shaders.unifo", + "rm_block.valid.layout_shared_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005023, + "dEQP-GLES3.functional.shaders.unifor", + "m_block.valid.layout_shared_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005024, + "dEQP-GLES3.functional.shaders.unifo", + "rm_block.valid.layout_packed_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005025, + "dEQP-GLES3.functional.shaders.unifor", + "m_block.valid.layout_packed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005026, + "dEQP-GLES3.functional.shaders.unifo", + "rm_block.valid.layout_std140_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005027, + "dEQP-GLES3.functional.shaders.unifor", + "m_block.valid.layout_std140_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005028, + "dEQP-GLES3.functional.shaders.unifor", + "m_block.valid.layout_row_major_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005029, + "dEQP-GLES3.functional.shaders.uniform", + "_block.valid.layout_row_major_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005030, + "dEQP-GLES3.functional.shaders.uniform_", + "block.valid.layout_column_major_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005031, + "dEQP-GLES3.functional.shaders.uniform_b", + "lock.valid.layout_column_major_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005032, + "dEQP-GLES3.functional.shaders.uni", + "form_block.valid.layout_all_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005033, + "dEQP-GLES3.functional.shaders.unif", + "orm_block.valid.layout_all_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005034, + "dEQP-GLES3.functional.shaders.uniform", + "_block.valid.layout_all_8_times_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005035, + "dEQP-GLES3.functional.shaders.uniform_", + "block.valid.layout_all_8_times_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005036, + "dEQP-GLES3.functional.shaders.uniform_", + "block.valid.global_layout_shared_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005037, + "dEQP-GLES3.functional.shaders.uniform_b", + "lock.valid.global_layout_shared_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005038, + "dEQP-GLES3.functional.shaders.uniform_", + "block.valid.global_layout_packed_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005039, + "dEQP-GLES3.functional.shaders.uniform_b", + "lock.valid.global_layout_packed_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005040, + "dEQP-GLES3.functional.shaders.uniform_", + "block.valid.global_layout_std140_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005041, + "dEQP-GLES3.functional.shaders.uniform_b", + "lock.valid.global_layout_std140_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005042, + "dEQP-GLES3.functional.shaders.uniform_bl", + "ock.valid.global_layout_row_major_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005043, + "dEQP-GLES3.functional.shaders.uniform_blo", + "ck.valid.global_layout_row_major_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005044, + "dEQP-GLES3.functional.shaders.uniform_blo", + "ck.valid.global_layout_column_major_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005045, + "dEQP-GLES3.functional.shaders.uniform_bloc", + "k.valid.global_layout_column_major_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005046, + "dEQP-GLES3.functional.shaders.uniform", + "_block.valid.global_layout_all_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005047, + "dEQP-GLES3.functional.shaders.uniform_", + "block.valid.global_layout_all_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005048, + "dEQP-GLES3.functional.shaders.uniform_blo", + "ck.valid.global_layout_all_8_times_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005049, + "dEQP-GLES3.functional.shaders.uniform_bloc", + "k.valid.global_layout_all_8_times_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005050, + "dEQP-GLES3.functional.shaders.uniform_bl", + "ock.valid.member_layout_row_major_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005051, + "dEQP-GLES3.functional.shaders.uniform_blo", + "ck.valid.member_layout_row_major_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005052, + "dEQP-GLES3.functional.shaders.uniform_blo", + "ck.valid.member_layout_column_major_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005053, + "dEQP-GLES3.functional.shaders.uniform_bloc", + "k.valid.member_layout_column_major_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005054, + "dEQP-GLES3.functional.shaders.uniform_bloc", + "k.valid.member_layout_row_major_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005055, + "dEQP-GLES3.functional.shaders.uniform_block", + ".valid.member_layout_row_major_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005056, + "dEQP-GLES3.functional.shaders.uniform_block.", + "valid.member_layout_column_major_vec4_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005057, + "dEQP-GLES3.functional.shaders.uniform_block.v", + "alid.member_layout_column_major_vec4_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005058, + "dEQP-GLES3.functional.shaders.uniform", + "_block.valid.member_layout_all_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005059, + "dEQP-GLES3.functional.shaders.uniform_", + "block.valid.member_layout_all_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005060, + "dEQP-GLES3.functional.shaders.uniform_blo", + "ck.valid.member_layout_all_8_times_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005061, + "dEQP-GLES3.functional.shaders.uniform_bloc", + "k.valid.member_layout_all_8_times_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005062, + "dEQP-GLES3.functional.shaders.unifor", + "m_block.valid.no_instance_name_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005063, + "dEQP-GLES3.functional.shaders.uniform", + "_block.valid.no_instance_name_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005064, + "dEQP-GLES3.functional.shaders.uniform_bloc", + "k.valid.same_variable_and_block_name_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005065, + "dEQP-GLES3.functional.shaders.uniform_block", + ".valid.same_variable_and_block_name_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005066, + "dEQP-GLES3.functional.shaders.uniform_block.", + "valid.same_variable_and_instance_name_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005067, + "dEQP-GLES3.functional.shaders.uniform_block.v", + "alid.same_variable_and_instance_name_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005068, + "dEQP-GLES3.functional.shaders.unifo", + "rm_block.valid.struct_member_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005069, + "dEQP-GLES3.functional.shaders.unifor", + "m_block.valid.struct_member_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005070, + "dEQP-GLES3.functional.shaders.uniform_block", + ".valid.struct_member_layout_row_major_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005071, + "dEQP-GLES3.functional.shaders.uniform_block.", + "valid.struct_member_layout_row_major_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005072, + "dEQP-GLES3.functional.shaders.uniform_block.v", + "alid.struct_member_layout_column_major_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005073, + "dEQP-GLES3.functional.shaders.uniform_block.va", + "lid.struct_member_layout_column_major_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005074, + "dEQP-GLES3.functional.shaders.uniform_bl", + "ock.valid.struct_member_layout_all_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005075, + "dEQP-GLES3.functional.shaders.uniform_blo", + "ck.valid.struct_member_layout_all_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005076, + "dEQP-GLES3.functional.shaders.uniform_block.", + "valid.struct_member_layout_all_8_times_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005077, + "dEQP-GLES3.functional.shaders.uniform_block.v", + "alid.struct_member_layout_all_8_times_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005078, + "dEQP-GLES3.functional.shaders.unifor", + "m_block.valid.long_block_name_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005079, + "dEQP-GLES3.functional.shaders.uniform", + "_block.valid.long_block_name_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005080, + "dEQP-GLES3.functional.shaders.uniform", + "_block.valid.long_instance_name_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005081, + "dEQP-GLES3.functional.shaders.uniform_", + "block.valid.long_instance_name_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005082, + "dEQP-GLES3.functional.shaders.uniform_b", + "lock.valid.underscore_block_name_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005083, + "dEQP-GLES3.functional.shaders.uniform_bl", + "ock.valid.underscore_block_name_fragment"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005084, + "dEQP-GLES3.functional.shaders.uniform_bl", + "ock.valid.underscore_instance_name_vertex"); + +static SHRINK_HWTEST_F(ActsDeqpgles30006TestSuite, TestCase_005085, + "dEQP-GLES3.functional.shaders.uniform_blo", + "ck.valid.underscore_instance_name_fragment"); diff --git a/graphic/vkgl/src/deqpgles3/functional/Deqpgles3write_basicTestCase.cpp b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3write_basicTestCase.cpp new file mode 100644 index 000000000..868ffd580 --- /dev/null +++ b/graphic/vkgl/src/deqpgles3/functional/Deqpgles3write_basicTestCase.cpp @@ -0,0 +1,312 @@ +/* + * 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 +#include "../Deqpgles3BaseFunc.h" +#include "../ActsDeqpgles30001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000089, + "dEQP-GLES3.functional.buffer.", + "write.basic.array_stream_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000090, + "dEQP-GLES3.functional.buffer.", + "write.basic.array_stream_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000091, + "dEQP-GLES3.functional.buffer.", + "write.basic.array_stream_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000092, + "dEQP-GLES3.functional.buffer.", + "write.basic.array_static_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000093, + "dEQP-GLES3.functional.buffer.", + "write.basic.array_static_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000094, + "dEQP-GLES3.functional.buffer.", + "write.basic.array_static_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000095, + "dEQP-GLES3.functional.buffer.", + "write.basic.array_dynamic_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000096, + "dEQP-GLES3.functional.buffer.", + "write.basic.array_dynamic_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000097, + "dEQP-GLES3.functional.buffer.", + "write.basic.array_dynamic_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000098, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_read_stream_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000099, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_read_stream_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000100, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_read_stream_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000101, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_read_static_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000102, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_read_static_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000103, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_read_static_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000104, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_read_dynamic_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000105, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_read_dynamic_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000106, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_read_dynamic_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000107, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_write_stream_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000108, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_write_stream_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000109, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_write_stream_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000110, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_write_static_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000111, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_write_static_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000112, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.copy_write_static_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000113, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.copy_write_dynamic_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000114, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.copy_write_dynamic_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000115, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.copy_write_dynamic_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000116, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.element_array_stream_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000117, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.element_array_stream_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000118, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.element_array_stream_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000119, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.element_array_static_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000120, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.element_array_static_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000121, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.element_array_static_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000122, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.element_array_dynamic_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000123, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.element_array_dynamic_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000124, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.element_array_dynamic_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000125, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.pixel_pack_stream_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000126, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.pixel_pack_stream_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000127, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.pixel_pack_stream_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000128, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.pixel_pack_static_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000129, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.pixel_pack_static_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000130, + "dEQP-GLES3.functional.buffer.wr", + "ite.basic.pixel_pack_static_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000131, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.pixel_pack_dynamic_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000132, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.pixel_pack_dynamic_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000133, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.pixel_pack_dynamic_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000134, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.pixel_unpack_stream_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000135, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.pixel_unpack_stream_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000136, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.pixel_unpack_stream_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000137, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.pixel_unpack_static_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000138, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.pixel_unpack_static_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000139, + "dEQP-GLES3.functional.buffer.wri", + "te.basic.pixel_unpack_static_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000140, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.pixel_unpack_dynamic_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000141, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.pixel_unpack_dynamic_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000142, + "dEQP-GLES3.functional.buffer.writ", + "e.basic.pixel_unpack_dynamic_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000143, + "dEQP-GLES3.functional.buffer.write.", + "basic.transform_feedback_stream_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000144, + "dEQP-GLES3.functional.buffer.write.", + "basic.transform_feedback_stream_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000145, + "dEQP-GLES3.functional.buffer.write.", + "basic.transform_feedback_stream_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000146, + "dEQP-GLES3.functional.buffer.write.", + "basic.transform_feedback_static_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000147, + "dEQP-GLES3.functional.buffer.write.", + "basic.transform_feedback_static_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000148, + "dEQP-GLES3.functional.buffer.write.", + "basic.transform_feedback_static_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000149, + "dEQP-GLES3.functional.buffer.write.b", + "asic.transform_feedback_dynamic_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000150, + "dEQP-GLES3.functional.buffer.write.b", + "asic.transform_feedback_dynamic_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000151, + "dEQP-GLES3.functional.buffer.write.b", + "asic.transform_feedback_dynamic_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000152, + "dEQP-GLES3.functional.buffer.w", + "rite.basic.uniform_stream_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000153, + "dEQP-GLES3.functional.buffer.w", + "rite.basic.uniform_stream_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000154, + "dEQP-GLES3.functional.buffer.w", + "rite.basic.uniform_stream_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000155, + "dEQP-GLES3.functional.buffer.w", + "rite.basic.uniform_static_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000156, + "dEQP-GLES3.functional.buffer.w", + "rite.basic.uniform_static_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000157, + "dEQP-GLES3.functional.buffer.w", + "rite.basic.uniform_static_copy"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000158, + "dEQP-GLES3.functional.buffer.w", + "rite.basic.uniform_dynamic_draw"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000159, + "dEQP-GLES3.functional.buffer.w", + "rite.basic.uniform_dynamic_read"); + +static SHRINK_HWTEST_F(ActsDeqpgles30001TestSuite, TestCase_000160, + "dEQP-GLES3.functional.buffer.w", + "rite.basic.uniform_dynamic_copy"); -- GitLab