Skip to content

X
Xts Acts

OpenHarmony / Xts Acts
大约 1 年 前同步成功

通知 9
Star 22
Fork 0
X
Xts Acts

体验新版 GitCode，发现更多精彩内容 >>

提交 e97d1a44 编写于 作者: F FondMemoryVVV
浏览文件
操作

修改toolchain目录tar_files.py文件 

Signed-off-by: NFondMemoryVVV <mashuai53@huawei.com>
上级 d5c96ba3
隐藏空白更改
内联 并排
Showing with 7 addition and 926 deletion
.history/toolchain/libc-test/src/toolchaintest_20220722151310.cpp 已删除 100644 → 0
浏览文件 @ d5c96ba3
/*
* Copyright (C) 2022 Huawei Device 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 <iostream>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <ctime>
#include <cstdio>
#include <vector>
#include <csignal>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "gtest/gtest.h"
#include "runtest.h"
using namespace std;
using namespace testing::ext;
class ToolChainTest : public testing::Test {};
volatile int t_status = 0;
static void handler(int s)
{
}
static int start(char *wrap, const char *argvs)
{
int pid, space_size = 100*1024;
pid = fork();
if (pid == 0) {
t_setrlim(RLIMIT_STACK, space_size);
int exe = execl(argvs, "strptime", nullptr);
printf("exe:%d %s exec failed: %s\n", exe, argvs, strerror(errno));
exit(1);
}
return pid;
}
static int runtests(const char *argvs)
{
char wrap[] = "";
int timeoutsec = 5, timeout = 0;
int status, pid;
sigset_t set;
void (*retfunc)(int);
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, nullptr);
retfunc = signal(SIGCHLD, handler);
if (retfunc == SIG_ERR) {
printf("signal triggering failed:%s\n", strerror(errno));
}
pid = start(wrap, argvs);
if (pid == -1) {
printf("%s fork failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
struct timespec tp;
tp.tv_sec = timeoutsec;
tp.tv_nsec = 0;
if (sigtimedwait(&set, nullptr, &tp) == -1) {
if (errno == EAGAIN) {
timeout = 1;
} else {
printf("%s sigtimedwait failed: %s\n", argvs, strerror(errno));
}
if (kill(pid, SIGKILL) == -1) {
printf("%s kill failed: %s\n", argvs, strerror(errno));
}
}
if (waitpid(pid, &status, 0) != pid) {
printf("%s waitpid failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) == 0) {
return t_status;
}
printf("FAIL %s [status %d]\n", argvs, WEXITSTATUS(status));
} else if (timeout) {
printf("FAIL %s [timed out]\n", argvs);
} else if (WIFSIGNALED(status)) {
printf("FAIL %s [signal %s]\n", argvs, strsignal(WTERMSIG(status)));
} else {
printf("FAIL %s [unknown]\n", argvs);
}
return 1;
}
/**
* @tc.name : ToolChainTest.LibcTest
* @tc.desc : start test
* @tc.level : Level 2
*/
HWTEST_F(ToolChainTest, LibcTest, Function | MediumTest | Level3)
{
int ret;
vector<string> temp;
string filepath = "/data/local/tmp/libc-test/src";
GetFileNames(filepath, temp);
for (size_t i = 0; i < temp.size(); i++) {
if ((temp[i].find("stat", filepath.length()-1) != -1) ||
(temp[i].find("sem_close-unmap", filepath.length()-1) != -1) ||
(temp[i].find("runtest", filepath.length()-1) != -1)) {
continue;
}
ret = runtests(temp[i].c_str());
EXPECT_EQ(0, ret) << "test " << temp[i] << " failed" << endl;
}
}
.history/toolchain/libc-test/src/toolchaintest_20220725110950.cpp 已删除 100644 → 0
浏览文件 @ d5c96ba3
/*
* Copyright (C) 2022 Huawei Device 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 <iostream>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <ctime>
#include <cstdio>
#include <vector>
#include <csignal>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "gtest/gtest.h"
#include "runtest.h"
using namespace std;
using namespace testing::ext;
class toolchaintest : public testing::Test {};
volatile int t_status = 0;
static void handler(int s)
{
}
static int start(char *wrap, const char *argvs)
{
int pid, space_size = 100*1024;
pid = fork();
if (pid == 0) {
t_setrlim(RLIMIT_STACK, space_size);
int exe = execl(argvs, "strptime", nullptr);
printf("exe:%d %s exec failed: %s\n", exe, argvs, strerror(errno));
exit(1);
}
return pid;
}
static int runtests(const char *argvs)
{
char wrap[] = "";
int timeoutsec = 5, timeout = 0;
int status, pid;
sigset_t set;
void (*retfunc)(int);
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, nullptr);
retfunc = signal(SIGCHLD, handler);
if (retfunc == SIG_ERR) {
printf("signal triggering failed:%s\n", strerror(errno));
}
pid = start(wrap, argvs);
if (pid == -1) {
printf("%s fork failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
struct timespec tp;
tp.tv_sec = timeoutsec;
tp.tv_nsec = 0;
if (sigtimedwait(&set, nullptr, &tp) == -1) {
if (errno == EAGAIN) {
timeout = 1;
} else {
printf("%s sigtimedwait failed: %s\n", argvs, strerror(errno));
}
if (kill(pid, SIGKILL) == -1) {
printf("%s kill failed: %s\n", argvs, strerror(errno));
}
}
if (waitpid(pid, &status, 0) != pid) {
printf("%s waitpid failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) == 0) {
return t_status;
}
printf("FAIL %s [status %d]\n", argvs, WEXITSTATUS(status));
} else if (timeout) {
printf("FAIL %s [timed out]\n", argvs);
} else if (WIFSIGNALED(status)) {
printf("FAIL %s [signal %s]\n", argvs, strsignal(WTERMSIG(status)));
} else {
printf("FAIL %s [unknown]\n", argvs);
}
return 1;
}
/**
* @tc.name : toolchaintest.LibcTest
* @tc.desc : start test
* @tc.level : Level 2
*/
HWTEST_F(toolchaintest, LibcTest, Function | MediumTest | Level3)
{
int ret;
vector<string> temp;
string filepath = "/data/local/tmp/libc-test/src";
GetFileNames(filepath, temp);
for (size_t i = 0; i < temp.size(); i++) {
if ((temp[i].find("stat", filepath.length()-1) != -1) ||
(temp[i].find("sem_close-unmap", filepath.length()-1) != -1) ||
(temp[i].find("runtest", filepath.length()-1) != -1)) {
continue;
}
ret = runtests(temp[i].c_str());
EXPECT_EQ(0, ret) << "test " << temp[i] << " failed" << endl;
}
}
.history/toolchain/libc-test/src/toolchaintest_20220725111203.cpp 已删除 100644 → 0
浏览文件 @ d5c96ba3
/*
* Copyright (C) 2022 Huawei Device 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 <iostream>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <ctime>
#include <cstdio>
#include <vector>
#include <csignal>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "gtest/gtest.h"
#include "runtest.h"
using namespace std;
using namespace testing::ext;
class toolchaintest : public testing::Test {};
volatile int t_status = 0;
static void handler(int s)
{
}
static int start(char *wrap, const char *argvs)
{
int pid, space_size = 100*1024;
pid = fork();
if (pid == 0) {
t_setrlim(RLIMIT_STACK, space_size);
int exe = execl(argvs, "strptime", nullptr);
printf("exe:%d %s exec failed: %s\n", exe, argvs, strerror(errno));
exit(1);
}
return pid;
}
static int runtests(const char *argvs)
{
char wrap[] = "";
int timeoutsec = 5, timeout = 0;
int status, pid;
sigset_t set;
void (*retfunc)(int);
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, nullptr);
retfunc = signal(SIGCHLD, handler);
if (retfunc == SIG_ERR) {
printf("signal triggering failed:%s\n", strerror(errno));
}
pid = start(wrap, argvs);
if (pid == -1) {
printf("%s fork failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
struct timespec tp;
tp.tv_sec = timeoutsec;
tp.tv_nsec = 0;
if (sigtimedwait(&set, nullptr, &tp) == -1) {
if (errno == EAGAIN) {
timeout = 1;
} else {
printf("%s sigtimedwait failed: %s\n", argvs, strerror(errno));
}
if (kill(pid, SIGKILL) == -1) {
printf("%s kill failed: %s\n", argvs, strerror(errno));
}
}
if (waitpid(pid, &status, 0) != pid) {
printf("%s waitpid failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) == 0) {
return t_status;
}
printf("FAIL %s [status %d]\n", argvs, WEXITSTATUS(status));
} else if (timeout) {
printf("FAIL %s [timed out]\n", argvs);
} else if (WIFSIGNALED(status)) {
printf("FAIL %s [signal %s]\n", argvs, strsignal(WTERMSIG(status)));
} else {
printf("FAIL %s [unknown]\n", argvs);
}
return 1;
}
/**
* @tc.name : toolchaintest.LibcTest
* @tc.desc : start test
* @tc.level : Level 2
*/
static HWTEST_F(toolchaintest, LibcTest, Function | MediumTest | Level3)
{
int ret;
vector<string> temp;
string filepath = "/data/local/tmp/libc-test/src";
GetFileNames(filepath, temp);
for (size_t i = 0; i < temp.size(); i++) {
if ((temp[i].find("stat", filepath.length()-1) != -1) ||
(temp[i].find("sem_close-unmap", filepath.length()-1) != -1) ||
(temp[i].find("runtest", filepath.length()-1) != -1)) {
continue;
}
ret = runtests(temp[i].c_str());
EXPECT_EQ(0, ret) << "test " << temp[i] << " failed" << endl;
}
}
.history/toolchain/libc-test/src/toolchaintest_20220725111643.cpp 已删除 100644 → 0
浏览文件 @ d5c96ba3
/*
* Copyright (C) 2022 Huawei Device 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 <iostream>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <ctime>
#include <cstdio>
#include <vector>
#include <csignal>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "gtest/gtest.h"
#include "runtest.h"
using namespace std;
using namespace testing::ext;
class toolchaintest : public testing::Test {};
volatile int t_status = 0;
static void handler(int s)
{
}
static int start(char *wrap, const char *argvs)
{
int pid, space_size = 100*1024;
pid = fork();
if (pid == 0) {
t_setrlim(RLIMIT_STACK, space_size);
int exe = execl(argvs, "strptime", nullptr);
printf("exe:%d %s exec failed: %s\n", exe, argvs, strerror(errno));
exit(1);
}
return pid;
}
static int runtests(const char *argvs)
{
char wrap[] = "";
int timeoutsec = 5, timeout = 0;
int status, pid;
sigset_t set;
void (*retfunc)(int);
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, nullptr);
retfunc = signal(SIGCHLD, handler);
if (retfunc == (int)SIG_ERR) {
printf("signal triggering failed:%s\n", strerror(errno));
}
pid = start(wrap, argvs);
if (pid == -1) {
printf("%s fork failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
struct timespec tp;
tp.tv_sec = timeoutsec;
tp.tv_nsec = 0;
if (sigtimedwait(&set, nullptr, &tp) == -1) {
if (errno == EAGAIN) {
timeout = 1;
} else {
printf("%s sigtimedwait failed: %s\n", argvs, strerror(errno));
}
if (kill(pid, SIGKILL) == -1) {
printf("%s kill failed: %s\n", argvs, strerror(errno));
}
}
if (waitpid(pid, &status, 0) != pid) {
printf("%s waitpid failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) == 0) {
return t_status;
}
printf("FAIL %s [status %d]\n", argvs, WEXITSTATUS(status));
} else if (timeout) {
printf("FAIL %s [timed out]\n", argvs);
} else if (WIFSIGNALED(status)) {
printf("FAIL %s [signal %s]\n", argvs, strsignal(WTERMSIG(status)));
} else {
printf("FAIL %s [unknown]\n", argvs);
}
return 1;
}
/**
* @tc.name : toolchaintest.LibcTest
* @tc.desc : start test
* @tc.level : Level 2
*/
static HWTEST_F(toolchaintest, LibcTest, Function | MediumTest | Level3)
{
int ret;
vector<string> temp;
string filepath = "/data/local/tmp/libc-test/src";
GetFileNames(filepath, temp);
for (size_t i = 0; i < temp.size(); i++) {
if ((temp[i].find("stat", filepath.length()-1) != -1) ||
(temp[i].find("sem_close-unmap", filepath.length()-1) != -1) ||
(temp[i].find("runtest", filepath.length()-1) != -1)) {
continue;
}
ret = runtests(temp[i].c_str());
EXPECT_EQ(0, ret) << "test " << temp[i] << " failed" << endl;
}
}
.history/toolchain/libc-test/src/toolchaintest_20220725112418.cpp 已删除 100644 → 0
浏览文件 @ d5c96ba3
/*
* Copyright (C) 2022 Huawei Device 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 <iostream>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <ctime>
#include <cstdio>
#include <vector>
#include <csignal>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "gtest/gtest.h"
#include "runtest.h"
using namespace std;
using namespace testing::ext;
class toolchaintest : public testing::Test {};
volatile int t_status = 0;
static void handler(int s)
{
}
static int start(char *wrap, const char *argvs)
{
int pid, space_size = 100*1024;
pid = fork();
if (pid == 0) {
t_setrlim(RLIMIT_STACK, space_size);
int exe = execl(argvs, "strptime", nullptr);
printf("exe:%d %s exec failed: %s\n", exe, argvs, strerror(errno));
exit(1);
}
return pid;
}
static int runtests(const char *argvs)
{
char wrap[] = "";
int timeoutsec = 5, timeout = 0;
int status, pid;
sigset_t set;
void (*retfunc)(int);
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, nullptr);
retfunc = signal(SIGCHLD, handler);
if (retfunc == int(SIG_ERR)) {
printf("signal triggering failed:%s\n", strerror(errno));
}
pid = start(wrap, argvs);
if (pid == -1) {
printf("%s fork failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
struct timespec tp;
tp.tv_sec = timeoutsec;
tp.tv_nsec = 0;
if (sigtimedwait(&set, nullptr, &tp) == -1) {
if (errno == EAGAIN) {
timeout = 1;
} else {
printf("%s sigtimedwait failed: %s\n", argvs, strerror(errno));
}
if (kill(pid, SIGKILL) == -1) {
printf("%s kill failed: %s\n", argvs, strerror(errno));
}
}
if (waitpid(pid, &status, 0) != pid) {
printf("%s waitpid failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) == 0) {
return t_status;
}
printf("FAIL %s [status %d]\n", argvs, WEXITSTATUS(status));
} else if (timeout) {
printf("FAIL %s [timed out]\n", argvs);
} else if (WIFSIGNALED(status)) {
printf("FAIL %s [signal %s]\n", argvs, strsignal(WTERMSIG(status)));
} else {
printf("FAIL %s [unknown]\n", argvs);
}
return 1;
}
/**
* @tc.name : toolchaintest.LibcTest
* @tc.desc : start test
* @tc.level : Level 2
*/
static HWTEST_F(toolchaintest, LibcTest, Function | MediumTest | Level3)
{
int ret;
vector<string> temp;
string filepath = "/data/local/tmp/libc-test/src";
GetFileNames(filepath, temp);
for (size_t i = 0; i < temp.size(); i++) {
if ((temp[i].find("stat", filepath.length()-1) != -1) ||
(temp[i].find("sem_close-unmap", filepath.length()-1) != -1) ||
(temp[i].find("runtest", filepath.length()-1) != -1)) {
continue;
}
ret = runtests(temp[i].c_str());
EXPECT_EQ(0, ret) << "test " << temp[i] << " failed" << endl;
}
}
.history/toolchain/libc-test/src/toolchaintest_20220725112546.cpp 已删除 100644 → 0
浏览文件 @ d5c96ba3
/*
* Copyright (C) 2022 Huawei Device 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 <iostream>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <ctime>
#include <cstdio>
#include <vector>
#include <csignal>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "gtest/gtest.h"
#include "runtest.h"
using namespace std;
using namespace testing::ext;
class toolchaintest : public testing::Test {};
volatile int t_status = 0;
static void handler(int s)
{
}
static int start(char *wrap, const char *argvs)
{
int pid, space_size = 100*1024;
pid = fork();
if (pid == 0) {
t_setrlim(RLIMIT_STACK, space_size);
int exe = execl(argvs, "strptime", nullptr);
printf("exe:%d %s exec failed: %s\n", exe, argvs, strerror(errno));
exit(1);
}
return pid;
}
static int runtests(const char *argvs)
{
char wrap[] = "";
int timeoutsec = 5, timeout = 0;
int status, pid;
sigset_t set;
void (*retfunc)(int);
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, nullptr);
retfunc = signal(SIGCHLD, handler);
if (retfunc == int(SIG_ERR)) {
printf("signal triggering failed:%s\n", strerror(errno));
}
pid = start(wrap, argvs);
if (pid == -1) {
printf("%s fork failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
struct timespec tp;
tp.tv_sec = timeoutsec;
tp.tv_nsec = 0;
if (sigtimedwait(&set, nullptr, &tp) == -1) {
if (errno == EAGAIN) {
timeout = 1;
} else {
printf("%s sigtimedwait failed: %s\n", argvs, strerror(errno));
}
if (kill(pid, SIGKILL) == -1) {
printf("%s kill failed: %s\n", argvs, strerror(errno));
}
}
if (waitpid(pid, &status, 0) != pid) {
printf("%s waitpid failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) == 0) {
return t_status;
}
printf("FAIL %s [status %d]\n", argvs, WEXITSTATUS(status));
} else if (timeout) {
printf("FAIL %s [timed out]\n", argvs);
} else if (WIFSIGNALED(status)) {
printf("FAIL %s [signal %s]\n", argvs, strsignal(WTERMSIG(status)));
} else {
printf("FAIL %s [unknown]\n", argvs);
}
return 1;
}
/**
* @tc.name : toolchaintest.LibcTest
* @tc.desc : start test
* @tc.level : Level 2
*/
static HWTEST_F(toolchaintest, LibcTest, Function | MediumTest | Level3)
{
int ret;
vector<string> temp;
string filepath = "/data/local/tmp/libc-test/src";
GetFileNames(filepath, temp);
for (size_t i = 0; i < temp.size(); i++) {
if ((temp[i].find("stat", filepath.length()-1) != -1) ||
(temp[i].find("sem_close-unmap", filepath.length()-1) != -1) ||
(temp[i].find("runtest", filepath.length()-1) != -1)) {
continue;
}
ret = runtests(temp[i].c_str());
EXPECT_EQ(0, ret) << "test " << temp[i] << " failed" << endl;
}
}
.history/toolchain/libc-test/src/toolchaintest_20220725112551.cpp 已删除 100644 → 0
浏览文件 @ d5c96ba3
/*
* Copyright (C) 2022 Huawei Device 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 <iostream>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include <ctime>
#include <cstdio>
#include <vector>
#include <csignal>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "gtest/gtest.h"
#include "runtest.h"
using namespace std;
using namespace testing::ext;
class toolchaintest : public testing::Test {};
volatile int t_status = 0;
static void handler(int s)
{
}
static int start(char *wrap, const char *argvs)
{
int pid, space_size = 100*1024;
pid = fork();
if (pid == 0) {
t_setrlim(RLIMIT_STACK, space_size);
int exe = execl(argvs, "strptime", nullptr);
printf("exe:%d %s exec failed: %s\n", exe, argvs, strerror(errno));
exit(1);
}
return pid;
}
static int runtests(const char *argvs)
{
char wrap[] = "";
int timeoutsec = 5, timeout = 0;
int status, pid;
sigset_t set;
void (*retfunc)(int);
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, nullptr);
retfunc = signal(SIGCHLD, handler);
if (retfunc == int(SIG_ERR)) {
printf("signal triggering failed:%s\n", strerror(errno));
}
pid = start(wrap, argvs);
if (pid == -1) {
printf("%s fork failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
struct timespec tp;
tp.tv_sec = timeoutsec;
tp.tv_nsec = 0;
if (sigtimedwait(&set, nullptr, &tp) == -1) {
if (errno == EAGAIN) {
timeout = 1;
} else {
printf("%s sigtimedwait failed: %s\n", argvs, strerror(errno));
}
if (kill(pid, SIGKILL) == -1) {
printf("%s kill failed: %s\n", argvs, strerror(errno));
}
}
if (waitpid(pid, &status, 0) != pid) {
printf("%s waitpid failed: %s\n", argvs, strerror(errno));
printf("FAIL %s [internal]\n", argvs);
return -1;
}
if (WIFEXITED(status)) {
if (WEXITSTATUS(status) == 0) {
return t_status;
}
printf("FAIL %s [status %d]\n", argvs, WEXITSTATUS(status));
} else if (timeout) {
printf("FAIL %s [timed out]\n", argvs);
} else if (WIFSIGNALED(status)) {
printf("FAIL %s [signal %s]\n", argvs, strsignal(WTERMSIG(status)));
} else {
printf("FAIL %s [unknown]\n", argvs);
}
return 1;
}
/**
* @tc.name : toolchaintest.LibcTest
* @tc.desc : start test
* @tc.level : Level 2
*/
static HWTEST_F(toolchaintest, LibcTest, Function | MediumTest | Level3)
{
int ret;
vector<string> temp;
string filepath = "/data/local/tmp/libc-test/src";
GetFileNames(filepath, temp);
for (size_t i = 0; i < temp.size(); i++) {
if ((temp[i].find("stat", filepath.length()-1) != -1) ||
(temp[i].find("sem_close-unmap", filepath.length()-1) != -1) ||
(temp[i].find("runtest", filepath.length()-1) != -1)) {
continue;
}
ret = runtests(temp[i].c_str());
EXPECT_EQ(0, ret) << "test " << temp[i] << " failed" << endl;
}
}
commonlibrary/ets_utils/toolchain/libc-test/tar_files.py → toolchain/libc-test/tar_files.py
浏览文件 @ e97d1a44
......@@ -24,19 +24,17 @@ import shutil
copyFileCounts = 0
def copyFiles(sourceDir, targetDir):
global copyFileCounts
def copy_files(sourceDir, targetDir):
for f in os.listdir(sourceDir):
sourceF = os.path.join(sourceDir, f)
targetF = os.path.join(targetDir, f)
if os.path.isfile(sourceF):
source_files = os.path.join(sourceDir, f)
target_files = os.path.join(targetDir, f)
if os.path.isfile(source_files):
if not os.path.exists(targetDir):
os.makedirs(targetDir)
copyFileCounts += 1
if not os.path.exists(targetF) or (os.path.exists(targetF) and (os.path.getsize(targetF) != os.path.getsize(sourceF))):
open(targetF, "wb").write(open(sourceF, "rb").read())
if os.path.isdir(sourceF):
copyFiles(sourceF, targetF)
open(target_files, "wb").write(open(source_files, "rb").read())
if os.path.isdir(source_files):
copy_files(source_files, target_files)
def make_targz_one_by_one(output_filename, source_dir):
tar = tarfile.open(output_filename,"w")
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或