diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2render_struct_in_arrayTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2render_struct_in_arrayTestCase.cpp new file mode 100644 index 0000000000000000000000000000000000000000..340b0711bc165ea6e2c213938479fd14ab56944d --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2render_struct_in_arrayTestCase.cpp @@ -0,0 +1,1075 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20015TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014396, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014396 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.init" + "ial.render.struct_in_array.float_vec4_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014396 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014396 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014397, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014397 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.initi" + "al.render.struct_in_array.float_vec4_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014397 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014397 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014398, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014398 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.ini" + "tial.render.struct_in_array.float_vec4_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014398 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014398 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014399, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014399 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.ini" + "tial.render.struct_in_array.mat4_mat2_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014399 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014399 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014400, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014400 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.init" + "ial.render.struct_in_array.mat4_mat2_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014400 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014400 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014401, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014401 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.in" + "itial.render.struct_in_array.mat4_mat2_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014401 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014401 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014402, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014402 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.ini" + "tial.render.struct_in_array.int_ivec4_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014402 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014402 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014403, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014403 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.init" + "ial.render.struct_in_array.int_ivec4_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014403 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014403 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014404, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014404 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.in" + "itial.render.struct_in_array.int_ivec4_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014404 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014404 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014405, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014405 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.init" + "ial.render.struct_in_array.bool_bvec4_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014405 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014405 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014406, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014406 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.initi" + "al.render.struct_in_array.bool_bvec4_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014406 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014406 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014407, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014407 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.ini" + "tial.render.struct_in_array.bool_bvec4_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014407 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014407 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014719, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014719 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.b" + "y_pointer.render.struct_in_array.float_vec4_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014719 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014719 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014720, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014720 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by" + "_pointer.render.struct_in_array.float_vec4_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014720 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014720 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014721, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014721 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "by_pointer.render.struct_in_array.float_vec4_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014721 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014721 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014722, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014722 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "by_pointer.render.struct_in_array.mat4_mat2_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014722 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014722 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014723, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014723 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.b" + "y_pointer.render.struct_in_array.mat4_mat2_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014723 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014723 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014724, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014724 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned" + ".by_pointer.render.struct_in_array.mat4_mat2_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014724 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014724 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014725, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014725 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "by_pointer.render.struct_in_array.int_ivec4_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014725 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014725 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014726, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014726 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.b" + "y_pointer.render.struct_in_array.int_ivec4_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014726 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014726 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014727, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014727 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned" + ".by_pointer.render.struct_in_array.int_ivec4_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014727 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014727 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014728, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014728 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.b" + "y_pointer.render.struct_in_array.bool_bvec4_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014728 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014728 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014729, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014729 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by" + "_pointer.render.struct_in_array.bool_bvec4_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014729 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014729 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014730, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014730 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "by_pointer.render.struct_in_array.bool_bvec4_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014730 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014730 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014731, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014731 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_poi" + "nter.render.struct_in_array.sampler2D_samplerCube_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014731 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014731 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014732, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014732 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_poin" + "ter.render.struct_in_array.sampler2D_samplerCube_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014732 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014732 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_014733, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_014733 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_po" + "inter.render.struct_in_array.sampler2D_samplerCube_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_014733 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_014733 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015008, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015008 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "by_value.render.struct_in_array.float_vec4_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015008 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015008 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015009, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015009 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.b" + "y_value.render.struct_in_array.float_vec4_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015009 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015009 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015010, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015010 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned" + ".by_value.render.struct_in_array.float_vec4_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015010 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015010 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015011, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015011 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned" + ".by_value.render.struct_in_array.int_ivec4_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015011 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015011 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015012, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015012 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "by_value.render.struct_in_array.int_ivec4_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015012 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015012 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015013, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015013 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigne" + "d.by_value.render.struct_in_array.int_ivec4_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015013 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015013 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015014, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015014 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned." + "by_value.render.struct_in_array.bool_bvec4_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015014 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015014 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015015, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015015 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.b" + "y_value.render.struct_in_array.bool_bvec4_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015015 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015015 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015016, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015016 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned" + ".by_value.render.struct_in_array.bool_bvec4_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015016 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015016 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015017, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015017 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_va" + "lue.render.struct_in_array.sampler2D_samplerCube_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015017 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015017 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015018, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015018 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_val" + "ue.render.struct_in_array.sampler2D_samplerCube_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015018 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015018 end"; +} + +static HWTEST_F(ActsDeqpgles20015TestSuite, TestCase_015019, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_015019 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.uniform_api.value.assigned.by_v" + "alue.render.struct_in_array.sampler2D_samplerCube_both", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20015TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20015TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20015TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20015TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20015TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_015019 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_015019 end"; +} diff --git a/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shaders_returnTestCase.cpp b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shaders_returnTestCase.cpp new file mode 100644 index 0000000000000000000000000000000000000000..967dc9c4b24006767e33bec16f80ec6f876e9a2e --- /dev/null +++ b/graphic/vkgl/src/deqpgles2/functional/Deqpgles2shaders_returnTestCase.cpp @@ -0,0 +1,1048 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "../Deqpgles2BaseFunc.h" +#include "../ActsDeqpgles20008TestSuite.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007619, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007619 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader" + "s.return.single_return_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007619 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007619 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007620, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007620 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders" + ".return.single_return_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007620 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007620 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007621, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007621 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retu" + "rn.conditional_return_always_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007621 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007621 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007622, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007622 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retur" + "n.conditional_return_always_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007622 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007622 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007623, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007623 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retu" + "rn.conditional_return_never_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007623 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007623 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007624, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007624 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retur" + "n.conditional_return_never_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007624 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007624 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007625, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007625 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retur" + "n.conditional_return_dynamic_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007625 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007625 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007626, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007626 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return" + ".conditional_return_dynamic_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007626 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007626 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007627, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007627 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shader" + "s.return.double_return_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007627 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007627 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007628, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007628 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders" + ".return.double_return_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007628 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007628 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007629, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007629 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.ret" + "urn.last_statement_in_main_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007629 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007629 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007630, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007630 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retu" + "rn.last_statement_in_main_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007630 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007630 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007631, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007631 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.r" + "eturn.output_write_always_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007631 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007631 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007632, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007632 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.re" + "turn.output_write_always_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007632 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007632 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007633, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007633 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.r" + "eturn.output_write_never_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007633 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007633 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007634, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007634 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.re" + "turn.output_write_never_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007634 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007634 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007635, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007635 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.re" + "turn.output_write_dynamic_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007635 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007635 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007636, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007636 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.ret" + "urn.output_write_dynamic_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007636 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007636 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007637, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007637 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retur" + "n.output_write_in_func_always_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007637 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007637 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007638, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007638 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return" + ".output_write_in_func_always_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007638 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007638 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007639, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007639 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retur" + "n.output_write_in_func_never_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007639 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007639 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007640, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007640 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return" + ".output_write_in_func_never_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007640 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007640 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007641, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007641 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return" + ".output_write_in_func_dynamic_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007641 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007641 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007642, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007642 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return." + "output_write_in_func_dynamic_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007642 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007642 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007643, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007643 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return" + ".return_in_static_loop_always_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007643 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007643 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007644, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007644 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return." + "return_in_static_loop_always_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007644 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007644 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007645, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007645 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retur" + "n.return_in_static_loop_never_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007645 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007645 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007646, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007646 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return" + ".return_in_static_loop_never_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007646 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007646 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007647, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007647 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return" + ".return_in_static_loop_dynamic_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007647 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007647 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007648, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007648 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return." + "return_in_static_loop_dynamic_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007648 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007648 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007649, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007649 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return" + ".return_in_dynamic_loop_always_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007649 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007649 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007650, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007650 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return." + "return_in_dynamic_loop_always_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007650 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007650 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007651, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007651 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return" + ".return_in_dynamic_loop_never_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007651 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007651 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007652, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007652 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return." + "return_in_dynamic_loop_never_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007652 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007652 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007653, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007653 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return." + "return_in_dynamic_loop_dynamic_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007653 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007653 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007654, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007654 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.return.r" + "eturn_in_dynamic_loop_dynamic_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007654 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007654 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007655, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007655 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.ret" + "urn.return_in_infinite_loop_vertex", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007655 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007655 end"; +} + +static HWTEST_F(ActsDeqpgles20008TestSuite, TestCase_007656, Function | MediumTest | Level2) +{ + GTEST_LOG_(INFO) << "TestCase_007656 start"; + int argc = 3; + const char *argv[3] = { + ".", + "--deqp-case=" + "dEQP-GLES2.functional.shaders.retu" + "rn.return_in_infinite_loop_fragment", + "--deqp-archive-dir=/data/local/tmp/" + }; + + FuncRunResult result = RunTestKHRGLES(argc, argv); + ActsDeqpgles20008TestSuite::runResult.numPassed += result.numPassed; + ActsDeqpgles20008TestSuite::runResult.numFailed += result.numFailed; + ActsDeqpgles20008TestSuite::runResult.numNotSupported += result.numNotSupported; + ActsDeqpgles20008TestSuite::runResult.numWarnings += result.numWarnings; + ActsDeqpgles20008TestSuite::runResult.numWaived += result.numWaived; + if (result.numNotSupported == 1) { + GTEST_LOG_(INFO) << "TestCase_007656 notsupport!"; + } else if (result.isComplete) { + EXPECT_TRUE(result.isComplete); + EXPECT_TRUE(result.numPassed == 1); + }; + GTEST_LOG_(INFO) << "TestCase_007656 end"; +}