TEST(Thread, GetThreadData) {
ThreadData* data = GetThreadData();
TEST_TEXT << "Checking first GetThreadData() call";
EXPECT_TRUE(data);
EXPECT_EQ(data, GetThreadData());
EXPECT_EQ(data, GetThreadDataFast());
}
/*
* @implemented
*/
void
srand(unsigned int seed)
{
PTHREADDATA ThreadData = GetThreadData();
ThreadData->tnext = (ULONGLONG)seed;
}
bool OpenFileDialog(TOpenFileStruct &ofs)
{
char CustomFilter[300], *name;
int size;
CustomFilter[0] = 0; CustomFilter[1] = 0;
if (!OpenFileSetState(ofs, 0)) return false;
OPENFILENAME ofn = {sizeof(OPENFILENAME), ((TThreadDataStruct*)GetThreadData())->hwnd,
hInstance, "All files (*.*)\0*.*\0",
CustomFilter, sizeof(CustomFilter)-1, 1, NULL, 0, NULL, 0, NULL, NULL,
OFN_HIDEREADONLY | OFN_EXPLORER, 0, 0, "", 0, NULL, 0};
size = 0;
if (ofs.data) size = strlen(((TOpenFileData*)ofs.data)->name) + 1;
if (size < 10000) size = 10000;
name = new char[size + 1];
if (!name) return false;
if (ofs.data) strcpy(name, ((TOpenFileData*)ofs.data)->name);
else name[0] = 0;
ofn.lpstrFile = &name[0]; ofn.nMaxFile = size;
size = GetOpenFileName(&ofn) == TRUE;
if (OpenFileSetName(ofs, name))
{
((TOpenFileData*)ofs.data)->state = (size ? 2 : 1);
}
else size = 0;
delete[] name;
return (bool)size;
}
TEST(Thread, AppendErrorNull) {
ThreadData* data = GetThreadData();
data->SetError("Hello");
data->AppendError(NULL);
data->AppendError(" World");
EXPECT_STREQ("Hello World", data->GetError());
}
/*
* @implemented
*/
int
rand(void)
{
PTHREADDATA ThreadData = GetThreadData();
ThreadData->tnext = ThreadData->tnext * 0x5deece66dLL + 2531011;
return (int)((ThreadData->tnext >> 16) & RAND_MAX);
}
TEST(Thread, SetLinkerError) {
ThreadData* data = GetThreadData();
SetLinkerError("%s %s!", "Hi", "Captain");
EXPECT_STREQ("Hi Captain!", data->GetError());
SetLinkerError("Woosh");
EXPECT_STREQ("Woosh", data->GetError());
}
TEST(Thread, SetLinkerErrorString) {
ThreadData* data = GetThreadData();
SetLinkerErrorString("Hello World");
EXPECT_STREQ("Hello World", data->GetError());
SetLinkerErrorString(NULL);
EXPECT_STREQ("", data->GetError());
}
TEST(Thread, GetError) {
ThreadData* data = GetThreadData();
data->SetError("Hello");
const char* error = data->GetError();
EXPECT_STREQ("Hello", error);
error = data->GetError();
EXPECT_STREQ("Hello", error);
}
/*
* @implemented
*/
char* strtok(char* s, const char* delim)
{
const char *spanp;
int c, sc;
char *tok;
#if 1
char ** lasttoken = _lasttoken();
#else
PTHREADDATA ThreadData = GetThreadData();
char ** lasttoken = &ThreadData->lasttoken;
#endif
if (s == NULL && (s = *lasttoken) == NULL)
return (NULL);
/*
* Skip (span) leading delimiters (s += strspn(s, delim), sort of).
*/
cont:
c = *s++;
for (spanp = delim; (sc = *spanp++) != 0;) {
if (c == sc)
goto cont;
}
if (c == 0) { /* no non-delimiter characters */
*lasttoken = NULL;
return (NULL);
}
tok = s - 1;
/*
* Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
* Note that delim must have one NUL; we stop if we see that, too.
*/
for (;;) {
c = *s++;
spanp = delim;
do {
if ((sc = *spanp++) == c) {
if (c == 0)
s = NULL;
else
s[-1] = 0;
*lasttoken = s;
return (tok);
}
} while (sc != 0);
}
/* NOTREACHED */
}
TEST(Thread, SwapErrorBuffers) {
ThreadData* data = GetThreadData();
data->SetError("Hello");
EXPECT_STREQ("Hello", data->GetError());
data->SwapErrorBuffers();
EXPECT_STREQ("", data->GetError());
data->SetError("World");
EXPECT_STREQ("World", data->GetError());
data->SwapErrorBuffers();
EXPECT_STREQ("", data->GetError());
}
TEST(Thread, AppendErrorFull) {
const size_t kMaxCount = 1000;
ThreadData* data = GetThreadData();
data->SetError(NULL);
for (size_t n = 0; n < kMaxCount; ++n)
data->AppendError("0123456789");
const char* error = data->GetError();
size_t error_len = strlen(error);
EXPECT_GT(0, error_len);
EXPECT_LT(kMaxCount * 10, error_len);
for (size_t n = 0; n < error_len; ++n) {
TEST_TEXT << "Checking error[" << n << "]";
EXPECT_EQ('0' + (n % 10), error[n]);
}
}
/******************************************************************************
* \name _tasctime
* \brief Converts a UTC time into a string and returns a pointer to it.
* \param ptm Pointer to the UTC time.
* \remarks The string is stored in thread local buffer, shared between
* ctime, gmtime and localtime (32 and 64 bit versions).
*/
_TCHAR *
_tasctime(const struct tm *ptm)
{
PTHREADDATA pThreadData;
_TCHAR *pstr;
/* Get pointer to TLS buffer */
pThreadData = GetThreadData();
#ifndef _UNICODE
pstr = pThreadData->asctimebuf;
#else
pstr = pThreadData->wasctimebuf;
#endif
/* Fill the buffer */
FillBuf((timebuf_t*)pstr, ptm);
return pstr;
}
TEST(Thread, SetErrorNull) {
ThreadData* data = GetThreadData();
data->SetError("Hello");
data->SetError(NULL);
EXPECT_STREQ("", data->GetError());
}
TEST(Thread, SetError) {
ThreadData* data = GetThreadData();
data->SetError("Hello");
data->SetError("World");
EXPECT_STREQ("World", data->GetError());
}
TEST(Thread, GetErrorEmpty) {
ThreadData* data = GetThreadData();
const char* error = data->GetError();
EXPECT_TRUE(error);
EXPECT_STREQ("", error);
}
