diff --git a/graphic/vkgl/src/khrgles32/ActsKhrgles320001TestSuite.cpp b/graphic/vkgl/src/khrgles32/ActsKhrgles320001TestSuite.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d4d2fa53a4781c7d78b97a289494fe8df963c88d --- /dev/null +++ b/graphic/vkgl/src/khrgles32/ActsKhrgles320001TestSuite.cpp @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "Khrgles32BaseFunc.h" +#include "ActsKhrgles320001TestSuite.h" + +namespace OHOS { + using namespace std; + using namespace testing::ext; + + time_t ActsKhrgles320001TestSuite::starttime; + time_t ActsKhrgles320001TestSuite::endtime; + FuncRunResult ActsKhrgles320001TestSuite::runResult; + + // Preset action of the test suite, which is executed before the first test case + void ActsKhrgles320001TestSuite::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 ActsKhrgles320001TestSuite::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 ActsKhrgles320001TestSuite::SetUp() + { + } + // Cleanup action of the test case + void ActsKhrgles320001TestSuite::TearDown() + { + } +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles32/ActsKhrgles320001TestSuite.h b/graphic/vkgl/src/khrgles32/ActsKhrgles320001TestSuite.h new file mode 100644 index 0000000000000000000000000000000000000000..d27fa3e939e3afb9df552649c8f00c843dd14253 --- /dev/null +++ b/graphic/vkgl/src/khrgles32/ActsKhrgles320001TestSuite.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef KHRGLES32_TESTCASE_H +#define KHRGLES32_TESTCASE_H + +#include +#include "Khrgles32BaseFunc.h" + +namespace OHOS { + class ActsKhrgles320001TestSuite : 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 // KHRGLES32_TESTCASE_H \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles32/ActsKhrgles320002TestSuite.cpp b/graphic/vkgl/src/khrgles32/ActsKhrgles320002TestSuite.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e5fb2ce44c4daa8c8f5b5d103c607d4c738e27ef --- /dev/null +++ b/graphic/vkgl/src/khrgles32/ActsKhrgles320002TestSuite.cpp @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "Khrgles32BaseFunc.h" +#include "ActsKhrgles320002TestSuite.h" + +namespace OHOS { + using namespace std; + using namespace testing::ext; + + time_t ActsKhrgles320002TestSuite::starttime; + time_t ActsKhrgles320002TestSuite::endtime; + FuncRunResult ActsKhrgles320002TestSuite::runResult; + + // Preset action of the test suite, which is executed before the first test case + void ActsKhrgles320002TestSuite::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 ActsKhrgles320002TestSuite::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 ActsKhrgles320002TestSuite::SetUp() + { + } + // Cleanup action of the test case + void ActsKhrgles320002TestSuite::TearDown() + { + } +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles32/ActsKhrgles320002TestSuite.h b/graphic/vkgl/src/khrgles32/ActsKhrgles320002TestSuite.h new file mode 100644 index 0000000000000000000000000000000000000000..3be85f89a34d6e5ccf6a22f788a58deed21fffd5 --- /dev/null +++ b/graphic/vkgl/src/khrgles32/ActsKhrgles320002TestSuite.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef KHRGLES32_TESTCASE_H +#define KHRGLES32_TESTCASE_H + +#include +#include "Khrgles32BaseFunc.h" + +namespace OHOS { + class ActsKhrgles320002TestSuite : 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 // KHRGLES32_TESTCASE_H \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles32/ActsKhrgles32TestSuite.cpp b/graphic/vkgl/src/khrgles32/ActsKhrgles32TestSuite.cpp new file mode 100644 index 0000000000000000000000000000000000000000..42867bbad0c1dbdac8ec939526a34c28791ecdd1 --- /dev/null +++ b/graphic/vkgl/src/khrgles32/ActsKhrgles32TestSuite.cpp @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include "Khrgles32BaseFunc.h" +#include "ActsKhrgles32TestSuite.h" + +namespace OHOS { + using namespace std; + using namespace testing::ext; + + time_t ActsKhrgles32TestSuite::starttime; + time_t ActsKhrgles32TestSuite::endtime; + FuncRunResult ActsKhrgles32TestSuite::runResult; + + // Preset action of the test suite, which is executed before the first test case + void ActsKhrgles32TestSuite::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 ActsKhrgles32TestSuite::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 ActsKhrgles32TestSuite::SetUp() + { + } + // Cleanup action of the test case + void ActsKhrgles32TestSuite::TearDown() + { + } +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles32/ActsKhrgles32TestSuite.h b/graphic/vkgl/src/khrgles32/ActsKhrgles32TestSuite.h new file mode 100644 index 0000000000000000000000000000000000000000..6bdcb4f964f61bb97bcf4d92224fa0377f823d29 --- /dev/null +++ b/graphic/vkgl/src/khrgles32/ActsKhrgles32TestSuite.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef KHRGLES32_TESTCASE_H +#define KHRGLES32_TESTCASE_H + +#include +#include "Khrgles32BaseFunc.h" + +namespace OHOS { + class ActsKhrgles32TestSuite : 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 // KHRGLES32_TESTCASE_H \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles32/Khrgles32BaseFunc.cpp b/graphic/vkgl/src/khrgles32/Khrgles32BaseFunc.cpp new file mode 100644 index 0000000000000000000000000000000000000000..3bd33b44e01fcda89e0c3966d34f595e68defa38 --- /dev/null +++ b/graphic/vkgl/src/khrgles32/Khrgles32BaseFunc.cpp @@ -0,0 +1,75 @@ +/* + * 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 "Khrgles32BaseFunc.h" + +static tcu::TestPackage* createKhrgles32Package(tcu::TestContext& testCtx) +{ + return new es32cts::ES32TestPackage(testCtx, "KHR-KHRGLES32"); +} +void RegistPackage(void) +{ + tcu::TestPackageRegistry *registry = tcu::TestPackageRegistry::getSingleton(); + registry->registerPackage("KHR-GLES32", createKhrgles32Package); +} + +FuncRunResult RunTestKHRGLES(int argc, const char** argv) +{ + FuncRunResult runResult; + try { + tcu::CommandLine cmdLine(argc, argv); + tcu::DirArchive archive(cmdLine.getArchiveDir()); + + de::UniquePtr platform(createOhosPlatform()); + de::UniquePtr app(new tcu::ActsApp(*platform, archive, tcutestlog, cmdLine)); + for (;;) { + if (!app->iterate()) { + break; + }; + }; + runResult.isComplete = app->getResult().isComplete; + runResult.numPassed = app->getResult().numPassed; + runResult.numExecuted = app->getResult().numExecuted; + runResult.numFailed = app->getResult().numFailed; + runResult.numNotSupported = app->getResult().numNotSupported; + runResult.numWarnings = app->getResult().numWarnings; + runResult.numWaived = app->getResult().numWaived; + } catch (const std::exception &e) { + tcu::die("%s", e.what()); + }; + return runResult; +} \ No newline at end of file diff --git a/graphic/vkgl/src/khrgles32/Khrgles32BaseFunc.h b/graphic/vkgl/src/khrgles32/Khrgles32BaseFunc.h new file mode 100644 index 0000000000000000000000000000000000000000..839d1dcaa2592423094d7b28d1742e952d5a75dc --- /dev/null +++ b/graphic/vkgl/src/khrgles32/Khrgles32BaseFunc.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef KHRGLES32_FUNC_H +#define KHRGLES32_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 // KHRGLES32_FUNC_H \ No newline at end of file