From c0fef8d73866eb36b140cd60c77c921bcd39fc00 Mon Sep 17 00:00:00 2001 From: wangshi Date: Tue, 5 Jul 2022 09:27:29 +0800 Subject: [PATCH] add depq2 testcase Signed-off-by: wangshi --- ...sign_full_multiple_basic_arrayTestCase.cpp | 103 ++++++++++ ...n_partial_multiple_basic_arrayTestCase.cpp | 103 ++++++++++ ...es2binary_operator_logical_andTestCase.cpp | 76 ++++++++ ...les2binary_operator_logical_orTestCase.cpp | 76 ++++++++ ...es2binary_operator_logical_xorTestCase.cpp | 76 ++++++++ .../Deqpgles2bool_compare_allTestCase.cpp | 184 ++++++++++++++++++ .../Deqpgles2bool_compare_anyTestCase.cpp | 184 ++++++++++++++++++ .../Deqpgles2bool_compare_notTestCase.cpp | 184 ++++++++++++++++++ .../Deqpgles2completeness_sizeTestCase.cpp | 76 ++++++++ .../Deqpgles2cube_basicTestCase.cpp | 76 ++++++++ .../functional/Deqpgles2cube_biasTestCase.cpp | 76 ++++++++ .../Deqpgles2cube_projectedTestCase.cpp | 76 ++++++++ ...qpgles2functional_debug_markerTestCase.cpp | 103 ++++++++++ ...qpgles2functional_flush_finishTestCase.cpp | 157 +++++++++++++++ ...multisampled_render_to_textureTestCase.cpp | 49 +++++ ...qpgles2functional_prerequisiteTestCase.cpp | 103 ++++++++++ 16 files changed, 1702 insertions(+) create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2basic_array_assign_full_multiple_basic_arrayTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2basic_array_assign_partial_multiple_basic_arrayTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_andTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_orTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_xorTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_allTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_anyTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_notTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2completeness_sizeTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_basicTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_biasTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_projectedTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_debug_markerTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_flush_finishTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_multisampled_render_to_textureTestCase.cpp create mode 100644 graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_prerequisiteTestCase.cpp diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2basic_array_assign_full_multiple_basic_arrayTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2basic_array_assign_full_multiple_basic_arrayTestCase.cpp new file mode 100644 index 000000000..ad26270b8 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2basic_array_assign_full_multiple_basic_arrayTestCase.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_015089, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015089 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.b" + "asic_array_assign_full.multiple_basic_array.vertex", + "--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_015089 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015089 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015090, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015090 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.ba" + "sic_array_assign_full.multiple_basic_array.fragment", + "--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_015090 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015090 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015091, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015091 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "basic_array_assign_full.multiple_basic_array.both", + "--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_015091 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015091 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2basic_array_assign_partial_multiple_basic_arrayTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2basic_array_assign_partial_multiple_basic_arrayTestCase.cpp new file mode 100644 index 000000000..36a4ea79d --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2basic_array_assign_partial_multiple_basic_arrayTestCase.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_015131, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015131 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.ba" + "sic_array_assign_partial.multiple_basic_array.vertex", + "--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_015131 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015131 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015132, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015132 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.bas" + "ic_array_assign_partial.multiple_basic_array.fragment", + "--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_015132 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015132 end"; +} + +static HWTEST_F(ActsDeqpgles20016TestSuite, TestCase_015133, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015133 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.b" + "asic_array_assign_partial.multiple_basic_array.both", + "--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_015133 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015133 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_andTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_andTestCase.cpp new file mode 100644 index 000000000..c525c5671 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_andTestCase.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 "../ActsDeqpgles20006TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20006TestSuite, TestCase_005726, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_005726 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operator." + "binary_operator.logical_and.bool_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20006TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20006TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20006TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20006TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20006TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_005726 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_005726 end"; +} + +static HWTEST_F(ActsDeqpgles20006TestSuite, TestCase_005727, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_005727 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operator.b" + "inary_operator.logical_and.bool_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20006TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20006TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20006TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20006TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20006TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_005727 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_005727 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_orTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_orTestCase.cpp new file mode 100644 index 000000000..7c4ba86db --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_orTestCase.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 "../ActsDeqpgles20006TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20006TestSuite, TestCase_005728, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_005728 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operator" + ".binary_operator.logical_or.bool_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20006TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20006TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20006TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20006TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20006TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_005728 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_005728 end"; +} + +static HWTEST_F(ActsDeqpgles20006TestSuite, TestCase_005729, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_005729 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operator." + "binary_operator.logical_or.bool_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20006TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20006TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20006TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20006TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20006TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_005729 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_005729 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_xorTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_xorTestCase.cpp new file mode 100644 index 000000000..8628e4ec9 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2binary_operator_logical_xorTestCase.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 "../ActsDeqpgles20006TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20006TestSuite, TestCase_005730, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_005730 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operator." + "binary_operator.logical_xor.bool_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20006TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20006TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20006TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20006TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20006TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_005730 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_005730 end"; +} + +static HWTEST_F(ActsDeqpgles20006TestSuite, TestCase_005731, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_005731 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.operator.b" + "inary_operator.logical_xor.bool_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20006TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20006TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20006TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20006TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20006TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_005731 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_005731 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_allTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_allTestCase.cpp new file mode 100644 index 000000000..06a8947ab --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_allTestCase.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 "../ActsDeqpgles20007TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006762, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006762 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.bool_compare.all.bvec2_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_006762 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006762 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006763, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006763 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.bool_compare.all.bvec2_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_006763 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006763 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006764, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006764 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.bool_compare.all.bvec3_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_006764 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006764 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006765, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006765 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.bool_compare.all.bvec3_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_006765 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006765 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006766, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006766 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.bool_compare.all.bvec4_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_006766 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006766 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006767, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006767 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.bool_compare.all.bvec4_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_006767 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006767 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_anyTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_anyTestCase.cpp new file mode 100644 index 000000000..c9075c1d3 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_anyTestCase.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 "../ActsDeqpgles20007TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006756, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006756 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.bool_compare.any.bvec2_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_006756 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006756 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006757, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006757 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.bool_compare.any.bvec2_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_006757 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006757 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006758, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006758 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.bool_compare.any.bvec3_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_006758 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006758 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006759, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006759 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.bool_compare.any.bvec3_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_006759 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006759 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006760, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006760 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.bool_compare.any.bvec4_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_006760 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006760 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006761, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006761 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.bool_compare.any.bvec4_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_006761 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006761 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_notTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_notTestCase.cpp new file mode 100644 index 000000000..4d7c12b97 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2bool_compare_notTestCase.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 "../ActsDeqpgles20007TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006768, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006768 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.bool_compare.not.bvec2_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_006768 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006768 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006769, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006769 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.bool_compare.not.bvec2_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_006769 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006769 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006770, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006770 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.bool_compare.not.bvec3_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_006770 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006770 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006771, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006771 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.bool_compare.not.bvec3_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_006771 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006771 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006772, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006772 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.oper" + "ator.bool_compare.not.bvec4_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_006772 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006772 end"; +} + +static HWTEST_F(ActsDeqpgles20007TestSuite, TestCase_006773, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_006773 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.opera" + "tor.bool_compare.not.bvec4_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_006773 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_006773 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2completeness_sizeTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2completeness_sizeTestCase.cpp new file mode 100644 index 000000000..da2c63a6f --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2completeness_sizeTestCase.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 "../ActsDeqpgles20014TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013017, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013017 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fb" + "o.completeness.size.zero", + "--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_013017 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013017 end"; +} + +static HWTEST_F(ActsDeqpgles20014TestSuite, TestCase_013018, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_013018 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.fbo." + "completeness.size.distinct", + "--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_013018 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_013018 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_basicTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_basicTestCase.cpp new file mode 100644 index 000000000..0b2f91eaa --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_basicTestCase.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 "../ActsDeqpgles20011TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010657, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010657 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture.m" + "ipmap.cube.basic.linear_nearest", + "--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_010657 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010657 end"; +} + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010658, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010658 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture." + "mipmap.cube.basic.linear_linear", + "--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_010658 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010658 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_biasTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_biasTestCase.cpp new file mode 100644 index 000000000..59c299dfe --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_biasTestCase.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 "../ActsDeqpgles20011TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010661, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010661 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture." + "mipmap.cube.bias.linear_nearest", + "--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_010661 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010661 end"; +} + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010662, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010662 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture." + "mipmap.cube.bias.linear_linear", + "--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_010662 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010662 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_projectedTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_projectedTestCase.cpp new file mode 100644 index 000000000..50cc279be --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2cube_projectedTestCase.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 "../ActsDeqpgles20011TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010659, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010659 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture.mip" + "map.cube.projected.linear_nearest", + "--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_010659 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010659 end"; +} + +static HWTEST_F(ActsDeqpgles20011TestSuite, TestCase_010660, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_010660 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.texture.mi" + "pmap.cube.projected.linear_linear", + "--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_010660 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_010660 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_debug_markerTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_debug_markerTestCase.cpp new file mode 100644 index 000000000..ad4cedb11 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_debug_markerTestCase.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_016490, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016490 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional." + "debug_marker.supported", + "--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_016490 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016490 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016491, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016491 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functiona" + "l.debug_marker.random", + "--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_016491 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016491 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016492, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016492 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional" + ".debug_marker.invalid", + "--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_016492 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016492 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_flush_finishTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_flush_finishTestCase.cpp new file mode 100644 index 000000000..be14e6518 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_flush_finishTestCase.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 "../ActsDeqpgles20017TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016412, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016412 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.function" + "al.flush_finish.wait", + "--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_016412 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016412 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016413, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016413 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functiona" + "l.flush_finish.flush", + "--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_016413 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016413 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016414, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016414 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional." + "flush_finish.flush_wait", + "--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_016414 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016414 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016415, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016415 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functiona" + "l.flush_finish.finish", + "--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_016415 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016415 end"; +} + +static HWTEST_F(ActsDeqpgles20017TestSuite, TestCase_016416, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_016416 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.f" + "lush_finish.finish_wait", + "--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_016416 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_016416 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_multisampled_render_to_textureTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_multisampled_render_to_textureTestCase.cpp new file mode 100644 index 000000000..0cee35971 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_multisampled_render_to_textureTestCase.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 "../ActsDeqpgles20001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000132, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000132 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.multisamp" + "led_render_to_texture.readpixels", + "--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_000132 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000132 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_prerequisiteTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_prerequisiteTestCase.cpp new file mode 100644 index 000000000..2b579bba9 --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2functional_prerequisiteTestCase.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 "../ActsDeqpgles20001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000007, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000007 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.p" + "rerequisite.state_reset", + "--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_000007 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000007 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000008, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000008 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.p" + "rerequisite.clear_color", + "--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_000008 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000008 end"; +} + +static HWTEST_F(ActsDeqpgles20001TestSuite, TestCase_000009, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000009 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.p" + "rerequisite.read_pixels", + "--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_000009 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000009 end"; +} -- GitLab