From 7e66a03bbfaed649f47e2267f54817804bce0ea1 Mon Sep 17 00:00:00 2001 From: huanggaolin Date: Mon, 27 Jun 2022 20:19:58 +0800 Subject: [PATCH] add testcase Signed-off-by: huanggaolin --- ...d_rendering_boundary_conditionTestCase.cpp | 130 +++++++++ .../Khrgles31rgba32f_samples_0TestCase.cpp | 265 ++++++++++++++++++ .../Khrgles31rgba32f_samples_1TestCase.cpp | 265 ++++++++++++++++++ .../Khrgles31rgba32f_samples_2TestCase.cpp | 265 ++++++++++++++++++ .../Khrgles31rgba8ui_samples_1TestCase.cpp | 265 ++++++++++++++++++ .../Khrgles31rgba8ui_samples_2TestCase.cpp | 265 ++++++++++++++++++ .../Khrgles31rgba8ui_samples_4TestCase.cpp | 265 ++++++++++++++++++ .../Khrgles31rgba8ui_samples_8TestCase.cpp | 265 ++++++++++++++++++ 8 files changed, 1985 insertions(+) create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_layered_rendering_boundary_conditionTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_0TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_1TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_2TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_1TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_2TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_4TestCase.cpp create mode 100644 graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_8TestCase.cpp diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_layered_rendering_boundary_conditionTestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_layered_rendering_boundary_conditionTestCase.cpp new file mode 100644 index 000000000..943ef6805 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31geometry_shader_layered_rendering_boundary_conditionTestCase.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_002478, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002478 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_shader.layered_rendering_boundary_co" + "ndition.layered_rendering_boundary_condition_various_textures", + "--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_002478 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002478 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002479, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002479 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_shader.layered_rendering_bound" + "ary_condition.layered_rendering_boundary_condition_no_gs", + "--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_002479 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002479 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002480, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002480 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_shader.layered_rendering_boundary_co" + "ndition.layered_rendering_boundary_condition_no_default_layer", + "--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_002480 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002480 end"; +} + +static HWTEST_F(ActsKhrgles310003TestSuite, TestCase_002481, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_002481 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.geometry_shader.layered_rendering_boundary_c" + "ondition.layered_rendering_boundary_condition_no_layered_fbo", + "--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_002481 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_002481 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_0TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_0TestCase.cpp new file mode 100644 index 000000000..92317e770 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_0TestCase.cpp @@ -0,0 +1,265 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000273, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000273 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variables" + ".mask.rgba32f.samples_0.mask_zero", + "--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_000273 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000273 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000274, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000274 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_0.mask_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_000274 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000274 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000275, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000275 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_0.mask_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_000275 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000275 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000276, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000276 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_0.mask_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_000276 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000276 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000277, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000277 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_0.mask_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_000277 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000277 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000278, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000278 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_0.mask_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_000278 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000278 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000279, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000279 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_0.mask_5", + "--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_000279 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000279 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000280, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000280 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_0.mask_6", + "--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_000280 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000280 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000281, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000281 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_0.mask_7", + "--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_000281 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000281 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_1TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_1TestCase.cpp new file mode 100644 index 000000000..b2c9b60fd --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_1TestCase.cpp @@ -0,0 +1,265 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000282, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000282 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variables" + ".mask.rgba32f.samples_1.mask_zero", + "--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_000282 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000282 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000283, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000283 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_1.mask_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_000283 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000283 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000284, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000284 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_1.mask_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_000284 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000284 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000285, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000285 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_1.mask_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_000285 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000285 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000286, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000286 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_1.mask_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_000286 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000286 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000287, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000287 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_1.mask_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_000287 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000287 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000288, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000288 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_1.mask_5", + "--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_000288 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000288 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000289, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000289 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_1.mask_6", + "--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_000289 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000289 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000290, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000290 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_1.mask_7", + "--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_000290 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000290 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_2TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_2TestCase.cpp new file mode 100644 index 000000000..dd3ecf0ca --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba32f_samples_2TestCase.cpp @@ -0,0 +1,265 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000291, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000291 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variables" + ".mask.rgba32f.samples_2.mask_zero", + "--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_000291 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000291 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000292, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000292 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_2.mask_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_000292 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000292 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000293, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000293 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_2.mask_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_000293 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000293 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000294, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000294 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_2.mask_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_000294 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000294 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000295, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000295 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_2.mask_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_000295 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000295 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000296, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000296 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_2.mask_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_000296 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000296 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000297, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000297 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_2.mask_5", + "--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_000297 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000297 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000298, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000298 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_2.mask_6", + "--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_000298 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000298 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000299, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000299 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba32f.samples_2.mask_7", + "--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_000299 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000299 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_1TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_1TestCase.cpp new file mode 100644 index 000000000..9ef3a9171 --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_1TestCase.cpp @@ -0,0 +1,265 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000237, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000237 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variables" + ".mask.rgba8ui.samples_1.mask_zero", + "--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_000237 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000237 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000238, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000238 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_1.mask_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_000238 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000238 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000239, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000239 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_1.mask_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_000239 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000239 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000240, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000240 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_1.mask_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_000240 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000240 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000241, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000241 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_1.mask_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_000241 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000241 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000242, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000242 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_1.mask_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_000242 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000242 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000243, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000243 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_1.mask_5", + "--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_000243 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000243 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000244, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000244 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_1.mask_6", + "--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_000244 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000244 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000245, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000245 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_1.mask_7", + "--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_000245 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000245 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_2TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_2TestCase.cpp new file mode 100644 index 000000000..7ee93201b --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_2TestCase.cpp @@ -0,0 +1,265 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000246, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000246 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variables" + ".mask.rgba8ui.samples_2.mask_zero", + "--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_000246 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000246 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000247, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000247 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_2.mask_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_000247 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000247 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000248, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000248 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_2.mask_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_000248 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000248 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000249, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000249 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_2.mask_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_000249 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000249 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000250, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000250 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_2.mask_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_000250 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000250 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000251, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000251 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_2.mask_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_000251 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000251 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000252, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000252 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_2.mask_5", + "--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_000252 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000252 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000253, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000253 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_2.mask_6", + "--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_000253 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000253 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000254, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000254 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_2.mask_7", + "--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_000254 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000254 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_4TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_4TestCase.cpp new file mode 100644 index 000000000..cacda986e --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_4TestCase.cpp @@ -0,0 +1,265 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000255, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000255 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variables" + ".mask.rgba8ui.samples_4.mask_zero", + "--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_000255 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000255 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000256, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000256 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_4.mask_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_000256 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000256 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000257, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000257 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_4.mask_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_000257 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000257 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000258, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000258 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_4.mask_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_000258 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000258 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000259, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000259 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_4.mask_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_000259 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000259 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000260, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000260 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_4.mask_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_000260 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000260 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000261, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000261 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_4.mask_5", + "--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_000261 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000261 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000262, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000262 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_4.mask_6", + "--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_000262 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000262 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000263, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000263 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_4.mask_7", + "--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_000263 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000263 end"; +} diff --git a/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_8TestCase.cpp b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_8TestCase.cpp new file mode 100644 index 000000000..f9d4e4a1e --- /dev/null +++ b/graphic/vkgl/src/khrgles31/core/Khrgles31rgba8ui_samples_8TestCase.cpp @@ -0,0 +1,265 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Khrgles31BaseFunc.h" +#include "../ActsKhrgles310001TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000264, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000264 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variables" + ".mask.rgba8ui.samples_8.mask_zero", + "--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_000264 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000264 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000265, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000265 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_8.mask_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_000265 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000265 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000266, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000266 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_8.mask_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_000266 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000266 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000267, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000267 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_8.mask_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_000267 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000267 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000268, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000268 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_8.mask_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_000268 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000268 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000269, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000269 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_8.mask_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_000269 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000269 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000270, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000270 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_8.mask_5", + "--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_000270 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000270 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000271, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000271 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_8.mask_6", + "--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_000271 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000271 end"; +} + +static HWTEST_F(ActsKhrgles310001TestSuite, TestCase_000272, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_000272 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "KHR-GLES31.core.sample_variable" + "s.mask.rgba8ui.samples_8.mask_7", + "--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_000272 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_000272 end"; +} -- GitLab