From 9c16d02c59adabf0d64afdd4b759a19cdf9a9c24 Mon Sep 17 00:00:00 2001 From: wangshi Date: Tue, 5 Jul 2022 09:28:24 +0800 Subject: [PATCH] add depq2 testcase Signed-off-by: wangshi --- .../Deqpgles22d_projectedTestCase.cpp | 130 +++++++++++++ .../Deqpgles2attach_deleted_inputTestCase.cpp | 103 ++++++++++ .../Deqpgles2attach_deleted_nameTestCase.cpp | 103 ++++++++++ ...Deqpgles2attach_deleted_outputTestCase.cpp | 1 - ...s2attribute_location_bind_timeTestCase.cpp | 157 +++++++++++++++ .../Deqpgles2geometric_crossTestCase.cpp | 130 +++++++++++++ ...pgles2misc_compound_assignmentTestCase.cpp | 76 ++++++++ ...Deqpgles2preprocessor_semanticTestCase.cpp | 130 +++++++++++++ ...pgles2rasterization_fill_rulesTestCase.cpp | 157 +++++++++++++++ .../Deqpgles2rasterization_limitsTestCase.cpp | 49 +++++ ...qpgles2shader_api_compile_linkTestCase.cpp | 103 ++++++++++ ...pgles2shader_api_create_deleteTestCase.cpp | 103 ++++++++++ .../Deqpgles2shaders_algorithmTestCase.cpp | 130 +++++++++++++ ...gles2state_query_buffer_objectTestCase.cpp | 76 ++++++++ .../Deqpgles2state_query_fboTestCase.cpp | 103 ++++++++++ .../Deqpgles2state_query_rboTestCase.cpp | 130 +++++++++++++ .../Deqpgles2state_query_stringTestCase.cpp | 157 +++++++++++++++ ...gles2texture_functions_invalidTestCase.cpp | 49 +++++ .../Deqpgles2unary_operator_notTestCase.cpp | 76 ++++++++ .../Deqpgles2use_index_arrayTestCase.cpp | 76 ++++++++ .../Deqpgles2use_vertex_arrayTestCase.cpp | 76 ++++++++ .../Deqpgles2variables_validTestCase.cpp | 103 ++++++++++ .../Deqpgles2write_basicTestCase.cpp | 184 ++++++++++++++++++ 23 files changed, 2401 insertions(+), 1 deletion(-) create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles22d_projectedTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_inputTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_nameTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2attribute_location_bind_timeTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2geometric_crossTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2misc_compound_assignmentTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_semanticTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2rasterization_fill_rulesTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2rasterization_limitsTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2shader_api_compile_linkTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2shader_api_create_deleteTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2shaders_algorithmTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_buffer_objectTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_fboTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_rboTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_stringTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2texture_functions_invalidTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2unary_operator_notTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2use_index_arrayTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2use_vertex_arrayTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2variables_validTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2write_basicTestCase.cpp diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles22d_projectedTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles22d_projectedTestCase.cpp new file mode 100644 index 000000000..dc083f43a --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles22d_projectedTestCase.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20011TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010621, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010621 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture.mipma" + "p.2d.projected.nearest_linear_clamp", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20011TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20011TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20011TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20011TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20011TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_010621 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010621 end"; +} + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010622, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010622 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture.mipma" + "p.2d.projected.nearest_linear_repeat", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20011TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20011TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20011TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20011TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20011TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_010622 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010622 end"; +} + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010623, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010623 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture.mipma" + "p.2d.projected.nearest_linear_mirror", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20011TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20011TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20011TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20011TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20011TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_010623 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010623 end"; +} + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010624, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010624 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture.mipma" + "p.2d.projected.linear_linear_repeat", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20011TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20011TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20011TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20011TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20011TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_010624 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010624 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_inputTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_inputTestCase.cpp new file mode 100644 index 000000000..b5463ba03 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_inputTestCase.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20017TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016485, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016485 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.lifetime.atta" + "ch.deleted_input.texture_framebuffer", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20017TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20017TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20017TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20017TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20017TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_016485 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016485 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016486, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016486 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.lifetime.attach." + "deleted_input.renderbuffer_framebuffer", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20017TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20017TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20017TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20017TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20017TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_016486 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016486 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016487, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016487 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.lifetime.at" + "tach.deleted_input.shader_program", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20017TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20017TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20017TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20017TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20017TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_016487 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016487 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_nameTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_nameTestCase.cpp new file mode 100644 index 000000000..fab03cb4d --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_nameTestCase.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20017TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016482, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016482 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.lifetime.atta" + "ch.deleted_name.texture_framebuffer", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20017TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20017TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20017TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20017TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20017TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_016482 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016482 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016483, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016483 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.lifetime.attach" + ".deleted_name.renderbuffer_framebuffer", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20017TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20017TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20017TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20017TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20017TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_016483 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016483 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016484, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016484 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.lifetime.a" + "ttach.deleted_name.shader_program", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20017TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20017TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20017TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20017TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20017TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_016484 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016484 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_outputTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_outputTestCase.cpp index 2f639b95e..3580e5430 100644 --- a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_outputTestCase.cpp +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attach_deleted_outputTestCase.cpp @@ -13,7 +13,6 @@ * limitations under the License. */ -#include #include #include "../Deqpgles2BaseFunc.h" #include "../ActsDeqpgles20017TestSuite.h" diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attribute_location_bind_timeTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attribute_location_bind_timeTestCase.cpp new file mode 100644 index 000000000..fec7d1ddc --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2attribute_location_bind_timeTestCase.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20014TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013964, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013964 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.attribut" + "e_location.bind_time.pre_attach", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013964 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013964 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013965, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013965 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.attribu" + "te_location.bind_time.pre_link", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013965 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013965 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013966, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013966 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.attribut" + "e_location.bind_time.post_link", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013966 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013966 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013967, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013967 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.attrib" + "ute_location.bind_time.relink", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013967 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013967 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013968, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013968 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.attribu" + "te_location.bind_time.reattach", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013968 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013968 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2geometric_crossTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2geometric_crossTestCase.cpp new file mode 100644 index 000000000..9061f9f06 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2geometric_crossTestCase.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20007TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006460, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006460 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operato" + "r.geometric.cross.mediump_vec3_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20007TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20007TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20007TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20007TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20007TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_006460 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006460 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006461, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006461 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operator" + ".geometric.cross.mediump_vec3_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20007TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20007TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20007TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20007TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20007TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_006461 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006461 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006462, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006462 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operat" + "or.geometric.cross.highp_vec3_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20007TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20007TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20007TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20007TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20007TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_006462 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006462 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006463, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006463 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operato" + "r.geometric.cross.highp_vec3_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20007TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20007TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20007TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20007TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20007TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_006463 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006463 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2misc_compound_assignmentTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2misc_compound_assignmentTestCase.cpp new file mode 100644 index 000000000..1cb6f2726 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2misc_compound_assignmentTestCase.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002737, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002737 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.misc.compound_" + "assignment.mul_swizzled_vec_by_matrix_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002737 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002737 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002738, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002738 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.misc.compound_a" + "ssignment.mul_swizzled_vec_by_matrix_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002738 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002738 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_semanticTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_semanticTestCase.cpp new file mode 100644 index 000000000..78d5e660a --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2preprocessor_semanticTestCase.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000269, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000269 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.preproc" + "essor.semantic.ops_as_arguments_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000269 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000269 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000270, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000270 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.preproce" + "ssor.semantic.ops_as_arguments_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000270 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000270 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000271, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000271 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.prepro" + "cessor.semantic.correct_order_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000271 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000271 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000272, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000272 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.preproc" + "essor.semantic.correct_order_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000272 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000272 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2rasterization_fill_rulesTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2rasterization_fill_rulesTestCase.cpp new file mode 100644 index 000000000..eb06801c7 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2rasterization_fill_rulesTestCase.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20014TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013885, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013885 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.raster" + "ization.fill_rules.basic_quad", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013885 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013885 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013886, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013886 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.rasterizat" + "ion.fill_rules.basic_quad_reverse", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013886 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013886 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013887, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013887 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.rasteri" + "zation.fill_rules.clipped_full", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013887 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013887 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013888, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013888 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.rasteriz" + "ation.fill_rules.clipped_partly", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013888 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013888 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013889, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013889 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.raster" + "ization.fill_rules.projected", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013889 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013889 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2rasterization_limitsTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2rasterization_limitsTestCase.cpp new file mode 100644 index 000000000..80a87faa5 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2rasterization_limitsTestCase.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20014TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013884, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013884 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.ra" + "sterization.limits.points", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013884 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013884 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shader_api_compile_linkTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shader_api_compile_linkTestCase.cpp new file mode 100644 index 000000000..a880846db --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shader_api_compile_linkTestCase.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20014TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013593, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013593 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader_api." + "compile_link.compile_vertex_shader", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013593 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013593 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013594, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013594 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader_api.c" + "ompile_link.compile_fragment_shader", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013594 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013594 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013595, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013595 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader_api." + "compile_link.link_vertex_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013595 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013595 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shader_api_create_deleteTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shader_api_create_deleteTestCase.cpp new file mode 100644 index 000000000..647dadfd2 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shader_api_create_deleteTestCase.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20014TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013590, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013590 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader_api." + "create_delete.create_vertex_shader", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013590 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013590 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013591, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013591 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader_api.c" + "reate_delete.create_fragment_shader", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013591 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013591 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013592, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013592 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader_api.c" + "reate_delete.delete_vertex_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20014TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20014TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20014TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20014TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20014TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_013592 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013592 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shaders_algorithmTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shaders_algorithmTestCase.cpp new file mode 100644 index 000000000..4d04ca7fd --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shaders_algorithmTestCase.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20008TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007866, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007866 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader" + "s.algorithm.hsl_to_rgb_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007866 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007866 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007867, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007867 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders" + ".algorithm.hsl_to_rgb_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007867 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007867 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007868, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007868 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader" + "s.algorithm.rgb_to_hsl_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007868 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007868 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007869, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007869 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders" + ".algorithm.rgb_to_hsl_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007869 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007869 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_buffer_objectTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_buffer_objectTestCase.cpp new file mode 100644 index 000000000..e2448a606 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_buffer_objectTestCase.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20016TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015653, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015653 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state_query.buffe" + "r_object.buffer_size_getbufferparameteri", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015653 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015653 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015654, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015654 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state_query.buffer" + "_object.buffer_usage_getbufferparameteri", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015654 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015654 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_fboTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_fboTestCase.cpp new file mode 100644 index 000000000..c0ba63226 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_fboTestCase.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20016TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015655, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015655 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state_query" + ".fbo.framebuffer_attachment_object", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015655 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015655 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015656, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015656 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state_query.fbo" + ".framebuffer_attachment_texture_level", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015656 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015656 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015657, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015657 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state_query.fbo.fra" + "mebuffer_attachment_texture_cube_map_face", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015657 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015657 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_rboTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_rboTestCase.cpp new file mode 100644 index 000000000..3a3d1e3b6 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_rboTestCase.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20016TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015658, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015658 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state" + "_query.rbo.renderbuffer_size", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015658 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015658 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015659, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015659 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state_query" + ".rbo.renderbuffer_internal_format", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015659 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015659 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015660, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015660 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state_query.r" + "bo.renderbuffer_component_size_color", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015660 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015660 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015661, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015661 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state_query.r" + "bo.renderbuffer_component_size_depth", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015661 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015661 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_stringTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_stringTestCase.cpp new file mode 100644 index 000000000..43118c13b --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2state_query_stringTestCase.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20016TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015648, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015648 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.st" + "ate_query.string.renderer", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015648 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015648 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015649, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015649 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.s" + "tate_query.string.vendor", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015649 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015649 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015650, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015650 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.st" + "ate_query.string.version", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015650 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015650 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015651, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015651 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.state_quer" + "y.string.shading_language_version", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015651 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015651 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015652, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015652 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.sta" + "te_query.string.extensions", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20016TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20016TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20016TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20016TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20016TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015652 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015652 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2texture_functions_invalidTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2texture_functions_invalidTestCase.cpp new file mode 100644 index 000000000..c32d3d7d3 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2texture_functions_invalidTestCase.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20008TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007822, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007822 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.texture_fun" + "ctions.invalid.texturecubelod_in_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007822 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007822 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2unary_operator_notTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2unary_operator_notTestCase.cpp new file mode 100644 index 000000000..2d924df78 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2unary_operator_notTestCase.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20005TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20005TestSuite, TestCase_004028, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_004028 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.unary_operator.not.bool_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20005TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20005TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20005TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20005TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20005TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_004028 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_004028 end"; +} + +static HWTEST_F(ActsDeqpgles20005TestSuite, TestCase_004029, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_004029 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.unary_operator.not.bool_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20005TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20005TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20005TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20005TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20005TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_004029 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_004029 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2use_index_arrayTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2use_index_arrayTestCase.cpp new file mode 100644 index 000000000..b9185b8de --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2use_index_arrayTestCase.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000072, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000072 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer" + ".write.use.index_array.array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000072 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000072 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000073, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000073 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer.wri" + "te.use.index_array.element_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000073 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000073 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2use_vertex_arrayTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2use_vertex_arrayTestCase.cpp new file mode 100644 index 000000000..0c759bcea --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2use_vertex_arrayTestCase.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000070, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000070 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer" + ".write.use.vertex_array.array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000070 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000070 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000071, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000071 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer.wri" + "te.use.vertex_array.element_array", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000071 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000071 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2variables_validTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2variables_validTestCase.cpp new file mode 100644 index 000000000..97683356f --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2variables_validTestCase.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002371, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002371 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.qualification_or" + "der.variables.valid.invariant_storage_precision", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002371 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002371 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002372, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002372 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.qualificati" + "on_order.variables.valid.storage_precision", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002372 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002372 end"; +} + +static HWTEST_F(ActsDeqpgles20003TestSuite, TestCase_002373, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002373 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.qualificati" + "on_order.variables.valid.invariant_storage", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20003TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20003TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20003TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002373 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002373 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2write_basicTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2write_basicTestCase.cpp new file mode 100644 index 000000000..db8767aaa --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2write_basicTestCase.cpp @@ -0,0 +1,184 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000064, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000064 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer." + "write.basic.array_stream_draw", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000064 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000064 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000065, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000065 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer." + "write.basic.array_static_draw", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000065 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000065 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000066, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000066 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer." + "write.basic.array_dynamic_draw", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000066 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000066 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000067, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000067 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer.writ" + "e.basic.element_array_stream_draw", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000067 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000067 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000068, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000068 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer.writ" + "e.basic.element_array_static_draw", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000068 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000068 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000069, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000069 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.buffer.writ" + "e.basic.element_array_dynamic_draw", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20001TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20001TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20001TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000069 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000069 end"; +} -- GitLab