ShuriZma
/
xenia
mirror of https://github.com/xenia-project/xenia.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1108 from bwrsandman/memory_tests 

Memory tests
This commit is contained in:
Justin Moore 2018-04-21 08:54:56 -05:00 committed by GitHub
parent 86f387ed42 24e7bb5293
commit 6209c4a931
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 446 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -59,7 +59,7 @@ script:
# Run linter.
- if [[ $LINT == true ]]; then ./xenia-build lint --all; fi
# Build and run our simple hello world test.
# Build and run base tests
- if [[ $BUILD == true ]]; then ./xenia-build build --config=$CONFIG --target=xenia-base-tests; fi
- if [[ $BUILD == true ]]; then ./build/bin/Linux/$CONFIG/xenia-base-tests; fi
# Build and run ppc tests

37
src/xenia/base/memory.cc
View File

@ -26,7 +26,9 @@ void copy_128_aligned(void* dest, const void* src, size_t count) {
#if XE_ARCH_AMD64
void copy_and_swap_16_aligned(void* dest_ptr, const void* src_ptr,
size_t count) {
assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x1);
assert_zero(reinterpret_cast<uintptr_t>(dest_ptr) & 0xF);
assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0xF);
auto dest = reinterpret_cast<uint16_t*>(dest_ptr);
auto src = reinterpret_cast<const uint16_t*>(src_ptr);
__m128i shufmask =
@ -34,12 +36,7 @@ void copy_and_swap_16_aligned(void* dest_ptr, const void* src_ptr,
0x04, 0x05, 0x02, 0x03, 0x00, 0x01);
size_t i = 0;
size_t unaligned_words = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 2;
for (; unaligned_words > 0 && i < count; unaligned_words--, i++) {
// Copy up to 16 byte alignment.
dest[i] = byte_swap(src[i]);
}
for (; i + 8 <= count; i += 8) {
for (i = 0; i + 8 <= count; i += 8) {
__m128i input = _mm_load_si128(reinterpret_cast<const __m128i*>(&src[i]));
__m128i output = _mm_shuffle_epi8(input, shufmask);
_mm_store_si128(reinterpret_cast<__m128i*>(&dest[i]), output);
@ -70,20 +67,17 @@ void copy_and_swap_16_unaligned(void* dest_ptr, const void* src_ptr,
void copy_and_swap_32_aligned(void* dest_ptr, const void* src_ptr,
size_t count) {
assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x3);
assert_zero(reinterpret_cast<uintptr_t>(dest_ptr) & 0xF);
assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0xF);
auto dest = reinterpret_cast<uint32_t*>(dest_ptr);
auto src = reinterpret_cast<const uint32_t*>(src_ptr);
__m128i shufmask =
_mm_set_epi8(0x0C, 0x0D, 0x0E, 0x0F, 0x08, 0x09, 0x0A, 0x0B, 0x04, 0x05,
0x06, 0x07, 0x00, 0x01, 0x02, 0x03);
size_t i = 0;
size_t unaligned_dwords = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 4;
for (; unaligned_dwords > 0 && i < count; unaligned_dwords--, i++) {
// Copy up to 16 byte alignment.
dest[i] = byte_swap(src[i]);
}
for (; i + 4 <= count; i += 4) {
size_t i;
for (i = 0; i + 4 <= count; i += 4) {
__m128i input = _mm_load_si128(reinterpret_cast<const __m128i*>(&src[i]));
__m128i output = _mm_shuffle_epi8(input, shufmask);
_mm_store_si128(reinterpret_cast<__m128i*>(&dest[i]), output);
@ -114,20 +108,17 @@ void copy_and_swap_32_unaligned(void* dest_ptr, const void* src_ptr,
void copy_and_swap_64_aligned(void* dest_ptr, const void* src_ptr,
size_t count) {
assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x7);
assert_zero(reinterpret_cast<uintptr_t>(dest_ptr) & 0xF);
assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0xF);
auto dest = reinterpret_cast<uint64_t*>(dest_ptr);
auto src = reinterpret_cast<const uint64_t*>(src_ptr);
__m128i shufmask =
_mm_set_epi8(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01,
0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
size_t i = 0;
size_t unaligned_qwords = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 8;
for (; unaligned_qwords > 0 && i < count; unaligned_qwords--, i++) {
// Copy up to 16 byte alignment.
dest[i] = byte_swap(src[i]);
}
for (; i + 2 <= count; i += 2) {
size_t i;
for (i = 0; i + 2 <= count; i += 2) {
__m128i input = _mm_load_si128(reinterpret_cast<const __m128i*>(&src[i]));
__m128i output = _mm_shuffle_epi8(input, shufmask);
_mm_store_si128(reinterpret_cast<__m128i*>(&dest[i]), output);

17
src/xenia/base/memory_test.cc
View File

@ -1,17 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2015 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/base/memory.h"
#include "third_party/catch/include/catch.hpp"
TEST_CASE("copy_and_swap_16_aligned", "Copy and Swap") {
// TODO(benvanik): tests.
REQUIRE(true == true);
}

9
src/xenia/base/premake5.lua
View File

@ -16,11 +16,4 @@ project("xenia-base")
"debug_visualizers.natvis",
})
test_suite("xenia-base-tests", project_root, ".", {
includedirs = {
project_root.."/third_party/gflags/src",
},
links = {
"xenia-base",
},
})
include("testing")

419
src/xenia/base/testing/memory_test.cc Normal file
View File

@ -0,0 +1,419 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2015 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/base/memory.h"
#include "third_party/catch/include/catch.hpp"
namespace xe {
namespace base {
namespace test {
TEST_CASE("copy_128_aligned", "Copy and Swap") {
alignas(128) uint8_t src[256], dest[256];
for (uint8_t i = 0; i < 255; ++i) {
src[i] = 255 - i;
}
std::memset(dest, 0, sizeof(dest));
copy_128_aligned(dest, src, 1);
REQUIRE(std::memcmp(dest, src, 128));
REQUIRE(dest[128] == 0);
std::memset(dest, 0, sizeof(dest));
copy_128_aligned(dest, src, 2);
REQUIRE(std::memcmp(dest, src, 256));
std::memset(dest, 0, sizeof(dest));
copy_128_aligned(dest, src + 1, 1);
REQUIRE(std::memcmp(dest, src + 1, 128));
}
TEST_CASE("copy_and_swap_16_aligned", "Copy and Swap") {
alignas(16) uint16_t a = 0x1111, b = 0xABCD;
copy_and_swap_16_aligned(&a, &b, 1);
REQUIRE(a == 0xCDAB);
REQUIRE(b == 0xABCD);
alignas(16) uint16_t c[] = {0x0000, 0x0000, 0x0000, 0x0000};
alignas(16) uint16_t d[] = {0x0123, 0x4567, 0x89AB, 0xCDEF};
copy_and_swap_16_aligned(c, d, 1);
REQUIRE(c[0] == 0x2301);
REQUIRE(c[1] == 0x0000);
REQUIRE(c[2] == 0x0000);
REQUIRE(c[3] == 0x0000);
copy_and_swap_16_aligned(c, d, 3);
REQUIRE(c[0] == 0x2301);
REQUIRE(c[1] == 0x6745);
REQUIRE(c[2] == 0xAB89);
REQUIRE(c[3] == 0x0000);
copy_and_swap_16_aligned(c, d, 4);
REQUIRE(c[0] == 0x2301);
REQUIRE(c[1] == 0x6745);
REQUIRE(c[2] == 0xAB89);
REQUIRE(c[3] == 0xEFCD);
alignas(16) uint64_t e;
copy_and_swap_16_aligned(&e, d, 4);
REQUIRE(e == 0xEFCDAB8967452301);
alignas(16) char f[85] = {0x00};
alignas(16) char g[] =
"This is a 85 byte long string... "
"It's supposed to be longer than standard alignment.";
copy_and_swap_16_aligned(f, g, 42);
REQUIRE(std::strcmp(f,
"hTsii s a58b ty eolgns rtni.g..I 't susppsodet oebl "
"noeg rhtnas atdnra dlagimnne.t") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_16_aligned(f, g + 16, 34);
REQUIRE(std::strcmp(f,
" eolgns rtni.g..I 't susppsodet oebl "
"noeg rhtnas atdnra dlagimnne.t") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_16_aligned(f, g + 32, 26);
REQUIRE(std::strcmp(f,
"I 't susppsodet oebl "
"noeg rhtnas atdnra dlagimnne.t") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_16_aligned(f, g + 64, 10);
REQUIRE(std::strcmp(f, "s atdnra dlagimnne.t") == 0);
}
TEST_CASE("copy_and_swap_16_unaligned", "Copy and Swap") {
uint16_t a = 0x1111, b = 0xABCD;
copy_and_swap_16_unaligned(&a, &b, 1);
REQUIRE(a == 0xCDAB);
REQUIRE(b == 0xABCD);
uint16_t c[] = {0x0000, 0x0000, 0x0000, 0x0000};
uint16_t d[] = {0x0123, 0x4567, 0x89AB, 0xCDEF};
copy_and_swap_16_unaligned(c, d, 1);
REQUIRE(c[0] == 0x2301);
REQUIRE(c[1] == 0x0000);
REQUIRE(c[2] == 0x0000);
REQUIRE(c[3] == 0x0000);
copy_and_swap_16_unaligned(c, d, 4);
REQUIRE(c[0] == 0x2301);
REQUIRE(c[1] == 0x6745);
REQUIRE(c[2] == 0xAB89);
REQUIRE(c[3] == 0xEFCD);
uint64_t e;
copy_and_swap_16_unaligned(&e, d, 4);
REQUIRE(e == 0xEFCDAB8967452301);
char f[85] = {0x00};
char g[] =
"This is a 85 byte long string... "
"It's supposed to be longer than standard alignment.";
copy_and_swap_16_unaligned(f, g, 42);
REQUIRE(std::strcmp(f,
"hTsii s a58b ty eolgns rtni.g..I 't susppsodet oebl "
"noeg rhtnas atdnra dlagimnne.t") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_16_unaligned(f, g + 1, 41);
REQUIRE(std::strcmp(f,
"ih ssia 8 5ybetl no gtsirgn.. .tIs's puopes dotb "
"eolgnret ah ntsnaaddra ilngemtn") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_16_unaligned(f, g + 2, 41);
REQUIRE(std::strcmp(f,
"sii s a58b ty eolgns rtni.g..I 't susppsodet oebl "
"noeg rhtnas atdnra dlagimnne.t") == 0);
}
TEST_CASE("copy_and_swap_32_aligned", "Copy and Swap") {
alignas(32) uint32_t a = 0x11111111, b = 0x89ABCDEF;
copy_and_swap_32_aligned(&a, &b, 1);
REQUIRE(a == 0xEFCDAB89);
REQUIRE(b == 0x89ABCDEF);
alignas(32) uint32_t c[] = {0x00000000, 0x00000000, 0x00000000, 0x00000000};
alignas(32) uint32_t d[] = {0x01234567, 0x89ABCDEF, 0xE887EEED, 0xD8514199};
copy_and_swap_32_aligned(c, d, 1);
REQUIRE(c[0] == 0x67452301);
REQUIRE(c[1] == 0x00000000);
REQUIRE(c[2] == 0x00000000);
REQUIRE(c[3] == 0x00000000);
copy_and_swap_32_aligned(c, d, 3);
REQUIRE(c[0] == 0x67452301);
REQUIRE(c[1] == 0xEFCDAB89);
REQUIRE(c[2] == 0xEDEE87E8);
REQUIRE(c[3] == 0x00000000);
copy_and_swap_32_aligned(c, d, 4);
REQUIRE(c[0] == 0x67452301);
REQUIRE(c[1] == 0xEFCDAB89);
REQUIRE(c[2] == 0xEDEE87E8);
REQUIRE(c[3] == 0x994151D8);
alignas(32) uint64_t e;
copy_and_swap_32_aligned(&e, d, 2);
REQUIRE(e == 0xEFCDAB8967452301);
alignas(32) char f[85] = {0x00};
alignas(32) char g[] =
"This is a 85 byte long string... "
"It's supposed to be longer than standard alignment.";
copy_and_swap_32_aligned(f, g, 21);
REQUIRE(std::strcmp(f,
"sihT si 58 atyb ol es gnnirt...g'tI us ssoppt deeb "
"onol regnahtats radnla dmngi.tne") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_32_aligned(f, g + 16, 17);
REQUIRE(std::strcmp(f,
"ol es gnnirt...g'tI us ssoppt deeb "
"onol regnahtats radnla dmngi.tne") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_32_aligned(f, g + 32, 13);
REQUIRE(std::strcmp(f,
"'tI us ssoppt deeb "
"onol regnahtats radnla dmngi.tne") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_32_aligned(f, g + 64, 5);
REQUIRE(std::strcmp(f, "ats radnla dmngi.tne") == 0);
}
TEST_CASE("copy_and_swap_32_unaligned", "Copy and Swap") {
uint32_t a = 0x11111111, b = 0x89ABCDEF;
copy_and_swap_32_unaligned(&a, &b, 1);
REQUIRE(a == 0xEFCDAB89);
REQUIRE(b == 0x89ABCDEF);
uint32_t c[] = {0x00000000, 0x00000000, 0x00000000, 0x00000000};
uint32_t d[] = {0x01234567, 0x89ABCDEF, 0xE887EEED, 0xD8514199};
copy_and_swap_32_unaligned(c, d, 1);
REQUIRE(c[0] == 0x67452301);
REQUIRE(c[1] == 0x00000000);
REQUIRE(c[2] == 0x00000000);
REQUIRE(c[3] == 0x00000000);
copy_and_swap_32_unaligned(c, d, 3);
REQUIRE(c[0] == 0x67452301);
REQUIRE(c[1] == 0xEFCDAB89);
REQUIRE(c[2] == 0xEDEE87E8);
REQUIRE(c[3] == 0x00000000);
copy_and_swap_32_unaligned(c, d, 4);
REQUIRE(c[0] == 0x67452301);
REQUIRE(c[1] == 0xEFCDAB89);
REQUIRE(c[2] == 0xEDEE87E8);
REQUIRE(c[3] == 0x994151D8);
uint64_t e;
copy_and_swap_32_unaligned(&e, d, 2);
REQUIRE(e == 0xEFCDAB8967452301);
char f[85] = {0x00};
char g[] =
"This is a 85 byte long string... "
"It's supposed to be longer than standard alignment.";
copy_and_swap_32_unaligned(f, g, 21);
REQUIRE(std::strcmp(f,
"sihT si 58 atyb ol es gnnirt...g'tI us ssoppt deeb "
"onol regnahtats radnla dmngi.tne") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_32_unaligned(f, g + 1, 20);
REQUIRE(std::strcmp(f,
" siha si 58 etybnol ts ggnir ...s'tIpus esopot d eb "
"gnolt re nahnatsdradila emng") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_32_unaligned(f, g + 2, 20);
REQUIRE(std::strcmp(f,
"i si a sb 58 etygnolrts .gniI .. s'tppusdeso ot l "
"ebegnoht rs nadnat dragilanemn") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_32_unaligned(f, g + 3, 20);
REQUIRE(std::strcmp(f,
"si s8 a yb 5l et gnoirts..gntI .s s'oppu desb otol "
"eregnaht ts nadnaa drngiltnem") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_32_unaligned(f, g + 4, 20);
REQUIRE(std::strcmp(f,
" si 58 atyb ol es gnnirt...g'tI us ssoppt deeb onol "
"regnahtats radnla dmngi.tne") == 0);
}
TEST_CASE("copy_and_swap_64_aligned", "Copy and Swap") {
alignas(64) uint64_t a = 0x1111111111111111, b = 0x0123456789ABCDEF;
copy_and_swap_64_aligned(&a, &b, 1);
REQUIRE(a == 0xEFCDAB8967452301);
REQUIRE(b == 0x0123456789ABCDEF);
alignas(64) uint64_t c[] = {0x0000000000000000, 0x0000000000000000,
0x0000000000000000, 0x0000000000000000};
alignas(64) uint64_t d[] = {0x0123456789ABCDEF, 0xE887EEEDD8514199,
0x21D4745A1D4A7706, 0xA4174FED675766E3};
copy_and_swap_64_aligned(c, d, 1);
REQUIRE(c[0] == 0xEFCDAB8967452301);
REQUIRE(c[1] == 0x0000000000000000);
REQUIRE(c[2] == 0x0000000000000000);
REQUIRE(c[3] == 0x0000000000000000);
copy_and_swap_64_aligned(c, d, 3);
REQUIRE(c[0] == 0xEFCDAB8967452301);
REQUIRE(c[1] == 0x994151D8EDEE87E8);
REQUIRE(c[2] == 0x06774A1D5A74D421);
REQUIRE(c[3] == 0x0000000000000000);
copy_and_swap_64_aligned(c, d, 4);
REQUIRE(c[0] == 0xEFCDAB8967452301);
REQUIRE(c[1] == 0x994151D8EDEE87E8);
REQUIRE(c[2] == 0x06774A1D5A74D421);
REQUIRE(c[3] == 0xE3665767ED4F17A4);
alignas(64) uint64_t e;
copy_and_swap_64_aligned(&e, d, 1);
REQUIRE(e == 0xEFCDAB8967452301);
alignas(64) char f[85] = {0x00};
alignas(64) char g[] =
"This is a 85 byte long string... "
"It's supposed to be longer than standard alignment.";
copy_and_swap_64_aligned(f, g, 10);
REQUIRE(std::strcmp(f,
" si sihTtyb 58 as gnol e...gnirtus s'tI t desoppnol eb "
"onaht regradnats mngila d") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_aligned(f, g + 16, 8);
REQUIRE(std::strcmp(f,
"s gnol e...gnirtus s'tI t desoppnol eb "
"onaht regradnats mngila d") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_aligned(f, g + 32, 6);
REQUIRE(std::strcmp(f,
"us s'tI t desoppnol eb "
"onaht regradnats mngila d") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_aligned(f, g + 64, 2);
REQUIRE(std::strcmp(f, "radnats mngila d") == 0);
}
TEST_CASE("copy_and_swap_64_unaligned", "Copy and Swap") {
uint64_t a = 0x1111111111111111, b = 0x0123456789ABCDEF;
copy_and_swap_64_unaligned(&a, &b, 1);
REQUIRE(a == 0xEFCDAB8967452301);
REQUIRE(b == 0x0123456789ABCDEF);
uint64_t c[] = {0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
0x0000000000000000};
uint64_t d[] = {0x0123456789ABCDEF, 0xE887EEEDD8514199, 0x21D4745A1D4A7706,
0xA4174FED675766E3};
copy_and_swap_64_unaligned(c, d, 1);
REQUIRE(c[0] == 0xEFCDAB8967452301);
REQUIRE(c[1] == 0x0000000000000000);
REQUIRE(c[2] == 0x0000000000000000);
REQUIRE(c[3] == 0x0000000000000000);
copy_and_swap_64_unaligned(c, d, 3);
REQUIRE(c[0] == 0xEFCDAB8967452301);
REQUIRE(c[1] == 0x994151D8EDEE87E8);
REQUIRE(c[2] == 0x06774A1D5A74D421);
REQUIRE(c[3] == 0x0000000000000000);
copy_and_swap_64_unaligned(c, d, 4);
REQUIRE(c[0] == 0xEFCDAB8967452301);
REQUIRE(c[1] == 0x994151D8EDEE87E8);
REQUIRE(c[2] == 0x06774A1D5A74D421);
REQUIRE(c[3] == 0xE3665767ED4F17A4);
uint64_t e;
copy_and_swap_64_unaligned(&e, d, 1);
REQUIRE(e == 0xEFCDAB8967452301);
char f[85] = {0x00};
char g[] =
"This is a 85 byte long string... "
"It's supposed to be longer than standard alignment.";
copy_and_swap_64_unaligned(f, g, 10);
REQUIRE(std::strcmp(f,
" si sihTtyb 58 as gnol e...gnirtus s'tI t desoppnol eb "
"onaht regradnats mngila d") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_unaligned(f, g + 1, 10);
REQUIRE(std::strcmp(f,
"a si sihetyb 58 ts gnol ...gnirpus s'tIot desopgnol "
"eb naht redradnatsemngila ") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_unaligned(f, g + 2, 10);
REQUIRE(std::strcmp(f,
" a si si etyb 58rts gnolI ...gnippus s't ot desoegnol "
"ebs naht r dradnatnemngila") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_unaligned(f, g + 3, 10);
REQUIRE(std::strcmp(f,
"8 a si sl etyb 5irts gnotI ...gnoppus s'b ot desregnol "
"ets naht a dradnatnemngil") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_unaligned(f, g + 4, 10);
REQUIRE(std::strcmp(f,
"58 a si ol etyb nirts gn'tI ...gsoppus seb ot de "
"regnol ats nahtla dradn.tnemngi") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_unaligned(f, g + 5, 9);
REQUIRE(std::strcmp(f,
" 58 a sinol etybgnirts gs'tI ...esoppus eb ot dt "
"regnolnats nahila drad") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_unaligned(f, g + 6, 9);
REQUIRE(std::strcmp(f,
"b 58 a sgnol ety.gnirts s'tI ..desoppusl eb ot ht "
"regnodnats nagila dra") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_unaligned(f, g + 7, 9);
REQUIRE(std::strcmp(f,
"yb 58 a gnol et..gnirtss s'tI . desoppuol eb otaht "
"regnadnats nngila dr") == 0);
std::memset(f, 0, sizeof(f));
copy_and_swap_64_unaligned(f, g + 8, 9);
REQUIRE(std::strcmp(f,
"tyb 58 as gnol e...gnirtus s'tI t desoppnol eb onaht "
"regradnats mngila d") == 0);
}
TEST_CASE("copy_and_swap_16_in_32_aligned", "Copy and Swap") {
// TODO(bwrsandman): test once properly understood.
REQUIRE(true == true);
}
TEST_CASE("copy_and_swap_16_in_32_unaligned", "Copy and Swap") {
// TODO(bwrsandman): test once properly understood.
REQUIRE(true == true);
}
} // namespace test
} // namespace base
} // namespace xe

11
src/xenia/base/testing/premake5.lua Normal file
View File

@ -0,0 +1,11 @@
project_root = "../../../.."
include(project_root.."/tools/build")
test_suite("xenia-base-tests", project_root, ".", {
includedirs = {
project_root.."/third_party/gflags/src",
},
links = {
"xenia-base",
},
})