wehub-resource-sync
321 lines
10 KiB
C++
321 lines
10 KiB
C++
//
|
|
// FileUtilsTest.cpp
|
|
// MNNTests
|
|
//
|
|
// Created by MNN on 2024/07/26.
|
|
// Copyright © 2018, Alibaba Group Holding Limited
|
|
//
|
|
|
|
#include "MNNTestSuite.h"
|
|
#include "core/MNNFileUtils.h"
|
|
|
|
#if defined(WIN32) || defined(_WIN32) || defined(_WIN64) || defined(_MSC_VER)
|
|
const char * file_path = "C:\\Windows\\Temp\\file_utils_test_temp_file";
|
|
#elif defined(__ANDROID__)
|
|
const char * file_path = "/data/local/tmp/file_utils_test_temp_file";
|
|
#elif defined(__APPLE__) || defined(__linux__) || defined(__unix__)
|
|
const char * file_path = "/tmp/file_utils_test_temp_file";
|
|
#else
|
|
const char * file_path = "./file_utils_test_temp_file";
|
|
#endif
|
|
|
|
class FileUtilsTest : public MNNTestCase {
|
|
public:
|
|
virtual ~FileUtilsTest() = default;
|
|
virtual bool run(int precision) {
|
|
/*======== Create and Remove ========*/
|
|
do {
|
|
// create a new file
|
|
file_t file = MNNCreateFile(file_path);
|
|
if (file == INVALID_FILE) {
|
|
return false;
|
|
} else {
|
|
MNNCloseFile(file);
|
|
}
|
|
bool exist = MNNFileExist(file_path);
|
|
if (!exist) {
|
|
return false;
|
|
}
|
|
// create a new file to cover an existing file
|
|
file = MNNCreateFile(file_path);
|
|
if (file == INVALID_FILE) {
|
|
return false;
|
|
} else {
|
|
MNNCloseFile(file);
|
|
}
|
|
exist = MNNFileExist(file_path);
|
|
if (!exist) {
|
|
return false;
|
|
}
|
|
// remove a file
|
|
MNN::ErrorCode ec = MNNRemoveFile(file_path);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
exist = MNNFileExist(file_path);
|
|
if (exist) {
|
|
return false;
|
|
}
|
|
printf("File Utils Test: Create and Remove passed\n");
|
|
} while(false);
|
|
|
|
/*======== Open and Close ========*/
|
|
do {
|
|
// Open and close a non-existent file
|
|
file_t file = MNNOpenFile(file_path, MNN_FILE_READ | MNN_FILE_WRITE);
|
|
if (file != INVALID_FILE) {
|
|
return false;
|
|
}
|
|
MNN::ErrorCode ec = MNNCloseFile(file);
|
|
if (ec != FILE_NOT_EXIST) {
|
|
return false;
|
|
}
|
|
// Open and close an existent file
|
|
file = MNNCreateFile(file_path);
|
|
if (file == INVALID_FILE) {
|
|
return false;
|
|
}
|
|
bool exist = MNNFileExist(file_path);
|
|
if (!exist) {
|
|
return false;
|
|
}
|
|
ec = MNNCloseFile(file);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
file = MNNOpenFile(file_path, MNN_FILE_READ | MNN_FILE_WRITE);
|
|
if (file == INVALID_FILE) {
|
|
return false;
|
|
}
|
|
ec = MNNCloseFile(file);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
ec = MNNRemoveFile(file_path);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
exist = MNNFileExist(file_path);
|
|
if (exist) {
|
|
return false;
|
|
}
|
|
printf("File Utils Test: Open and Close passed\n");
|
|
} while(false);
|
|
|
|
/*======== Get and Set File Size ========*/
|
|
do {
|
|
file_t file = MNNOpenFile(file_path, MNN_FILE_READ | MNN_FILE_WRITE);
|
|
if (file != INVALID_FILE) {
|
|
return false;
|
|
}
|
|
size_t size = MNNGetFileSize(file);
|
|
if (size != INVALID_SIZE) {
|
|
printf("File size mismatch: expected %lu but got %lu\n", INVALID_SIZE, size);
|
|
return false;
|
|
}
|
|
file = MNNCreateFile(file_path);
|
|
if (file == INVALID_FILE) {
|
|
return false;
|
|
}
|
|
size = MNNGetFileSize(file);
|
|
if (size != 0) {
|
|
printf("File size mismatch: expected 0 but got %lu\n", size);
|
|
return false;
|
|
}
|
|
size_t expectedSize = 1023;
|
|
MNN::ErrorCode ec = MNNSetFileSize(file, expectedSize);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
size = MNNGetFileSize(file);
|
|
if (size != expectedSize) {
|
|
printf("File size mismatch: expected %lu but got %lu\n", expectedSize, size);
|
|
return false;
|
|
}
|
|
expectedSize = 64 * 1024 * 1024;
|
|
ec = MNNSetFileSize(file, expectedSize);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
size = MNNGetFileSize(file);
|
|
if (size != expectedSize) {
|
|
printf("File size mismatch: expected %lu but got %lu\n", expectedSize, size);
|
|
return false;
|
|
}
|
|
ec = MNNCloseFile(file);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
ec = MNNRemoveFile(file_path);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
bool exist = MNNFileExist(file_path);
|
|
if (exist) {
|
|
return false;
|
|
}
|
|
printf("File Utils Test: Get and Set File Size passed\n");
|
|
} while(false);
|
|
|
|
/*======== Read and Write ========*/
|
|
do {
|
|
char alpha[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
size_t size = 32;
|
|
char * buf = (char *)malloc(size);
|
|
if (buf == nullptr) {
|
|
printf("MNN_FAILED to allocate memory in File Utils Test!\n");
|
|
return false;
|
|
}
|
|
file_t file = MNNOpenFile(file_path, MNN_FILE_READ | MNN_FILE_WRITE);
|
|
if (file != INVALID_FILE) {
|
|
return false;
|
|
}
|
|
size_t ret = MNNReadFile(file, nullptr, 0);
|
|
if (ret != 0) {
|
|
return false;
|
|
}
|
|
ret = MNNWriteFile(file, nullptr, 0);
|
|
if (ret != 0) {
|
|
return false;
|
|
}
|
|
file = MNNCreateFile(file_path);
|
|
if (file == INVALID_FILE) {
|
|
return false;
|
|
}
|
|
ret = MNNReadFile(file, buf, 10);
|
|
if (ret != 0) {
|
|
return false;
|
|
}
|
|
ret = MNNWriteFile(file, alpha, 26);
|
|
if (ret != 26) {
|
|
return false;
|
|
}
|
|
MNN::ErrorCode ec = MNNSetFilePointer(file, 0);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
ret = MNNReadFile(file, buf, 20);
|
|
if (ret != 20) {
|
|
return false;
|
|
}
|
|
ret = MNNReadFile(file, buf, 10);
|
|
if (ret != 6) {
|
|
return false;
|
|
}
|
|
ec = MNNSetFilePointer(file, 0);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
ret = MNNReadFile(file, buf, 3);
|
|
if (ret != 3) {
|
|
return false;
|
|
}
|
|
if (buf[0] != 'A' || buf[1] != 'B' || buf[2] != 'C') {
|
|
return false;
|
|
}
|
|
ec = MNNSetFilePointer(file, 20);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
ret = MNNReadFile(file, buf, 3);
|
|
if (ret != 3) {
|
|
return false;
|
|
}
|
|
if (buf[0] != 'U' || buf[1] != 'V' || buf[2] != 'W') {
|
|
return false;
|
|
}
|
|
ec = MNNSetFilePointer(file, 10);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
char hello[6] = "hello";
|
|
ret = MNNWriteFile(file, (void *)hello, 6);
|
|
if (ret != 6) {
|
|
return false;
|
|
}
|
|
ec = MNNSetFilePointer(file, 10);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
ret = MNNReadFile(file, buf, 6);
|
|
if (0 != strcmp(buf, "hello")) {
|
|
return false;
|
|
}
|
|
ec = MNNCloseFile(file);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
ec = MNNRemoveFile(file_path);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
bool exist = MNNFileExist(file_path);
|
|
if (exist) {
|
|
return false;
|
|
}
|
|
free(buf);
|
|
printf("File Utils Test: Read and Write passed\n");
|
|
} while(false);
|
|
|
|
/*======== Map and Unmap ========*/
|
|
do {
|
|
char * addr = (char *)MNNMmapFile(INVALID_FILE, INVALID_SIZE);
|
|
if (addr != nullptr) {
|
|
return false;
|
|
}
|
|
MNN::ErrorCode ec = MNNUnmapFile(addr, 0);
|
|
if (ec != FILE_UNMAP_FAILED) {
|
|
return false;
|
|
}
|
|
file_t file = MNNCreateFile(file_path);
|
|
if (file == INVALID_FILE) {
|
|
return false;
|
|
}
|
|
addr = (char *)MNNMmapFile(file, 1024);
|
|
if (addr != nullptr) {
|
|
return false;
|
|
}
|
|
ec = MNNSetFileSize(file, 1024);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
addr = (char *)MNNMmapFile(file, 1024);
|
|
if (addr == nullptr) {
|
|
return false;
|
|
}
|
|
strcpy(addr, "hello");
|
|
ec = MNNUnmapFile(addr, 1024);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
addr = (char *)MNNMmapFile(file, 1024);
|
|
if (addr == nullptr) {
|
|
return false;
|
|
}
|
|
if(0 != strcmp(addr, "hello")) {
|
|
return false;
|
|
}
|
|
ec = MNNUnmapFile(addr, 1024);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
ec = MNNCloseFile(file);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
ec = MNNRemoveFile(file_path);
|
|
if (ec != NO_ERROR) {
|
|
return false;
|
|
}
|
|
bool exist = MNNFileExist(file_path);
|
|
if (exist) {
|
|
return false;
|
|
}
|
|
printf("File Utils Test: Map and Unmap passed\n");
|
|
} while(false);
|
|
|
|
return true;
|
|
}
|
|
};
|
|
MNNTestSuiteRegister(FileUtilsTest, "core/file_utils");
|