intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-06 02:18:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Moving hash and file_io to core

Browse Source 
Change-Id: I1e6eece53fadf62a8919aa41e04deee3dac2ce60
This commit is contained in:
Jaroslaw Chodor
2019-10-16 22:21:04 +02:00
committed by sys_ocldev
parent 239fe2a0fe
commit 90e5cf164c
59 changed files with 80 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
unit_tests/helpers/CMakeLists.txt
View File

@@ -21,14 +21,12 @@ set(IGDRCL_SRCS_tests_helpers
${CMAKE_CURRENT_SOURCE_DIR}/dispatch_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/dispatch_info_builder_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/extendable_enum_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/file_io_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/flush_stamp_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/get_gpgpu_engines_tests.inl
${CMAKE_CURRENT_SOURCE_DIR}/get_info_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gtest_helpers.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware_commands_helper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hardware_commands_helper_tests.h
${CMAKE_CURRENT_SOURCE_DIR}/hash_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_default_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_tests.h
@@ -45,8 +43,6 @@ set(IGDRCL_SRCS_tests_helpers
${CMAKE_CURRENT_SOURCE_DIR}/raii_hw_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/queue_helpers_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sampler_helpers_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/string_to_hash_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/string_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/task_information_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_debug_variables.inl
${CMAKE_CURRENT_SOURCE_DIR}/timestamp_packet_tests.cpp

41
unit_tests/helpers/file_io_tests.cpp
View File

@@ -1,41 +0,0 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "runtime/helpers/file_io.h"
#include "gtest/gtest.h"
#include <cstdio>
TEST(FileIO, existsHasSize) {
std::string fileName("fileIO.bin");
std::remove(fileName.c_str());
ASSERT_FALSE(fileExists(fileName.c_str()));
FILE *fp = nullptr;
fopen_s(&fp, fileName.c_str(), "wb");
ASSERT_NE(nullptr, fp);
fprintf(fp, "TEST");
fclose(fp);
EXPECT_TRUE(fileExists(fileName.c_str()));
EXPECT_TRUE(fileExistsHasSize(fileName.c_str()));
}
TEST(FileIO, existsSizeZero) {
std::string fileName("fileIO.bin");
std::remove(fileName.c_str());
ASSERT_FALSE(fileExists(fileName.c_str()));
FILE *fp = nullptr;
fopen_s(&fp, fileName.c_str(), "wb");
ASSERT_NE(nullptr, fp);
fclose(fp);
EXPECT_TRUE(fileExists(fileName.c_str()));
EXPECT_FALSE(fileExistsHasSize(fileName.c_str()));
}

36
unit_tests/helpers/hash_tests.cpp
View File

@@ -1,36 +0,0 @@
/*
* Copyright (C) 2018-2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "runtime/helpers/hash.h"
#include "gtest/gtest.h"
using namespace NEO;
TEST(HashTests, givenSamePointersWhenHashIsCalculatedThenSame32BitValuesAreGenerated) {
uintptr_t ptr1UI = 1;
uintptr_t ptr2UI = 1;
void *ptr1 = reinterpret_cast<void *>(ptr1UI);
void *ptr2 = reinterpret_cast<void *>(ptr2UI);
uint32_t hash1 = hashPtrToU32(ptr1);
uint32_t hash2 = hashPtrToU32(ptr2);
EXPECT_EQ(hash1, hash2);
}
TEST(HashTests, givenDifferentPointersWhenHashIsCalculatedThenUnique32BitValuesAreGenerated) {
uintptr_t ptr1UI = 1;
uintptr_t ptr2UI = ptr1UI | (ptr1UI << ((sizeof(uintptr_t) / 2) * 8));
void *ptr1 = reinterpret_cast<void *>(ptr1UI);
void *ptr2 = reinterpret_cast<void *>(ptr2UI);
uint32_t hash1 = hashPtrToU32(ptr1);
uint32_t hash2 = hashPtrToU32(ptr2);
EXPECT_NE(hash1, hash2);
}

150
unit_tests/helpers/string_tests.cpp
View File

@@ -1,150 +0,0 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "core/helpers/string.h"
#include "runtime/helpers/hash.h"
#include "gtest/gtest.h"
#if defined(__linux__)
TEST(StringHelpers, strncpy) {
char dst[1024] = "";
char src[1024] = "HelloWorld";
//preconditions
ASSERT_EQ(sizeof(dst), sizeof(src));
//String must be smaller than array capacity
ASSERT_LT(strlen(src), sizeof(src));
auto ret = strncpy_s(nullptr, 1024, src, 1024);
EXPECT_EQ(ret, -EINVAL);
ret = strncpy_s(dst, 1024, nullptr, 1024);
EXPECT_EQ(ret, -EINVAL);
ret = strncpy_s(dst, 512, src, 1024);
EXPECT_EQ(ret, -ERANGE);
memset(dst, 0, sizeof(dst));
ret = strncpy_s(dst, 1024, src, strlen(src) / 2);
EXPECT_EQ(ret, 0);
EXPECT_EQ(0, memcmp(dst, src, strlen(src) / 2));
for (size_t i = strlen(src) / 2; i < sizeof(dst); i++)
EXPECT_EQ(0, dst[i]);
memset(dst, 0, sizeof(dst));
ret = strncpy_s(dst, strlen(src) / 2, src, strlen(src) / 2);
EXPECT_EQ(ret, 0);
EXPECT_EQ(0, memcmp(dst, src, strlen(src) / 2));
for (size_t i = strlen(src) / 2; i < sizeof(dst); i++)
EXPECT_EQ(0, dst[i]);
strncpy_s(dst, 1024, src, 1024);
EXPECT_EQ(0, memcmp(dst, src, strlen(src)));
for (size_t i = strlen(src); i < sizeof(dst); i++)
EXPECT_EQ(0, dst[i]);
}
TEST(StringHelpers, memmove) {
char dst[1024] = "";
char src[1024] = "HelloWorld";
ASSERT_EQ(sizeof(dst), sizeof(src));
auto ret = memmove_s(nullptr, sizeof(dst), src, sizeof(src));
EXPECT_EQ(ret, -EINVAL);
ret = memmove_s(dst, sizeof(dst), nullptr, sizeof(src));
EXPECT_EQ(ret, -EINVAL);
ret = memmove_s(dst, sizeof(src) / 2, src, sizeof(src));
EXPECT_EQ(ret, -ERANGE);
memset(dst, 0, sizeof(dst));
ret = memmove_s(dst, sizeof(dst), src, sizeof(src));
EXPECT_EQ(ret, 0);
EXPECT_EQ(0, memcmp(dst, src, sizeof(dst)));
}
TEST(StringHelpers, strcpy) {
char dst[1024] = "";
char src[1024] = "HelloWorld";
ASSERT_EQ(sizeof(dst), sizeof(src));
auto ret = strcpy_s(nullptr, 0, src);
EXPECT_EQ(ret, -EINVAL);
ret = strcpy_s(nullptr, sizeof(dst), src);
EXPECT_EQ(ret, -EINVAL);
ret = strcpy_s(nullptr, 0, nullptr);
EXPECT_EQ(ret, -EINVAL);
ret = strcpy_s(nullptr, sizeof(dst), nullptr);
EXPECT_EQ(ret, -EINVAL);
ret = strcpy_s(dst, 0, nullptr);
EXPECT_EQ(ret, -EINVAL);
ret = strcpy_s(dst, strlen(src) / 2, src);
EXPECT_EQ(ret, -ERANGE);
ret = strcpy_s(dst, strlen(src), src);
EXPECT_EQ(ret, -ERANGE);
char pattern = 0x5a;
memset(dst, pattern, sizeof(dst));
ret = strcpy_s(dst, sizeof(dst), src);
EXPECT_EQ(ret, 0);
EXPECT_EQ(0, memcmp(dst, src, strlen(src)));
EXPECT_EQ(0, dst[strlen(src)]);
for (size_t i = strlen(src) + 1; i < sizeof(dst); i++)
EXPECT_EQ(pattern, dst[i]);
}
TEST(StringHelpers, strnlen) {
char src[1024] = "HelloWorld";
auto ret = strnlen_s(nullptr, sizeof(src));
EXPECT_EQ(ret, 0u);
ret = strnlen_s(src, 0);
EXPECT_EQ(ret, 0u);
ret = strnlen_s(src, sizeof(src));
EXPECT_EQ(ret, strlen(src));
}
TEST(StringHelpers, memcpy) {
char dst[1024] = "";
char src[1024] = "HelloWorld";
//preconditions
ASSERT_EQ(sizeof(dst), sizeof(src));
//String must be smaller than array capacity
ASSERT_LT(strlen(src), sizeof(src));
auto ret = memcpy_s(nullptr, sizeof(dst), src, sizeof(src));
EXPECT_EQ(ret, -EINVAL);
ret = memcpy_s(dst, sizeof(dst), nullptr, sizeof(src));
EXPECT_EQ(ret, -EINVAL);
ret = memcpy_s(dst, sizeof(dst) / 2, src, sizeof(src));
EXPECT_EQ(ret, -ERANGE);
memset(dst, 0, sizeof(dst));
ret = memcpy_s(dst, sizeof(dst), src, strlen(src) / 2);
EXPECT_EQ(ret, 0);
EXPECT_EQ(0, memcmp(dst, src, strlen(src) / 2));
for (size_t i = strlen(src) / 2; i < sizeof(dst); i++)
EXPECT_EQ(0, dst[i]);
}
#endif

238
unit_tests/helpers/string_to_hash_tests.cpp
View File

@@ -1,238 +0,0 @@
/*
* Copyright (C) 2017-2019 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "runtime/helpers/hash.h"
#include "runtime/helpers/string_helpers.h"
#include "gtest/gtest.h"
using NEO::Hash;
TEST(CreateCombinedStrings, singleString) {
std::string dstString;
size_t dstStringSizeInBytes = 0;
const char srcString[] = "HelloWorld";
const char *pSrcString = srcString;
auto srcStrings = &pSrcString;
size_t lengths = strlen(srcString);
auto retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
1,
srcStrings,
&lengths);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(lengths + 1, dstStringSizeInBytes);
EXPECT_EQ(0, strcmp(srcString, dstString.c_str()));
}
TEST(CreateCombinedStrings, SingleStringWithNullLengthNoCrash) {
std::string dstString;
size_t dstStringSizeInBytes = 0;
const char srcString[] = "HelloWorld";
const char *pSrcString = srcString;
auto srcStrings = &pSrcString;
auto retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
1,
srcStrings,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strcmp(srcString, dstString.c_str()));
}
TEST(CreateCombinedStrings, SingleStringWithZeroLengthNoCrash) {
std::string dstString;
size_t dstStringSizeInBytes = 0;
const char srcString[] = "HelloWorld";
const char *pSrcString = srcString;
auto srcStrings = &pSrcString;
size_t lengths = 0;
auto retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
1,
srcStrings,
&lengths);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strcmp(srcString, dstString.c_str()));
}
TEST(CreateCombinedStrings, multiString) {
std::string dstString;
size_t dstStringSizeInBytes = 0;
const char *srcString[] = {"HelloWorld", "dlroWolleH"};
std::string combined(srcString[0]);
combined += srcString[1];
auto srcStrings = &srcString[0];
size_t lengths[2] = {strlen(srcString[0]), strlen(srcString[1])};
auto retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
2,
srcStrings,
lengths);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strcmp(combined.c_str(), dstString.c_str()));
}
TEST(CreateCombinedStrings, multiStringWithNullLengthNoCrash) {
std::string dstString;
size_t dstStringSizeInBytes = 0;
const char *srcString[] = {"HelloWorld", "dlroWolleH"};
std::string combined(srcString[0]);
combined += srcString[1];
auto srcStrings = &srcString[0];
auto retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
2,
srcStrings,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strcmp(combined.c_str(), dstString.c_str()));
}
TEST(CreateCombinedStrings, multiStringWithZeroLengthNoCrash) {
std::string dstString;
size_t dstStringSizeInBytes = 0;
const char *srcString[] = {"HelloWorld", "dlroWolleH"};
std::string combined(srcString[0]);
combined += srcString[1];
auto srcStrings = &srcString[0];
size_t lengths[2] = {0, strlen(srcString[1])};
auto retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
2,
srcStrings,
lengths);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strcmp(combined.c_str(), dstString.c_str()));
}
TEST(CreateCombinedStrings, GivenMultipleStringWhichOneContainsAndErrorAndSizeThatForcesDriverToOmitTheErorrThenProgramSourceDoesntContainErrorString) {
std::string dstString;
size_t dstStringSizeInBytes = 0;
const char *srcString[] = {"HelloWorld", "dlroWolleHBABA"};
const char *expString[] = {"HelloWorld", "dlroWolleH"};
size_t lengths[2] = {0, strlen(expString[1])};
std::string combined(expString[0]);
combined += expString[1];
auto retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
2,
srcString,
lengths);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strcmp(combined.c_str(), dstString.c_str()));
}
TEST(CreateCombinedStrings, negativeScenarios) {
std::string dstString;
size_t dstStringSizeInBytes = 0;
const char *srcString[] = {"HelloWorld", "dlroWolleH"};
std::string combined(srcString[0]);
combined += srcString[1];
const char *srcStrings[2] = {srcString[0], srcString[1]};
size_t lengths[2] = {0, strlen(srcString[1])};
auto retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
0,
srcStrings,
lengths);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
1,
nullptr,
lengths);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
srcStrings[0] = nullptr;
retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
2,
srcStrings,
lengths);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST(CreateCombinedStrings, GivenMultipleStringThatCountIsHigherThenMaximalStackSizeSizesWhenAskedForCombinedThenProperStringIsRetruned) {
std::string dstString;
size_t dstStringSizeInBytes = 0;
const char *defaultString = "hello";
const char *srcString[maximalStackSizeSizes + 2];
std::string combinedString;
for (int i = 0; i < maximalStackSizeSizes + 2; i++) {
srcString[i] = defaultString;
combinedString += defaultString;
}
auto retVal = createCombinedString(
dstString,
dstStringSizeInBytes,
maximalStackSizeSizes + 2,
srcString,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0, strcmp(combinedString.c_str(), dstString.c_str()));
}
TEST(CreateHash, HashBuffers) {
char pBuffer[128];
memset(pBuffer, 0x23, sizeof(pBuffer));
// make sure we can get a hash and make sure we can get the same hash
auto hash1 = Hash::hash(pBuffer, sizeof(pBuffer));
auto hash2 = Hash::hash(pBuffer, sizeof(pBuffer));
EXPECT_NE(0u, hash1);
EXPECT_NE(0u, hash2);
EXPECT_EQ(hash1, hash2);
// make sure that we get a different hash for different length/data
auto hash3 = Hash::hash(pBuffer, sizeof(pBuffer) - 1);
EXPECT_NE(0u, hash3);
EXPECT_NE(hash2, hash3);
}
TEST(CreateHash, unalignedLengths) {
char pBuffer[] = {
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
// Use unaligned lengths. Wiggle the byte after the length
// Shouldn't affect hash.
for (auto length = 1u; length < sizeof(pBuffer); length++) {
auto hash1 = Hash::hash(pBuffer, length);
pBuffer[length]++;
EXPECT_EQ(hash1, Hash::hash(pBuffer, length));
}
}

2
unit_tests/helpers/test_files.cpp
View File

@@ -7,7 +7,7 @@
#include "test_files.h"
#include "runtime/helpers/file_io.h"
#include "core/helpers/file_io.h"
#include "config.h"