Skip to content

X
Xts Acts

OpenHarmony / Xts Acts
接近 2 年 前同步成功

通知 9
Star 22
Fork 0
X
Xts Acts
未验证 提交 bfe0008b 编写于 作者: O openharmony_ci 提交者： Gitee
浏览文件
操作

!3819 add khrglesext testcase 

Merge pull request !3819 from daiqian2/master
上级 a044ceeb 477830ef
展开全部 隐藏空白更改
内联 并排
Showing with 10414 addition and 0 deletion
graphic/vkgl/src/khrglesext/ActsKhrglesext0001TestSuite.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include <ctime>
#include "KhrglesextBaseFunc.h"
#include "ActsKhrglesext0001TestSuite.h"
namespace OHOS {
using namespace std;
using namespace testing::ext;
time_t ActsKhrglesext0001TestSuite::starttime;
time_t ActsKhrglesext0001TestSuite::endtime;
FuncRunResult ActsKhrglesext0001TestSuite::runResult;
// Preset action of the test suite, which is executed before the first test case
void ActsKhrglesext0001TestSuite::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 ActsKhrglesext0001TestSuite::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 ActsKhrglesext0001TestSuite::SetUp()
{
}
// Cleanup action of the test case
void ActsKhrglesext0001TestSuite::TearDown()
{
}
}
\ No newline at end of file
graphic/vkgl/src/khrglesext/ActsKhrglesext0001TestSuite.h 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 KHRGLESEXT_TESTCASE_H
#define KHRGLESEXT_TESTCASE_H
#include <gtest/gtest.h>
#include "KhrglesextBaseFunc.h"
namespace OHOS {
class ActsKhrglesext0001TestSuite : 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();
// Cleanup action of the test case
virtual void TearDown();
};
} // namespace OHOS
#endif // KHRGLESEXT_TESTCASE_H
\ No newline at end of file
graphic/vkgl/src/khrglesext/ActsKhrglesextTestSuite.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include <ctime>
#include "KhrglesextBaseFunc.h"
#include "ActsKhrglesextTestSuite.h"
namespace OHOS {
using namespace std;
using namespace testing::ext;
time_t ActsKhrglesextTestSuite::starttime;
time_t ActsKhrglesextTestSuite::endtime;
FuncRunResult ActsKhrglesextTestSuite::runResult;
// Preset action of the test suite, which is executed before the first test case
void ActsKhrglesextTestSuite::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 ActsKhrglesextTestSuite::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 ActsKhrglesextTestSuite::SetUp()
{
}
// Cleanup action of the test case
void ActsKhrglesextTestSuite::TearDown()
{
}
}
\ No newline at end of file
graphic/vkgl/src/khrglesext/ActsKhrglesextTestSuite.h 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 KHRGLESEXT_TESTCASE_H
#define KHRGLESEXT_TESTCASE_H
#include <gtest/gtest.h>
#include "KhrglesextBaseFunc.h"
namespace OHOS {
class ActsKhrglesextTestSuite : 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();
// Cleanup action of the test case
virtual void TearDown();
};
} // namespace OHOS
#endif // KHRGLESEXT_TESTCASE_H
\ No newline at end of file
graphic/vkgl/src/khrglesext/KhrglesextBaseFunc.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 "tcuDefs.hpp"
#include "tcuCommandLine.hpp"
#include "tcuPlatform.hpp"
#include "ActsApp.h"
#include "tcuResource.hpp"
#include "tcuTestLog.hpp"
#include "tcuTestSessionExecutor.hpp"
#include "deUniquePtr.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 "KhrglesextBaseFunc.h"
static tcu::TestPackage* createKhrglesextPackage(tcu::TestContext& testCtx)
{
return new esextcts::ESEXTTestPackage(testCtx, "KHR-KHRGLESEXT");
}
void RegistPackage(void)
{
tcu::TestPackageRegistry *registry = tcu::TestPackageRegistry::getSingleton();
registry->registerPackage("KHR-GLESEXT", createKhrglesextPackage);
}
FuncRunResult RunTestKHRGLES(int argc, const char** argv)
{
FuncRunResult runResult;
try {
tcu::CommandLine cmdLine(argc, argv);
tcu::DirArchive archive(cmdLine.getArchiveDir());
de::UniquePtr<tcu::Platform> platform(createOhosPlatform());
de::UniquePtr<tcu::ActsApp> app(new tcu::ActsApp(*platform, archive, 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
graphic/vkgl/src/khrglesext/KhrglesextBaseFunc.h 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 KHRGLESEXT_FUNC_H
#define KHRGLESEXT_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 // KHRGLESEXT_FUNC_H
\ No newline at end of file
graphic/vkgl/src/khrglesext/build0001/BUILD.gn 0 → 100644
浏览文件 @ bfe0008b
# 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/vkglcts/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("libkhrglesextfunc0001") {
sources = common_src
sources += [ "../KhrglesextBaseFunc.cpp" ]
include_dirs = common_include
deps = common_depends
external_deps = [
"hilog_native:libhilog",
"multimedia_image_standard:image_native",
]
lib_dirs = [ "//third_party/VK-GL-CTS/outlibs" ]
libs = [ "png" ]
configs = [ ":deqp_platform_ohos_config" ]
public_deps = [ "//foundation/ace/ace_engine/build/external_config/flutter/skia:ace_skia_ohos" ]
}
ohos_moduletest_suite("ActsKhrglesextTestSuite0001") {
sources = [
"../ActsKhrglesext0001TestSuite.cpp",
"../disjoint_timer_query/KhrglesextKHR-GLESEXT_disjoint_timer_queryTestCase.cpp",
"../draw_elements_base_vertex_tests/KhrglesextKHR-GLESEXT_draw_elements_base_vertex_testsTestCase.cpp",
"../ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_textureTestCase.cpp",
"../ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_texturelodTestCase.cpp",
"../ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_texturelodoffsetTestCase.cpp",
"../ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_textureoffsetTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_adjacencyTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_apiTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_blittingTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_clippingTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_constant_variablesTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_inputTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_layered_fboTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_layered_framebufferTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_layered_renderingTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_layered_rendering_boundary_conditionTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_layered_rendering_fbo_no_attachmentTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_limitsTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_linkingTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_nonarray_inputTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_outputTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_primitive_counterTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_primitive_queriesTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_program_resourceTestCase.cpp",
"../geometry_shader/Khrglesextgeometry_shader_qualifiersTestCase.cpp",
"../geometry_shader/Khrglesextrendering_renderingTestCase.cpp",
"../gpu_shader5/KhrglesextKHR-GLESEXT_gpu_shader5TestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_compilation_and_linking_errorsTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_singleTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_tessellation_control_to_tessellation_evaluationTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_tessellation_invarianceTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_point_modeTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_quads_tessellationTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_tc_barriersTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_tessellationTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_tessellation_shader_triangles_tessellationTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_vertexTestCase.cpp",
"../tessellation_shader/Khrglesexttessellation_shader_windingTestCase.cpp",
"../texture_border_clamp/KhrglesextKHR-GLESEXT_texture_border_clampTestCase.cpp",
"../texture_buffer/KhrglesextKHR-GLESEXT_texture_bufferTestCase.cpp",
"../texture_cube_map_array/KhrglesextKHR-GLESEXT_texture_cube_map_arrayTestCase.cpp",
"../viewport_array/KhrglesextKHR-GLESEXT_viewport_arrayTestCase.cpp",
]
include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ]
deps = [ ":libkhrglesextfunc0001" ]
cflags = [ "-Wno-error" ]
}
graphic/vkgl/src/khrglesext/build0001/Test.json 0 → 100644
浏览文件 @ bfe0008b
{
"description": "Config for ActsKhrglesextTestSuite0001 test cases",
"driver": {
"module-name": "ActsKhrglesextTestSuite0001",
"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": [
"ActsKhrglesextTestSuite0001->/data/local/tmp/ActsKhrglesextTestSuite0001",
"../../../common/common/librosen_context.z.so->/system/lib",
"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
graphic/vkgl/src/khrglesext/disjoint_timer_query/KhrglesextKHR-GLESEXT_disjoint_timer_queryTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000335, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000335 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.disjoint_t"
"imer_query.handle_reuse",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000335 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000335 end";
}
graphic/vkgl/src/khrglesext/draw_elements_base_vertex_tests/KhrglesextKHR-GLESEXT_draw_elements_base_vertex_testsTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000290, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000290 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_base_v"
"ertex_tests.basevertex_behavior1",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000290 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000290 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000291, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000291 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_base_v"
"ertex_tests.basevertex_behavior2",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000291 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000291 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000292, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000292 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_base"
"_vertex_tests.AEP_shader_stages",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000292 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000292 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000293, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000293 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_"
"base_vertex_tests.underflow",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000293 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000293 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000294, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000294 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_"
"base_vertex_tests.overflow",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000294 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000294 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000295, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000295 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_bas"
"e_vertex_tests.valid_active_tf",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000295 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000295 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000296, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000296 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_base_ve"
"rtex_tests.invalid_count_argument",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000296 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000296 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000297, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000297 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_base_vertex"
"_tests.invalid_instancecount_argument",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000297 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000297 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000298, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000298 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_base_v"
"ertex_tests.invalid_mode_argument",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000298 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000298 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000299, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000299 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_base_vert"
"ex_tests.invalid_primcount_argument",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000299 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000299 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000300, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000300 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_base_vert"
"ex_tests.invalid_start_end_arguments",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000300 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000300 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000301, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000301 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.draw_elements_base_v"
"ertex_tests.invalid_type_argument",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000301 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000301 end";
}
graphic/vkgl/src/khrglesext/ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_textureTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000319, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000319 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod."
"texture.sampler2darrayshadow_vertex",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000319 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000319 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000320, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000320 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.t"
"exture.sampler2darrayshadow_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000320 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000320 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000321, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000321 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.tex"
"ture.sampler2darrayshadow_bias_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000321 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000321 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000322, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000322 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.t"
"exture.samplercubearrayshadow_vertex",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000322 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000322 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000323, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000323 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.te"
"xture.samplercubearrayshadow_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000323 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000323 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000324, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000324 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.text"
"ure.samplercubearrayshadow_bias_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000324 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000324 end";
}
graphic/vkgl/src/khrglesext/ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_texturelodTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000328, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000328 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.t"
"exturelod.sampler2darrayshadow_vertex",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000328 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000328 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000329, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000329 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.te"
"xturelod.sampler2darrayshadow_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000329 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000329 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000330, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000330 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod."
"texturelod.samplercubeshadow_vertex",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000330 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000330 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000331, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000331 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.t"
"exturelod.samplercubeshadow_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000331 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000331 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000332, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000332 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.tex"
"turelod.samplercubearrayshadow_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000332 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000332 end";
}
graphic/vkgl/src/khrglesext/ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_texturelodoffsetTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000333, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000333 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.text"
"urelodoffset.sampler2darrayshadow_vertex",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000333 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000333 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000334, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000334 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.textu"
"relodoffset.sampler2darrayshadow_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000334 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000334 end";
}
graphic/vkgl/src/khrglesext/ext_texture_shadow_lod/Khrglesextext_texture_shadow_lod_textureoffsetTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000325, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000325 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.tex"
"tureoffset.sampler2darrayshadow_vertex",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000325 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000325 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000326, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000326 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.text"
"ureoffset.sampler2darrayshadow_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000326 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000326 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000327, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000327 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.ext_texture_shadow_lod.textur"
"eoffset.sampler2darrayshadow_bias_fragment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000327 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000327 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_adjacencyTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000001, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000001 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.adja"
"cency.adjacency_non_indiced_lines",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000001 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000001 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000002, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000002 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.ad"
"jacency.adjacency_indiced_lines",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000002 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000002 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000003, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000003 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.adjacen"
"cy.adjacency_non_indiced_line_strip",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000003 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000003 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000004, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000004 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.adjac"
"ency.adjacency_indiced_line_strip",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000004 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000004 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000005, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000005 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.adjace"
"ncy.adjacency_non_indiced_triangles",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000005 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000005 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000006, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000006 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.adja"
"cency.adjacency_indiced_triangles",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000006 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000006 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000007, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000007 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.adjacency"
".adjacency_non_indiced_triangle_strip",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000007 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000007 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000008, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000008 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.adjacen"
"cy.adjacency_indiced_triangle_strip",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000008 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000008 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_apiTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000112, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000112 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shade"
"r.api.createShaderProgramv",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000112 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000112 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000113, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000113 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_"
"shader.api.shader_type",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000113 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000113 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000114, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000114 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_s"
"hader.api.getProgramiv",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000114 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000114 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000115, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000115 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_s"
"hader.api.getProgramiv2",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000115 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000115 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000116, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000116 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_s"
"hader.api.getProgramiv3",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000116 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000116 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000117, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000117 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_sh"
"ader.api.fs_gs_draw_call",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000117 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000117 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000118, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000118 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shad"
"er.api.max_image_uniforms",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000118 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000118 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000119, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000119 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader."
"api.max_shader_storage_blocks",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000119 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000119 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000120, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000120 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shad"
"er.api.max_atomic_counters",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000120 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000120 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000121, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000121 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.a"
"pi.max_atomic_counter_buffers",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000121 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000121 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000122, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000122 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.api.p"
"ipeline_program_without_active_vs",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000122 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000122 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000123, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000123 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.a"
"pi.incompatible_draw_call_mode",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000123 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000123 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000124, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000124 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.ap"
"i.insufficient_emitted_vertices",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000124 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000124 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000125, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000125 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.api"
".program_pipeline_vs_gs_capture",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000125 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000125 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000126, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000126 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.api.draw_pr"
"imitives_do_not_match_output_primitives",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000126 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000126 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000127, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000127 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.ap"
"i.draw_calls_while_tf_is_paused",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000127 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000127 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_blittingTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000069, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000069 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader"
".blitting.layered_nonlayered",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000069 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000069 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000070, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000070 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader"
".blitting.nonlayered_layered",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000070 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000070 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000071, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000071 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shade"
"r.blitting.layered_layered",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000071 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000071 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_clippingTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000068, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000068 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_s"
"hader.clipping.clipping",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000068 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000068 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_constant_variablesTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000089, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000089 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.cons"
"tant_variables.constant_variables",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000089 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000089 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_inputTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000044, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000044 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader"
".input.gl_in_array_contents",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000044 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000044 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000045, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000045 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shade"
"r.input.gl_in_array_length",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000045 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000045 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000046, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000046 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shade"
"r.input.gl_pointsize_value",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000046 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000046 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000047, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000047 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shad"
"er.input.gl_position_value",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000047 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000047 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_layered_fboTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000129, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000129 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shad"
"er.layered_fbo.layered_fbo",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000129 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000129 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000130, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000130 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.lay"
"ered_fbo.layered_fbo_attachments",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000130 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000130 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000131, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000131 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.laye"
"red_fbo.fb_texture_invalid_target",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000131 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000131 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000132, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000132 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layered_"
"fbo.fb_texture_no_fbo_bound_to_target",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000132 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000132 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000133, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000133 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layere"
"d_fbo.fb_texture_invalid_attachment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000133 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000133 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000134, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000134 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.laye"
"red_fbo.fb_texture_invalid_value",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000134 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000134 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000135, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000135 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layered"
"_fbo.fb_texture_invalid_level_number",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000135 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000135 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000136, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000136 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layered_fbo.fb"
"_texture_argument_refers_to_buffer_texture",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000136 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000136 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_layered_framebufferTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000076, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000076 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.lay"
"ered_framebuffer.stencil_support",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000076 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000076 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000077, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000077 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.la"
"yered_framebuffer.depth_support",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000077 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000077 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000078, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000078 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.laye"
"red_framebuffer.blending_support",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000078 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000078 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000079, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000079 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layer"
"ed_framebuffer.clear_call_support",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000079 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000079 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_layered_renderingTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000067, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000067 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.lay"
"ered_rendering.layered_rendering",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000067 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000067 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_layered_rendering_boundary_conditionTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000072, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000072 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layered_rendering_boundary_cond"
"ition.layered_rendering_boundary_condition_various_textures",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000072 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000072 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000073, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000073 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layered_rendering_boundar"
"y_condition.layered_rendering_boundary_condition_no_gs",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000073 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000073 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000074, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000074 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layered_rendering_boundary_cond"
"ition.layered_rendering_boundary_condition_no_default_layer",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000074 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000074 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000075, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000075 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layered_rendering_boundary_con"
"dition.layered_rendering_boundary_condition_no_layered_fbo",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000075 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000075 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_layered_rendering_fbo_no_attachmentTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000088, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000088 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.layered_rendering_fbo"
"_no_attachment.layered_rendering_fbo_no_attachment",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000088 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000088 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_limitsTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000090, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000090 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader."
"limits.max_uniform_components",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000090 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000090 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000091, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000091 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shade"
"r.limits.max_uniform_blocks",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000091 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000091 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000092, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000092 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader"
".limits.max_input_components",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000092 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000092 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000093, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000093 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader."
"limits.max_output_components",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000093 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000093 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000094, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000094 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader"
".limits.max_output_vertices",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000094 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000094 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000095, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000095 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.limits"
".max_output_components_single_point",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000095 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000095 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000096, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000096 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shade"
"r.limits.max_texture_units",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000096 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000096 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000097, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000097 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shad"
"er.limits.max_invocations",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000097 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000097 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000098, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000098 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.li"
"mits.max_combined_texture_units",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000098 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000098 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_linkingTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000099, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000099 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.lin"
"king.incomplete_program_objects",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000099 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000099 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000100, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000100 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_sha"
"der.linking.incomplete_gs",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000100 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000100 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000101, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000101 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.linki"
"ng.invalid_arrayed_input_variables",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000101 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000101 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000102, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000102 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.link"
"ing.vs_gs_variable_type_mismatch",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000102 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000102 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000103, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000103 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.linkin"
"g.vs_gs_variable_qualifier_mismatch",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000103 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000103 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000104, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000104 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.linking."
"vs_gs_arrayed_variable_size_mismatch",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000104 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000104 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000105, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000105 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.l"
"inking.fragcoord_redeclaration",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000105 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000105 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000106, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000106 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shade"
"r.linking.location_aliasing",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000106 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000106 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000107, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000107 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.link"
"ing.more_ACs_in_GS_than_supported",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000107 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000107 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000108, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000108 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.linki"
"ng.more_ACBs_in_GS_than_supported",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000108 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000108 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000109, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000109 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.linkin"
"g.geometry_shader_compilation_fail",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000109 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000109 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000110, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000110 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.linking.mo"
"re_input_vertices_in_GS_than_available",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000110 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000110 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000111, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000111 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.linking"
".tf_capture_from_gs_and_vs_variables",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000111 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000111 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_nonarray_inputTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000043, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000043 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader."
"nonarray_input.nonarray_input",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000043 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000043 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_outputTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000080, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000080 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.out"
"put.conflicted_output_primitive",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000080 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000080 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000081, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000081 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.outp"
"ut.conflicted_output_vertices_max",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000081 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000081 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000082, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000082 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shade"
"r.output.vertex_emit_at_end",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000082 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000082 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000083, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000083 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.ou"
"tput.primitive_end_done_at_end",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000083 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000083 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000084, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000084 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.output.p"
"rimite_end_done_for_single_primitive",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000084 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000084 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_primitive_queriesTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000085, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000085 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.primiti"
"ve_queries.primitive_queries_points",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000085 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000085 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000086, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000086 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.primit"
"ive_queries.primitive_queries_lines",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000086 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000086 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000087, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000087 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.primitiv"
"e_queries.primitive_queries_triangles",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000087 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000087 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_program_resourceTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000042, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000042 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader.pr"
"ogram_resource.program_resource",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000042 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000042 end";
}
graphic/vkgl/src/khrglesext/geometry_shader/Khrglesextgeometry_shader_qualifiersTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000128, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000128 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.geometry_shader."
"qualifiers.flat_interpolation",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000128 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000128 end";
}
graphic/vkgl/src/khrglesext/tessellation_shader/Khrglesexttessellation_shader_singleTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000160, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000160 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shader.single.d"
"efault_values_of_context_wide_properties",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000160 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000160 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000161, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000161 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shade"
"r.single.isolines_tessellation",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000161 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000161 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000162, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000162 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shader.single"
".ext_program_interface_query_dependency",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000162 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000162 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000163, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000163 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shader."
"single.program_object_properties",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000163 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000163 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000164, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000164 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shader.singl"
"e.xfb_captures_data_from_correct_stage",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000164 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000164 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000165, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000165 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_sha"
"der.single.max_patch_vertices",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000165 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000165 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000166, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000166 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_sha"
"der.single.primitive_coverage",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000166 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000166 end";
}
graphic/vkgl/src/khrglesext/tessellation_shader/Khrglesexttessellation_shader_tessellation_control_to_tessellation_evaluationTestCase.cpp 0 → 100644
浏览文件 @ bfe0008b
/*
* 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 <gtest/gtest.h>
#include "../KhrglesextBaseFunc.h"
#include "../ActsKhrglesext0001TestSuite.h"
using namespace std;
using namespace testing::ext;
using namespace OHOS;
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000169, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000169 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shader.tessellation_con"
"trol_to_tessellation_evaluation.data_pass_through",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000169 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000169 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000170, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000170 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shader.tessellati"
"on_control_to_tessellation_evaluation.gl_in",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000170 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000170 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000171, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000171 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shader.tessellation_control_to_tes"
"sellation_evaluation.gl_MaxPatchVertices_Position_PointSize",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000171 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000171 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000172, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000172 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shader.tessellation_cont"
"rol_to_tessellation_evaluation.gl_PatchVerticesIn",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000172 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000172 end";
}
static HWTEST_F(ActsKhrglesext0001TestSuite, TestCase_000173, Function | MediumTest | Level2)
{
GTEST_LOG_(INFO) << "TestCase_000173 start";
int argc = 3;
const char *argv[3] = {
".",
"--deqp-case="
"KHR-GLESEXT.tessellation_shader.tessellation_c"
"ontrol_to_tessellation_evaluation.gl_tessLevel",
"--deqp-archive-dir=/data/local/tmp/"
};
FuncRunResult result = RunTestKHRGLES(argc, argv);
ActsKhrglesext0001TestSuite::runResult.numPassed += result.numPassed;
ActsKhrglesext0001TestSuite::runResult.numFailed += result.numFailed;
ActsKhrglesext0001TestSuite::runResult.numNotSupported += result.numNotSupported;
ActsKhrglesext0001TestSuite::runResult.numWarnings += result.numWarnings;
ActsKhrglesext0001TestSuite::runResult.numWaived += result.numWaived;
if (result.numNotSupported == 1) {
GTEST_LOG_(INFO) << "TestCase_000173 notsupport!";
} else if (result.isComplete) {
EXPECT_TRUE(result.isComplete);
EXPECT_TRUE(result.numPassed == 1);
};
GTEST_LOG_(INFO) << "TestCase_000173 end";
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或