From 857e87f7d8b7c5a233c60beb0f89af9c41fe1a4f Mon Sep 17 00:00:00 2001 From: peibibao Date: Mon, 27 Jun 2022 20:26:35 +0800 Subject: [PATCH] add testcase Signed-off-by: peibibao --- ...hrgles31core_shader_group_voteTestCase.cpp | 157 ++++++++++++++++++ ...Khrgles31geometry_shader_inputTestCase.cpp | 130 +++++++++++++++ ...try_shader_layered_framebufferTestCase.cpp | 130 +++++++++++++++ ...late_at_centroid_check_rgba32fTestCase.cpp | 103 ++++++++++++ ...polate_at_centroid_check_rgba8TestCase.cpp | 103 ++++++++++++ ...olate_at_centroid_check_rgba8iTestCase.cpp | 103 ++++++++++++ ...late_at_centroid_check_rgba8uiTestCase.cpp | 103 ++++++++++++ ...polate_at_offset_check_rgba32fTestCase.cpp | 103 ++++++++++++ ...rpolate_at_offset_check_rgba8iTestCase.cpp | 103 ++++++++++++ ...polate_at_offset_check_rgba8uiTestCase.cpp | 103 ++++++++++++ ...erpolate_at_sample_check_rgba8TestCase.cpp | 103 ++++++++++++ ...rpolate_at_sample_check_rgba8iTestCase.cpp | 103 ++++++++++++ ...itfield_operation_packSnorm4x8TestCase.cpp | 130 +++++++++++++++ ...itfield_operation_packUnorm4x8TestCase.cpp | 130 +++++++++++++++ ...field_operation_unpackUnorm4x8TestCase.cpp | 130 +++++++++++++++ ..._shader_triangles_tessellationTestCase.cpp | 103 ++++++++++++ ...storage_multisample_GLCoverageTestCase.cpp | 130 +++++++++++++++ 17 files changed, 1967 insertions(+) create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31core_shader_group_voteTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_inputTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_layered_framebufferTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba32fTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8iTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8uiTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba32fTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba8iTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba8uiTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_sample_check_rgba8TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_sample_check_rgba8iTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_packSnorm4x8TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_packUnorm4x8TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_unpackUnorm4x8TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31tessellation_shader_tessellation_shader_triangles_tessellationTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31texture_storage_multisample_GLCoverageTestCase.cpp diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31core_shader_group_voteTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31core_shader_group_voteTestCase.cpp new file mode 100644 index 000000000..8ca5b71a2 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31core_shader_group_voteTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002261, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002261 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_" + "group_vote.availability", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002261 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002261 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002262, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002262 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_g" + "roup_vote.all_invocations", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002262 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002262 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002263, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002263 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_g" + "roup_vote.any_invocation", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002263 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002263 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002264, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002264 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_grou" + "p_vote.all_invocations_equal", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002264 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002264 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002265, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002265 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_group_v" + "ote.invocations_with_variables", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002265 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002265 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_inputTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_inputTestCase.cpp new file mode 100644 index 000000000..90595454f --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_inputTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002450, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002450 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_shad" + "er.input.gl_in_array_contents", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002450 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002450 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002451, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002451 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_sha" + "der.input.gl_in_array_length", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002451 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002451 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002452, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002452 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_sha" + "der.input.gl_pointsize_value", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002452 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002452 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002453, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002453 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_sh" + "ader.input.gl_position_value", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002453 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002453 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_layered_framebufferTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_layered_framebufferTestCase.cpp new file mode 100644 index 000000000..e13a14006 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_layered_framebufferTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002482, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002482 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_shader.l" + "ayered_framebuffer.stencil_support", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002482 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002482 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002483, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002483 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_shader." + "layered_framebuffer.depth_support", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002483 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002483 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002484, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002484 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_shader.la" + "yered_framebuffer.blending_support", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002484 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002484 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002485, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002485 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_shader.lay" + "ered_framebuffer.clear_call_support", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002485 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002485 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba32fTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba32fTestCase.cpp new file mode 100644 index 000000000..1a15d91f2 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba32fTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000742, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000742 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.re" + "nder.interpolate_at_centroid_check.rgba32f.samples_1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000742 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000742 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000743, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000743 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.re" + "nder.interpolate_at_centroid_check.rgba32f.samples_2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000743 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000743 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000744, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000744 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.re" + "nder.interpolate_at_centroid_check.rgba32f.samples_4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000744 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000744 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8TestCase.cpp new file mode 100644 index 000000000..3bf0f1c9c --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8TestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000733, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000733 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_centroid_check.rgba8.samples_1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000733 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000733 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000734, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000734 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_centroid_check.rgba8.samples_2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000734 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000734 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000735, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000735 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_centroid_check.rgba8.samples_4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000735 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000735 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8iTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8iTestCase.cpp new file mode 100644 index 000000000..e02b8bd77 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8iTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000736, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000736 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.re" + "nder.interpolate_at_centroid_check.rgba8i.samples_1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000736 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000736 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000737, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000737 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.re" + "nder.interpolate_at_centroid_check.rgba8i.samples_2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000737 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000737 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000738, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000738 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.re" + "nder.interpolate_at_centroid_check.rgba8i.samples_4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000738 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000738 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8uiTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8uiTestCase.cpp new file mode 100644 index 000000000..e5a041aa6 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_centroid_check_rgba8uiTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000739, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000739 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.re" + "nder.interpolate_at_centroid_check.rgba8ui.samples_1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000739 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000739 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000740, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000740 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.re" + "nder.interpolate_at_centroid_check.rgba8ui.samples_2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000740 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000740 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000741, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000741 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.re" + "nder.interpolate_at_centroid_check.rgba8ui.samples_4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000741 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000741 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba32fTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba32fTestCase.cpp new file mode 100644 index 000000000..e5d4ac3cf --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba32fTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000766, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000766 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_offset_check.rgba32f.samples_1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000766 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000766 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000767, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000767 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_offset_check.rgba32f.samples_2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000767 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000767 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000768, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000768 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_offset_check.rgba32f.samples_4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000768 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000768 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba8iTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba8iTestCase.cpp new file mode 100644 index 000000000..f49af820b --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba8iTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000760, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000760 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_offset_check.rgba8i.samples_1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000760 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000760 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000761, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000761 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_offset_check.rgba8i.samples_2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000761 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000761 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000762, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000762 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_offset_check.rgba8i.samples_4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000762 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000762 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba8uiTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba8uiTestCase.cpp new file mode 100644 index 000000000..957f85565 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_offset_check_rgba8uiTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000763, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000763 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_offset_check.rgba8ui.samples_1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000763 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000763 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000764, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000764 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_offset_check.rgba8ui.samples_2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000764 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000764 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000765, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000765 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_offset_check.rgba8ui.samples_4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000765 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000765 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_sample_check_rgba8TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_sample_check_rgba8TestCase.cpp new file mode 100644 index 000000000..abf5a02d1 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_sample_check_rgba8TestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000709, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000709 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation." + "render.interpolate_at_sample_check.rgba8.samples_1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000709 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000709 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000710, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000710 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation." + "render.interpolate_at_sample_check.rgba8.samples_2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000710 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000710 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000711, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000711 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation." + "render.interpolate_at_sample_check.rgba8.samples_4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000711 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000711 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_sample_check_rgba8iTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_sample_check_rgba8iTestCase.cpp new file mode 100644 index 000000000..e15307887 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31interpolate_at_sample_check_rgba8iTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000712, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000712 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_sample_check.rgba8i.samples_1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000712 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000712 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000713, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000713 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_sample_check.rgba8i.samples_2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000713 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000713 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000714, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000714 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_multisample_interpolation.r" + "ender.interpolate_at_sample_check.rgba8i.samples_4", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000714 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000714 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_packSnorm4x8TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_packSnorm4x8TestCase.cpp new file mode 100644 index 000000000..895358586 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_packSnorm4x8TestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000380, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000380 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfi" + "eld_operation.packSnorm4x8.0", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000380 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000380 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000381, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000381 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfi" + "eld_operation.packSnorm4x8.1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000381 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000381 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000382, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000382 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfi" + "eld_operation.packSnorm4x8.2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000382 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000382 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000383, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000383 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfi" + "eld_operation.packSnorm4x8.3", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000383 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000383 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_packUnorm4x8TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_packUnorm4x8TestCase.cpp new file mode 100644 index 000000000..8b4536673 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_packUnorm4x8TestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000376, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000376 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfi" + "eld_operation.packUnorm4x8.0", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000376 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000376 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000377, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000377 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfi" + "eld_operation.packUnorm4x8.1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000377 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000377 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000378, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000378 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfi" + "eld_operation.packUnorm4x8.2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000378 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000378 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000379, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000379 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfi" + "eld_operation.packUnorm4x8.3", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000379 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000379 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_unpackUnorm4x8TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_unpackUnorm4x8TestCase.cpp new file mode 100644 index 000000000..6945f7207 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31shader_bitfield_operation_unpackUnorm4x8TestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000384, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000384 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfie" + "ld_operation.unpackUnorm4x8.0", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000384 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000384 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000385, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000385 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfie" + "ld_operation.unpackUnorm4x8.1", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000385 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000385 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000386, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000386 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfie" + "ld_operation.unpackUnorm4x8.2", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000386 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000386 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000387, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000387 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.shader_bitfie" + "ld_operation.unpackUnorm4x8.3", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000387 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000387 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31tessellation_shader_tessellation_shader_triangles_tessellationTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31tessellation_shader_tessellation_shader_triangles_tessellationTestCase.cpp new file mode 100644 index 000000000..ca1ba8aa1 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31tessellation_shader_tessellation_shader_triangles_tessellationTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310003TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002585, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002585 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.tessellation_shader.tessellation_" + "shader_triangles_tessellation.degenerate_triangle", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002585 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002585 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002586, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002586 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.tessellation_shader.tessellation_" + "shader_triangles_tessellation.identical_triangles", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002586 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002586 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002587, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002587 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.tessellation_shader.tessellation_shader_" + "triangles_tessellation.inner_tessellation_level_rounding", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310003TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310003TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310003TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310003TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310003TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_002587 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002587 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31texture_storage_multisample_GLCoverageTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31texture_storage_multisample_GLCoverageTestCase.cpp new file mode 100644 index 000000000..0c00c505c --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31texture_storage_multisample_GLCoverageTestCase.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 "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000049, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000049 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.texture_storage_multisample.GLC" + "overage.extension_specific_enums_are_recognized", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000049 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000049 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000050, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000050 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.texture_storage_multisample.GLCoverage.get_tex_para" + "meter_reports_correct_default_values_for_multisample_texture_targets", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000050 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000050 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000051, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000051 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.texture_storage_multisample.GLCover" + "age.gl_sample_mask_mode_status_is_reported_correctly", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000051 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000051 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000052, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000052 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.texture_storage_multisample.GLCover" + "age.gl_tex_parameter_handlers_accept_zero_base_level", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsKhrgles310001TestSuite::runResult.numPassed += result.numPassed; + ActsKhrgles310001TestSuite::runResult.numFailed += result.numFailed; + ActsKhrgles310001TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsKhrgles310001TestSuite::runResult.numWarnings += result.numWarnings; + ActsKhrgles310001TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_000052 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000052 end"; +} -- GitLab