From 220f80f8687c7c7e86c1a63f553496ef8eb51560 Mon Sep 17 00:00:00 2001 From: wangshi Date: Wed, 13 Jul 2022 16:44:19 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E4=BC=98=E5=8C=96=E8=BF=87?= =?UTF-8?q?=E7=9A=84khrgles2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: wangshi --- .../khrgles2/ActsKhrgles20001TestSuite.cpp | 60 + .../src/khrgles2/ActsKhrgles20001TestSuite.h | 40 + .../src/khrgles2/ActsKhrgles2TestSuite.cpp | 60 + .../vkgl/src/khrgles2/ActsKhrgles2TestSuite.h | 40 + .../vkgl/src/khrgles2/Khrgles2BaseFunc.cpp | 81 + graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.h | 32 + graphic/vkgl/src/khrgles2/build0001/BUILD.gn | 70 + graphic/vkgl/src/khrgles2/build0001/Test.json | 38 + .../vkgl/src/khrgles2/build0001/logdefine.cpp | 20 + ...2internalformat_copy_tex_imageTestCase.cpp | 80 + ...es2internalformat_renderbufferTestCase.cpp | 64 + ...rgles2internalformat_texture2dTestCase.cpp | 172 +++ ...aders_aggressive_optimizationsTestCase.cpp | 72 + .../Khrgles2shaders_negativeTestCase.cpp | 32 + ...Khrgles2filtering_combinationsTestCase.cpp | 1324 +++++++++++++++++ .../Khrgles2filtering_formatsTestCase.cpp | 48 + .../Khrgles2filtering_sizesTestCase.cpp | 144 ++ ...2texture_3d_compressed_textureTestCase.cpp | 144 ++ ...gles2texture_3d_copy_sub_imageTestCase.cpp | 32 + ...texture_3d_framebuffer_textureTestCase.cpp | 32 + .../Khrgles2texture_3d_sub_imageTestCase.cpp | 32 + 21 files changed, 2617 insertions(+) create mode 100644 graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.cpp create mode 100644 graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.h create mode 100644 graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.cpp create mode 100644 graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.h create mode 100644 graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.cpp create mode 100644 graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.h create mode 100644 graphic/vkgl/src/khrgles2/build0001/BUILD.gn create mode 100644 graphic/vkgl/src/khrgles2/build0001/Test.json create mode 100644 graphic/vkgl/src/khrgles2/build0001/logdefine.cpp create mode 100644 graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_copy_tex_imageTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_renderbufferTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_texture2dTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_aggressive_optimizationsTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_negativeTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_combinationsTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_formatsTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_sizesTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_compressed_textureTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_copy_sub_imageTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_framebuffer_textureTestCase.cpp create mode 100644 graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_sub_imageTestCase.cpp diff --git a/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.cpp b/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.cpp new file mode 100644 index 000000000..e30c01a2c --- /dev/null +++ b/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.cpp @@ -0,0 +1,60 @@ +/* + * 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 +#include +#include "Khrgles2BaseFunc.h" +#include "ActsKhrgles20001TestSuite.h" + +namespace OHOS { + using namespace std; + using namespace testing::ext; + + time_t ActsKhrgles20001TestSuite::startTime; + time_t ActsKhrgles20001TestSuite::endTime; + FuncRunResult ActsKhrgles20001TestSuite::runResult; + + // Preset action of the test suite, which is executed before the first test case + void ActsKhrgles20001TestSuite::SetUpTestCase(void) + { + time(&startTime); + RegistPackage(); + runResult.numPassed = 0; + runResult.numFailed = 0; + runResult.numNotSupported = 0; + runResult.numWarnings = 0; + runResult.numWaived = 0; + } + // Test suite cleanup action, which is executed after the last test case + void ActsKhrgles20001TestSuite::TearDownTestCase(void) + { + time(&endTime); + printf("Test run totals --- Passed[%d]\n", runResult.numPassed); + printf("Test run totals --- Failed[%d]\n", runResult.numFailed); + printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported); + printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings); + printf("Test run totals --- Waved[%d]\n", runResult.numWaived); + printf("testmain end --- COST TIME[%lld]\n", (endTime-startTime)); + } + // Preset action of the test case + void ActsKhrgles20001TestSuite::SetUp(void) + { + } + // Cleanup action of the test case + void ActsKhrgles20001TestSuite::TearDown(void) + { + } +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.h b/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.h new file mode 100644 index 000000000..44d52c932 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/ActsKhrgles20001TestSuite.h @@ -0,0 +1,40 @@ +/* + * 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. + */ + +#ifndef KHRGLES2_TESTCASE_H +#define KHRGLES2_TESTCASE_H + +#include +#include "Khrgles2BaseFunc.h" + +namespace OHOS { + class ActsKhrgles20001TestSuite : public testing::Test { + public: + static time_t startTime; + static time_t endTime; + static FuncRunResult runResult; + protected: + // Preset action of the test suite, which is executed before the first test case + static void SetUpTestCase(void); + // Test suite cleanup action, which is executed after the last test case + static void TearDownTestCase(void); + // Preset action of the test case + virtual void SetUp(void); + // Cleanup action of the test case + virtual void TearDown(void); + }; +} // namespace OHOS + +#endif // KHRGLES2_TESTCASE_H \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.cpp b/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.cpp new file mode 100644 index 000000000..bf5554903 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.cpp @@ -0,0 +1,60 @@ +/* + * 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 +#include +#include "Khrgles2BaseFunc.h" +#include "ActsKhrgles2TestSuite.h" + +namespace OHOS { + using namespace std; + using namespace testing::ext; + + time_t ActsKhrgles2TestSuite::startTime; + time_t ActsKhrgles2TestSuite::endTime; + FuncRunResult ActsKhrgles2TestSuite::runResult; + + // Preset action of the test suite, which is executed before the first test case + void ActsKhrgles2TestSuite::SetUpTestCase(void) + { + time(&startTime); + RegistPackage(); + runResult.numPassed = 0; + runResult.numFailed = 0; + runResult.numNotSupported = 0; + runResult.numWarnings = 0; + runResult.numWaived = 0; + } + // Test suite cleanup action, which is executed after the last test case + void ActsKhrgles2TestSuite::TearDownTestCase(void) + { + time(&endTime); + printf("Test run totals --- Passed[%d]\n", runResult.numPassed); + printf("Test run totals --- Failed[%d]\n", runResult.numFailed); + printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported); + printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings); + printf("Test run totals --- Waved[%d]\n", runResult.numWaived); + printf("testmain end --- COST TIME[%lld]\n", (endTime-startTime)); + } + // Preset action of the test case + void ActsKhrgles2TestSuite::SetUp(void) + { + } + // Cleanup action of the test case + void ActsKhrgles2TestSuite::TearDown(void) + { + } +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.h b/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.h new file mode 100644 index 000000000..6c12f7817 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/ActsKhrgles2TestSuite.h @@ -0,0 +1,40 @@ +/* + * 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. + */ + +#ifndef KHRGLES2_TESTCASE_H +#define KHRGLES2_TESTCASE_H + +#include +#include "Khrgles2BaseFunc.h" + +namespace OHOS { + class ActsKhrgles2TestSuite : public testing::Test { + public: + static time_t startTime; + static time_t endTime; + static FuncRunResult runResult; + protected: + // Preset action of the test suite, which is executed before the first test case + static void SetUpTestCase(void); + // Test suite cleanup action, which is executed after the last test case + static void TearDownTestCase(void); + // Preset action of the test case + virtual void SetUp(void); + // Cleanup action of the test case + virtual void TearDown(void); + }; +} // namespace OHOS + +#endif // KHRGLES2_TESTCASE_H \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.cpp b/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.cpp new file mode 100644 index 000000000..f19e082b0 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.cpp @@ -0,0 +1,81 @@ +/* + * 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 "tcuDefs.hpp" +#include "tcuCommandLine.hpp" +#include "tcuPlatform.hpp" +#include "ActsApp.h" +#include "tcuResource.hpp" +#include "tcuTestLog.hpp" +#include "tcuTestSessionExecutor.hpp" +#include "deUniquePtr.hpp" +#include "tcuOhosPlatform.hpp" + +#include "external/openglcts/modules/common/glcConfigPackage.hpp" +#include "external/openglcts/modules/common/glcTestPackage.hpp" +#include "external/openglcts/modules/gles2/es2cTestPackage.hpp" +#include "external/openglcts/modules/gles32/es32cTestPackage.hpp" +#include "external/openglcts/modules/gles31/es31cTestPackage.hpp" +#include "external/openglcts/modules/gles3/es3cTestPackage.hpp" +#include "external/openglcts/modules/glesext/esextcTestPackage.hpp" +#include "external/openglcts/modules/common/glcSingleConfigTestPackage.hpp" + +#include "modules/gles2/tes2TestPackage.hpp" +#include "modules/gles3/tes3TestPackage.hpp" +#include "modules/gles31/tes31TestPackage.hpp" + +#include "ohos_context_i.h" +#include "logdefine.h" +#include "Khrgles2BaseFunc.h" + +static tcu::TestPackage* createKhrgles2Package(tcu::TestContext& testCtx) +{ + return new es2cts::TestPackage(testCtx, "KHR-GLES2"); +} +void RegistPackage(void) +{ + tcu::TestPackageRegistry *registry = tcu::TestPackageRegistry::getSingleton(); + registry->registerPackage("KHR-GLES2", createKhrgles2Package); +} + +// extern tcu::TestLog tcutestlog; +FuncRunResult RunTestKHRGLES(int argc, const char** argv) +{ + FuncRunResult runResult; + try { + tcu::CommandLine cmdLine(argc, argv); + tcu::DirArchive archive(cmdLine.getArchiveDir()); + + de::UniquePtr platform(createOhosPlatform()); + de::UniquePtr app(new tcu::ActsApp(*platform, archive, OHOS::Logdefine::tcutestlog, cmdLine)); + for (;;) { + if (!app->iterate()) { + break; + }; + }; + runResult.isComplete = app->getResult().isComplete; + runResult.numPassed = app->getResult().numPassed; + runResult.numExecuted = app->getResult().numExecuted; + runResult.numFailed = app->getResult().numFailed; + runResult.numNotSupported = app->getResult().numNotSupported; + runResult.numWarnings = app->getResult().numWarnings; + runResult.numWaived = app->getResult().numWaived; + } catch (const std::exception &e) { + tcu::die("%s", e.what()); + }; + return runResult; +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.h b/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.h new file mode 100644 index 000000000..97bbcbf1c --- /dev/null +++ b/graphic/vkgl/src/khrgles2/Khrgles2BaseFunc.h @@ -0,0 +1,32 @@ +/* + * 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. + */ + +#ifndef KHRGLES2_FUNC_H +#define KHRGLES2_FUNC_H + +struct FuncRunResult { + int numExecuted; // !< Total number of cases executed. + int numPassed; // !< Number of cases passed. + int numFailed; // !< Number of cases failed. + int numNotSupported; // !< Number of cases not supported. + int numWarnings; // !< Number of QualityWarning / CompatibilityWarning results. + int numWaived; // !< Number of waived tests. + bool isComplete; // !< Is run complete. +}; + +void RegistPackage(void); +FuncRunResult RunTestKHRGLES(int argc, const char** argv); + +#endif // KHRGLES2_FUNC_H \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/build0001/BUILD.gn b/graphic/vkgl/src/khrgles2/build0001/BUILD.gn new file mode 100644 index 000000000..e88f7ef89 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/build0001/BUILD.gn @@ -0,0 +1,70 @@ +# 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. + +import("//test/xts/acts/graphic/vkgl/comm.gni") + +config("deqp_platform_ohos_config") { + cflags_cc = deqp_common_cflags_cc + + cflags_cc += [ + # "-Wno-conversion", + # "-Wno-unused-function", + "-Wno-unused-parameter", + ] + + defines = deqp_common_defines + + # defines -=["DE_PTR_SIZE=8"] + defines += [ + "DE_PTR_SIZE=4", + "_XOPEN_SOURCE=600", + ] +} + +ohos_static_library("libkhrgles2func0001") { + sources = common_src + sources += [ "../Khrgles2BaseFunc.cpp" ] + + include_dirs = common_include + deps = common_depends + external_deps = [ + "hilog_native:libhilog", + "multimedia_image_standard:image_native", + ] + configs = [ ":deqp_platform_ohos_config" ] + public_deps = [ "//foundation/ace/ace_engine/build/external_config/flutter/skia:ace_skia_ohos" ] +} + +ohos_moduletest_suite("ActsKhrgles2TestSuite0001") { + sources = [ + "../ActsKhrgles20001TestSuite.cpp", + "../core/Khrgles2internalformat_copy_tex_imageTestCase.cpp", + "../core/Khrgles2internalformat_renderbufferTestCase.cpp", + "../core/Khrgles2internalformat_texture2dTestCase.cpp", + "../shaders/Khrgles2shaders_aggressive_optimizationsTestCase.cpp", + "../shaders/Khrgles2shaders_negativeTestCase.cpp", + "../texture_3d/Khrgles2filtering_combinationsTestCase.cpp", + "../texture_3d/Khrgles2filtering_formatsTestCase.cpp", + "../texture_3d/Khrgles2filtering_sizesTestCase.cpp", + "../texture_3d/Khrgles2texture_3d_compressed_textureTestCase.cpp", + "../texture_3d/Khrgles2texture_3d_copy_sub_imageTestCase.cpp", + "../texture_3d/Khrgles2texture_3d_framebuffer_textureTestCase.cpp", + "../texture_3d/Khrgles2texture_3d_sub_imageTestCase.cpp", + ] + + include_dirs = [ "//test/xts/acts/graphic/vkgl/src" ] + + deps = [ ":libkhrgles2func0001" ] + + cflags = [ "-Wno-error" ] +} diff --git a/graphic/vkgl/src/khrgles2/build0001/Test.json b/graphic/vkgl/src/khrgles2/build0001/Test.json new file mode 100644 index 000000000..7ce3fd605 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/build0001/Test.json @@ -0,0 +1,38 @@ +{ + "description": "Config for ActsKhrgles2TestSuite0001 test cases", + "driver": { + "module-name": "ActsKhrgles2TestSuite0001", + "native-test-timeout": "120000", + "native-test-device-path": "/data/local/tmp", + "runtime-hint": "100s", + "type": "CppTest" + }, + "kits": [ + { + "pre-push" : [ + ], + "post-push" : [ + "chmod -R 777 /data/local/tmp/*", + "mkdir /data/local/tmp/gl_cts", + "tar zxvf /data/local/tmp/gl_cts.tar.gz -C /data/local/tmp/gl_cts", + "cp -r /data/local/tmp/gl_cts/data/gles2 /data/local/tmp", + "cp -r /data/local/tmp/gl_cts/data/gles3 /data/local/tmp", + "cp -r /data/local/tmp/gl_cts/data/gles31 /data/local/tmp" + ], + "push": [ + "ActsKhrgles2TestSuite0001->/data/local/tmp/ActsKhrgles2TestSuite0001", + "../../../common/common/librosen_context.z.so->/system/lib", + "../../../../../test/xts/acts/graphic/vkgl/data/gl_cts.tar.gz->/data/local/tmp/gl_cts.tar.gz" + ], + "type": "PushKit" + }, + { + "type": "ShellKit", + "run-command": [ + "remount", + "mkdir /data/test", + "cd /data/local/tmp" + ] + } + ] +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/build0001/logdefine.cpp b/graphic/vkgl/src/khrgles2/build0001/logdefine.cpp new file mode 100644 index 000000000..f4b5825e9 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/build0001/logdefine.cpp @@ -0,0 +1,20 @@ +/* + * 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 "logdefine.h" + +namespace OHOS { + tcu::TestLog Logdefine::tcutestlog("/data/local/tmp/ActsKhrgles2TestSuite0001.qpa", 0); +} // OHOS \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_copy_tex_imageTestCase.cpp b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_copy_tex_imageTestCase.cpp new file mode 100644 index 000000000..53782b1b3 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_copy_tex_imageTestCase.cpp @@ -0,0 +1,80 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000449, + "KHR-GLES2.core.internalf", + "ormat.copy_tex_image.rgb"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000450, + "KHR-GLES2.core.internalf", + "ormat.copy_tex_image.rgba"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000451, + "KHR-GLES2.core.internalfo", + "rmat.copy_tex_image.alpha"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000452, + "KHR-GLES2.core.internalform", + "at.copy_tex_image.luminance"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000453, + "KHR-GLES2.core.internalformat.", + "copy_tex_image.luminance_alpha"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000454, + "KHR-GLES2.core.internalfor", + "mat.copy_tex_image.rgb5_a1"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000455, + "KHR-GLES2.core.internalfo", + "rmat.copy_tex_image.rgb565"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000456, + "KHR-GLES2.core.internalfo", + "rmat.copy_tex_image.rgba4"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000457, + "KHR-GLES2.core.internalformat.cop", + "y_tex_image.luminance4_alpha4_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000458, + "KHR-GLES2.core.internalformat.cop", + "y_tex_image.luminance8_alpha8_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000459, + "KHR-GLES2.core.internalformat", + ".copy_tex_image.luminance8_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000460, + "KHR-GLES2.core.internalform", + "at.copy_tex_image.alpha8_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000461, + "KHR-GLES2.core.internalfor", + "mat.copy_tex_image.rgb10_a2"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000462, + "KHR-GLES2.core.internalfo", + "rmat.copy_tex_image.rgb10"); diff --git a/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_renderbufferTestCase.cpp b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_renderbufferTestCase.cpp new file mode 100644 index 000000000..e8142e1b0 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_renderbufferTestCase.cpp @@ -0,0 +1,64 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000463, + "KHR-GLES2.core.internalf", + "ormat.renderbuffer.rgba8"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000464, + "KHR-GLES2.core.internal", + "format.renderbuffer.rgb8"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000465, + "KHR-GLES2.core.internalformat.", + "renderbuffer.stencil_index1_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000466, + "KHR-GLES2.core.internalformat.", + "renderbuffer.stencil_index4_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000467, + "KHR-GLES2.core.internalforma", + "t.renderbuffer.stencil_index8"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000468, + "KHR-GLES2.core.internalformat.", + "renderbuffer.depth_component16"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000469, + "KHR-GLES2.core.internalformat.", + "renderbuffer.depth_component24"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000470, + "KHR-GLES2.core.internalformat.", + "renderbuffer.depth_component32"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000471, + "KHR-GLES2.core.internalformat", + ".renderbuffer.depth24_stencil8"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000472, + "KHR-GLES2.core.internalfo", + "rmat.renderbuffer.rgb5_a1"); diff --git a/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_texture2dTestCase.cpp b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_texture2dTestCase.cpp new file mode 100644 index 000000000..1123ab0b2 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/core/Khrgles2internalformat_texture2dTestCase.cpp @@ -0,0 +1,172 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000412, + "KHR-GLES2.core.internalformat.t", + "exture2d.rgba_unsigned_byte_rgba"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000413, + "KHR-GLES2.core.internalformat.", + "texture2d.rgb_unsigned_byte_rgb"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000414, + "KHR-GLES2.core.internalformat.textur", + "e2d.rgba_unsigned_short_4_4_4_4_rgba"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000415, + "KHR-GLES2.core.internalformat.texture2d.lu", + "minance_alpha_unsigned_byte_luminance_alpha"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000416, + "KHR-GLES2.core.internalformat.textur", + "e2d.luminance_unsigned_byte_luminance"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000417, + "KHR-GLES2.core.internalformat.te", + "xture2d.alpha_unsigned_byte_alpha"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000418, + "KHR-GLES2.core.internalformat.texture2", + "d.rgba_unsigned_int_2_10_10_10_rev_rgba"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000419, + "KHR-GLES2.core.internalformat.texture2d.", + "rgba_unsigned_int_2_10_10_10_rev_rgb10_a2"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000420, + "KHR-GLES2.core.internalformat.texture2d.", + "rgba_unsigned_int_2_10_10_10_rev_rgb5_a1"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000421, + "KHR-GLES2.core.internalformat.texture", + "2d.rgb_unsigned_int_2_10_10_10_rev_rgb"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000422, + "KHR-GLES2.core.internalformat.texture2d.dep", + "th_component_unsigned_short_depth_component"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000423, + "KHR-GLES2.core.internalformat.texture2d.de", + "pth_component_unsigned_int_depth_component"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000424, + "KHR-GLES2.core.internalformat.texture2d.de", + "pth_stencil_unsigned_int_24_8_depth_stencil"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000425, + "KHR-GLES2.core.internalformat.t", + "exture2d.rgb_half_float_oes_rgb"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000426, + "KHR-GLES2.core.internalformat.te", + "xture2d.rgba_half_float_oes_rgba"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000427, + "KHR-GLES2.core.internalformat.text", + "ure2d.rgb_half_float_oes_rgb_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000428, + "KHR-GLES2.core.internalformat.textu", + "re2d.rgba_half_float_oes_rgba_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000429, + "KHR-GLES2.core.internalforma", + "t.texture2d.rgb_float_rgb32f"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000430, + "KHR-GLES2.core.internalformat", + ".texture2d.rgba_float_rgba32f"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000431, + "KHR-GLES2.core.internalformat.t", + "exture2d.rgb_float_rgb32f_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000432, + "KHR-GLES2.core.internalformat.te", + "xture2d.rgba_float_rgba32f_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000433, + "KHR-GLES2.core.internalformat.tex", + "ture2d.rgba_unsigned_byte_rgb5_a1"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000434, + "KHR-GLES2.core.internalformat.te", + "xture2d.rgba_unsigned_byte_rgba4"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000435, + "KHR-GLES2.core.internalformat.te", + "xture2d.rgb_unsigned_byte_rgb565"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000436, + "KHR-GLES2.core.internalformat.textur", + "e2d.rgba_unsigned_short_4_4_4_4_rgba4"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000437, + "KHR-GLES2.core.internalformat.textur", + "e2d.rgba_unsigned_short_5_5_5_1_rgba"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000438, + "KHR-GLES2.core.internalformat.texture", + "2d.rgba_unsigned_short_5_5_5_1_rgb5_a1"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000439, + "KHR-GLES2.core.internalformat.text", + "ure2d.rgb_unsigned_short_5_6_5_rgb"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000440, + "KHR-GLES2.core.internalformat.textu", + "re2d.rgb_unsigned_short_5_6_5_rgb565"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000441, + "KHR-GLES2.core.internalformat.texture2d.lumin", + "ance_alpha_unsigned_byte_luminance8_alpha8_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000442, + "KHR-GLES2.core.internalformat.texture2d.lumin", + "ance_alpha_unsigned_byte_luminance4_alpha4_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000443, + "KHR-GLES2.core.internalformat.texture2d", + ".luminance_unsigned_byte_luminance8_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000444, + "KHR-GLES2.core.internalformat.textu", + "re2d.alpha_unsigned_byte_alpha8_oes"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000445, + "KHR-GLES2.core.internalformat.texture2d.dep", + "th_component_unsigned_int_depth_component16"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000446, + "KHR-GLES2.core.internalformat.texture2d.dept", + "h_component_unsigned_short_depth_component16"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000447, + "KHR-GLES2.core.internalformat.texture2d.dep", + "th_component_unsigned_int_depth_component24"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000448, + "KHR-GLES2.core.internalformat.texture2d.dep", + "th_component_unsigned_int_depth_component32"); diff --git a/graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_aggressive_optimizationsTestCase.cpp b/graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_aggressive_optimizationsTestCase.cpp new file mode 100644 index 000000000..1e133da18 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_aggressive_optimizationsTestCase.cpp @@ -0,0 +1,72 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000003, + "KHR-GLES2.shaders.aggressive", + "_optimizations.sin_float_vert"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000004, + "KHR-GLES2.shaders.aggressive", + "_optimizations.sin_float_frag"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000005, + "KHR-GLES2.shaders.aggressive", + "_optimizations.sin_vec2_vert"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000006, + "KHR-GLES2.shaders.aggressive", + "_optimizations.sin_vec2_frag"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000007, + "KHR-GLES2.shaders.aggressive", + "_optimizations.sin_vec3_vert"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000008, + "KHR-GLES2.shaders.aggressive", + "_optimizations.sin_vec3_frag"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000009, + "KHR-GLES2.shaders.aggressive", + "_optimizations.cos_float_vert"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000010, + "KHR-GLES2.shaders.aggressive", + "_optimizations.cos_float_frag"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000011, + "KHR-GLES2.shaders.aggressive", + "_optimizations.cos_vec2_vert"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000012, + "KHR-GLES2.shaders.aggressive", + "_optimizations.cos_vec2_frag"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000013, + "KHR-GLES2.shaders.aggressive", + "_optimizations.cos_vec3_vert"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000014, + "KHR-GLES2.shaders.aggressive", + "_optimizations.cos_vec3_frag"); diff --git a/graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_negativeTestCase.cpp b/graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_negativeTestCase.cpp new file mode 100644 index 000000000..99050bb8d --- /dev/null +++ b/graphic/vkgl/src/khrgles2/shaders/Khrgles2shaders_negativeTestCase.cpp @@ -0,0 +1,32 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000001, + "KHR-GLES2.shaders.", + "negative.initialize"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000002, + "KHR-GLES2.shaders.nega", + "tive.constant_sequence"); diff --git a/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_combinationsTestCase.cpp b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_combinationsTestCase.cpp new file mode 100644 index 000000000..66c7be7cd --- /dev/null +++ b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_combinationsTestCase.cpp @@ -0,0 +1,1324 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000051, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.nearest_nearest_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000052, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000053, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000054, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000055, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000056, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000057, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000058, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000059, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000060, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000061, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000062, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000063, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000064, + "KHR-GLES2.texture_3d.filtering.combinati", + "ons.nearest_nearest_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000065, + "KHR-GLES2.texture_3d.filtering.combinati", + "ons.nearest_nearest_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000066, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000067, + "KHR-GLES2.texture_3d.filtering.combinati", + "ons.nearest_nearest_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000068, + "KHR-GLES2.texture_3d.filtering.combinati", + "ons.nearest_nearest_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000069, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000070, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000071, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000072, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000073, + "KHR-GLES2.texture_3d.filtering.combinati", + "ons.nearest_nearest_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000074, + "KHR-GLES2.texture_3d.filtering.combinati", + "ons.nearest_nearest_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000075, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_nearest_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000076, + "KHR-GLES2.texture_3d.filtering.combinati", + "ons.nearest_nearest_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000077, + "KHR-GLES2.texture_3d.filtering.combinati", + "ons.nearest_nearest_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000078, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.nearest_linear_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000079, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.nearest_linear_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000080, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.nearest_linear_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000081, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.nearest_linear_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000082, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000083, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000084, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.nearest_linear_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000085, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000086, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000087, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.nearest_linear_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000088, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000089, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000090, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000091, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000092, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000093, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000094, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000095, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000096, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.nearest_linear_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000097, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000098, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000099, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000100, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000101, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000102, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000103, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000104, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.nearest_linear_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000105, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_nearest_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000106, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_nearest_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000107, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_nearest_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000108, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_nearest_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000109, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000110, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000111, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_nearest_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000112, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000113, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000114, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_nearest_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000115, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000116, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000117, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000118, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000119, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000120, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000121, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000122, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000123, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_nearest_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000124, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000125, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000126, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000127, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000128, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000129, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000130, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000131, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_nearest_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000132, + "KHR-GLES2.texture_3d.filtering.combin", + "ations.linear_linear_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000133, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000134, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000135, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000136, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000137, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000138, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000139, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000140, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000141, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000142, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000143, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000144, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000145, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_linear_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000146, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_linear_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000147, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000148, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_linear_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000149, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_linear_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000150, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000151, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000152, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000153, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000154, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_linear_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000155, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_linear_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000156, + "KHR-GLES2.texture_3d.filtering.combina", + "tions.linear_linear_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000157, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_linear_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000158, + "KHR-GLES2.texture_3d.filtering.combinat", + "ions.linear_linear_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000159, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_nearest_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000160, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_nearest_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000161, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_nearest_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000162, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_nearest_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000163, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000164, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000165, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_nearest_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000166, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000167, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000168, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_nearest_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000169, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000170, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000171, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000172, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000173, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000174, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000175, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000176, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000177, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_nearest_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000178, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000179, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000180, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000181, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000182, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000183, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000184, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000185, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_nearest_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000186, + "KHR-GLES2.texture_3d.filtering.combinations.n", + "earest_mipmap_nearest_linear_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000187, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000188, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000189, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000190, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000191, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000192, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000193, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000194, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000195, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000196, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000197, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000198, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000199, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_linear_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000200, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_linear_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000201, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000202, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_linear_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000203, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_linear_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000204, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000205, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000206, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000207, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000208, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_linear_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000209, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_linear_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000210, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_nearest_linear_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000211, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_linear_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000212, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_nearest_linear_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000213, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_nearest_nearest_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000214, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000215, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000216, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000217, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000218, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000219, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000220, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000221, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000222, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000223, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000224, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000225, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000226, + "KHR-GLES2.texture_3d.filtering.combinations.lin", + "ear_mipmap_nearest_nearest_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000227, + "KHR-GLES2.texture_3d.filtering.combinations.lin", + "ear_mipmap_nearest_nearest_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000228, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000229, + "KHR-GLES2.texture_3d.filtering.combinations.lin", + "ear_mipmap_nearest_nearest_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000230, + "KHR-GLES2.texture_3d.filtering.combinations.lin", + "ear_mipmap_nearest_nearest_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000231, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000232, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000233, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000234, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000235, + "KHR-GLES2.texture_3d.filtering.combinations.lin", + "ear_mipmap_nearest_nearest_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000236, + "KHR-GLES2.texture_3d.filtering.combinations.lin", + "ear_mipmap_nearest_nearest_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000237, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_nearest_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000238, + "KHR-GLES2.texture_3d.filtering.combinations.lin", + "ear_mipmap_nearest_nearest_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000239, + "KHR-GLES2.texture_3d.filtering.combinations.lin", + "ear_mipmap_nearest_nearest_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000240, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_nearest_linear_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000241, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_nearest_linear_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000242, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_nearest_linear_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000243, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_nearest_linear_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000244, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000245, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000246, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_nearest_linear_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000247, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000248, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000249, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_nearest_linear_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000250, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000251, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000252, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000253, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000254, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000255, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000256, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000257, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000258, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_nearest_linear_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000259, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000260, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000261, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000262, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000263, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000264, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000265, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000266, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_nearest_linear_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000267, + "KHR-GLES2.texture_3d.filtering.combinations.n", + "earest_mipmap_linear_nearest_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000268, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000269, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000270, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000271, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000272, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000273, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000274, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000275, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000276, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000277, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000278, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000279, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000280, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_linear_nearest_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000281, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_linear_nearest_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000282, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000283, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_linear_nearest_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000284, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_linear_nearest_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000285, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000286, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000287, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000288, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000289, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_linear_nearest_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000290, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_linear_nearest_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000291, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_nearest_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000292, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_linear_nearest_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000293, + "KHR-GLES2.texture_3d.filtering.combinations.nea", + "rest_mipmap_linear_nearest_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000294, + "KHR-GLES2.texture_3d.filtering.combinations.n", + "earest_mipmap_linear_linear_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000295, + "KHR-GLES2.texture_3d.filtering.combinations.n", + "earest_mipmap_linear_linear_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000296, + "KHR-GLES2.texture_3d.filtering.combinations.n", + "earest_mipmap_linear_linear_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000297, + "KHR-GLES2.texture_3d.filtering.combinations.n", + "earest_mipmap_linear_linear_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000298, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000299, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000300, + "KHR-GLES2.texture_3d.filtering.combinations.n", + "earest_mipmap_linear_linear_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000301, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000302, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000303, + "KHR-GLES2.texture_3d.filtering.combinations.n", + "earest_mipmap_linear_linear_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000304, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000305, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000306, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000307, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000308, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000309, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000310, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000311, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000312, + "KHR-GLES2.texture_3d.filtering.combinations.n", + "earest_mipmap_linear_linear_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000313, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000314, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000315, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000316, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000317, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000318, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000319, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000320, + "KHR-GLES2.texture_3d.filtering.combinations.ne", + "arest_mipmap_linear_linear_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000321, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_nearest_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000322, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_nearest_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000323, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_nearest_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000324, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_nearest_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000325, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000326, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000327, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_nearest_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000328, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000329, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000330, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_nearest_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000331, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000332, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000333, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000334, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000335, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000336, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000337, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000338, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000339, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_nearest_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000340, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000341, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000342, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000343, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000344, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000345, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000346, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000347, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_nearest_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000348, + "KHR-GLES2.texture_3d.filtering.combinations.", + "linear_mipmap_linear_linear_clamp_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000349, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_clamp_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000350, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_clamp_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000351, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_clamp_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000352, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_clamp_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000353, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_clamp_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000354, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_clamp_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000355, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_clamp_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000356, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_clamp_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000357, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_repeat_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000358, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_repeat_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000359, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_repeat_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000360, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_repeat_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000361, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_linear_repeat_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000362, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_linear_repeat_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000363, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_repeat_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000364, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_linear_repeat_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000365, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_linear_repeat_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000366, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_mirror_clamp_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000367, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_mirror_clamp_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000368, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_mirror_clamp_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000369, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_mirror_repeat_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000370, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_linear_mirror_repeat_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000371, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_linear_mirror_repeat_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000372, + "KHR-GLES2.texture_3d.filtering.combinations.l", + "inear_mipmap_linear_linear_mirror_mirror_clamp"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000373, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_linear_mirror_mirror_repeat"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000374, + "KHR-GLES2.texture_3d.filtering.combinations.li", + "near_mipmap_linear_linear_mirror_mirror_mirror"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000375, + "KHR-GLES2.texture_3d.filte", + "ring.combinations.negative"); diff --git a/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_formatsTestCase.cpp b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_formatsTestCase.cpp new file mode 100644 index 000000000..de17398cf --- /dev/null +++ b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_formatsTestCase.cpp @@ -0,0 +1,48 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000015, + "KHR-GLES2.texture_3d.filte", + "ring.formats.rgba8_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000016, + "KHR-GLES2.texture_3d.filt", + "ering.formats.rgba8_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000017, + "KHR-GLES2.texture_3d.filtering.fo", + "rmats.rgba8_nearest_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000018, + "KHR-GLES2.texture_3d.filtering.fo", + "rmats.rgba8_linear_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000019, + "KHR-GLES2.texture_3d.filtering.fo", + "rmats.rgba8_nearest_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000020, + "KHR-GLES2.texture_3d.filtering.f", + "ormats.rgba8_linear_mipmap_linear"); diff --git a/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_sizesTestCase.cpp b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_sizesTestCase.cpp new file mode 100644 index 000000000..2160ce37e --- /dev/null +++ b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2filtering_sizesTestCase.cpp @@ -0,0 +1,144 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000021, + "KHR-GLES2.texture_3d.filt", + "ering.sizes.4x8x8_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000022, + "KHR-GLES2.texture_3d.fil", + "tering.sizes.4x8x8_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000023, + "KHR-GLES2.texture_3d.filtering.s", + "izes.4x8x8_nearest_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000024, + "KHR-GLES2.texture_3d.filtering.s", + "izes.4x8x8_linear_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000025, + "KHR-GLES2.texture_3d.filtering.s", + "izes.4x8x8_nearest_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000026, + "KHR-GLES2.texture_3d.filtering.", + "sizes.4x8x8_linear_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000027, + "KHR-GLES2.texture_3d.filte", + "ring.sizes.32x64x16_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000028, + "KHR-GLES2.texture_3d.filte", + "ring.sizes.32x64x16_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000029, + "KHR-GLES2.texture_3d.filtering.siz", + "es.32x64x16_nearest_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000030, + "KHR-GLES2.texture_3d.filtering.si", + "zes.32x64x16_linear_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000031, + "KHR-GLES2.texture_3d.filtering.si", + "zes.32x64x16_nearest_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000032, + "KHR-GLES2.texture_3d.filtering.si", + "zes.32x64x16_linear_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000033, + "KHR-GLES2.texture_3d.filter", + "ing.sizes.128x32x64_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000034, + "KHR-GLES2.texture_3d.filte", + "ring.sizes.128x32x64_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000035, + "KHR-GLES2.texture_3d.filtering.siz", + "es.128x32x64_nearest_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000036, + "KHR-GLES2.texture_3d.filtering.siz", + "es.128x32x64_linear_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000037, + "KHR-GLES2.texture_3d.filtering.siz", + "es.128x32x64_nearest_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000038, + "KHR-GLES2.texture_3d.filtering.si", + "zes.128x32x64_linear_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000039, + "KHR-GLES2.texture_3d.filt", + "ering.sizes.3x7x5_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000040, + "KHR-GLES2.texture_3d.fil", + "tering.sizes.3x7x5_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000041, + "KHR-GLES2.texture_3d.filtering.s", + "izes.3x7x5_nearest_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000042, + "KHR-GLES2.texture_3d.filtering.s", + "izes.3x7x5_linear_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000043, + "KHR-GLES2.texture_3d.filtering.s", + "izes.3x7x5_nearest_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000044, + "KHR-GLES2.texture_3d.filtering.", + "sizes.3x7x5_linear_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000045, + "KHR-GLES2.texture_3d.filte", + "ring.sizes.63x63x63_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000046, + "KHR-GLES2.texture_3d.filte", + "ring.sizes.63x63x63_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000047, + "KHR-GLES2.texture_3d.filtering.siz", + "es.63x63x63_nearest_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000048, + "KHR-GLES2.texture_3d.filtering.si", + "zes.63x63x63_linear_mipmap_nearest"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000049, + "KHR-GLES2.texture_3d.filtering.si", + "zes.63x63x63_nearest_mipmap_linear"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000050, + "KHR-GLES2.texture_3d.filtering.si", + "zes.63x63x63_linear_mipmap_linear"); diff --git a/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_compressed_textureTestCase.cpp b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_compressed_textureTestCase.cpp new file mode 100644 index 000000000..eb998ddee --- /dev/null +++ b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_compressed_textureTestCase.cpp @@ -0,0 +1,144 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000382, + "KHR-GLES2.texture_3d.compres", + "sed_texture.rgba_astc_4x4_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000383, + "KHR-GLES2.texture_3d.compres", + "sed_texture.rgba_astc_5x4_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000384, + "KHR-GLES2.texture_3d.compres", + "sed_texture.rgba_astc_5x5_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000385, + "KHR-GLES2.texture_3d.compres", + "sed_texture.rgba_astc_6x5_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000386, + "KHR-GLES2.texture_3d.compres", + "sed_texture.rgba_astc_6x6_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000387, + "KHR-GLES2.texture_3d.compres", + "sed_texture.rgba_astc_8x5_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000388, + "KHR-GLES2.texture_3d.compres", + "sed_texture.rgba_astc_8x6_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000389, + "KHR-GLES2.texture_3d.compres", + "sed_texture.rgba_astc_8x8_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000390, + "KHR-GLES2.texture_3d.compress", + "ed_texture.rgba_astc_10x5_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000391, + "KHR-GLES2.texture_3d.compress", + "ed_texture.rgba_astc_10x6_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000392, + "KHR-GLES2.texture_3d.compress", + "ed_texture.rgba_astc_10x8_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000393, + "KHR-GLES2.texture_3d.compress", + "ed_texture.rgba_astc_10x10_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000394, + "KHR-GLES2.texture_3d.compress", + "ed_texture.rgba_astc_12x10_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000395, + "KHR-GLES2.texture_3d.compress", + "ed_texture.rgba_astc_12x12_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000396, + "KHR-GLES2.texture_3d.compressed_", + "texture.srgb8_alpha8_astc_4x4_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000397, + "KHR-GLES2.texture_3d.compressed_", + "texture.srgb8_alpha8_astc_5x4_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000398, + "KHR-GLES2.texture_3d.compressed_", + "texture.srgb8_alpha8_astc_5x5_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000399, + "KHR-GLES2.texture_3d.compressed_", + "texture.srgb8_alpha8_astc_6x5_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000400, + "KHR-GLES2.texture_3d.compressed_", + "texture.srgb8_alpha8_astc_6x6_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000401, + "KHR-GLES2.texture_3d.compressed_", + "texture.srgb8_alpha8_astc_8x5_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000402, + "KHR-GLES2.texture_3d.compressed_", + "texture.srgb8_alpha8_astc_8x6_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000403, + "KHR-GLES2.texture_3d.compressed_", + "texture.srgb8_alpha8_astc_8x8_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000404, + "KHR-GLES2.texture_3d.compressed_", + "texture.sgb8_alpha8_astc_10x5_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000405, + "KHR-GLES2.texture_3d.compressed_t", + "exture.srgb8_alpha8_astc_10x6_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000406, + "KHR-GLES2.texture_3d.compressed_t", + "exture.srgb8_alpha8_astc_10x8_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000407, + "KHR-GLES2.texture_3d.compressed_t", + "exture.srgb8_alpha8_astc_10x10_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000408, + "KHR-GLES2.texture_3d.compressed_t", + "exture.srgb8_alpha8_astc_12x10_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000409, + "KHR-GLES2.texture_3d.compressed_t", + "exture.srgb8_alpha8_astc_12x12_khr"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000410, + "KHR-GLES2.texture_3d.compressed_te", + "xture.negative_compressed_tex_image"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000411, + "KHR-GLES2.texture_3d.compressed_text", + "ure.negative_compressed_tex_sub_image"); diff --git a/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_copy_sub_imageTestCase.cpp b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_copy_sub_imageTestCase.cpp new file mode 100644 index 000000000..fd36d31f3 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_copy_sub_imageTestCase.cpp @@ -0,0 +1,32 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000378, + "KHR-GLES2.texture_3d", + ".copy_sub_image.rgba"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000379, + "KHR-GLES2.texture_3d.c", + "opy_sub_image.negative"); diff --git a/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_framebuffer_textureTestCase.cpp b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_framebuffer_textureTestCase.cpp new file mode 100644 index 000000000..465119fe0 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_framebuffer_textureTestCase.cpp @@ -0,0 +1,32 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000380, + "KHR-GLES2.texture_3d.f", + "ramebuffer_texture.rgba"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000381, + "KHR-GLES2.texture_3d.fra", + "mebuffer_texture.negative"); diff --git a/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_sub_imageTestCase.cpp b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_sub_imageTestCase.cpp new file mode 100644 index 000000000..80d0abc22 --- /dev/null +++ b/graphic/vkgl/src/khrgles2/texture_3d/Khrgles2texture_3d_sub_imageTestCase.cpp @@ -0,0 +1,32 @@ +/* + * 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 +#include "../Khrgles2BaseFunc.h" +#include "../ActsKhrgles20001TestSuite.h" +#include "shrinkdefine.h" + +using namespace std; +using namespace testing::ext; +using namespace OHOS; + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000376, + "KHR-GLES2.texture_", + "3d.sub_image.rgba8"); + +static SHRINK_HWTEST_F(ActsKhrgles20001TestSuite, TestCase_000377, + "KHR-GLES2.texture_3", + "d.sub_image.negative"); -- GitLab