cmd.c File Reference

#include "precomp.h"

Include dependency graph for cmd.c:

Go to the source code of this file.

Classes
struct	TEST_ENTRY

Macros
#define	TIMEOUT   3000
#define	TRISTATE   2

Typedefs
typedef struct TEST_ENTRY	TEST_ENTRY

Functions
static BOOL	MyDuplicateHandle (HANDLE hFile, PHANDLE phFile, BOOL bInherit)
static BOOL	PrepareForRedirect (STARTUPINFOA *psi, PHANDLE phInputWrite, PHANDLE phOutputRead, PHANDLE phErrorRead)
static void	DoTestEntry (const TEST_ENTRY *pEntry)
	START_TEST (exit)
	START_TEST (echo)
	START_TEST (cd)
	START_TEST (pushd)
	START_TEST (attrib)

Variables
static const TEST_ENTRY	s_exit_entries []
static const TEST_ENTRY	s_echo_entries []
static const TEST_ENTRY	s_cd_entries []
static const TEST_ENTRY	s_pushd_entries []
static const TEST_ENTRY	s_attrib_entries []

Macro Definition Documentation

TIMEOUT

#define TIMEOUT   3000

Definition at line 10 of file cmd.c.

TRISTATE

#define TRISTATE   2

Definition at line 25 of file cmd.c.

Typedef Documentation

TEST_ENTRY

typedef struct TEST_ENTRY TEST_ENTRY

Function Documentation

DoTestEntry()

static void DoTestEntry ( const TEST_ENTRY *  pEntry )

static

Definition at line 405 of file cmd.c.

{
    STARTUPINFOA si;
    PROCESS_INFORMATION pi;
    DWORD dwExitCode, dwWait;
    HANDLE hOutputRead = NULL;
    HANDLE hErrorRead = NULL;
    DWORD dwRead;
    BOOL bStdOutput, bStdError;
    CHAR szOut[512], szErr[512];
 
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESTDHANDLES;
 
    if (!PrepareForRedirect(&si, NULL, &hOutputRead, &hErrorRead))
    {
        skip("PrepareForRedirect failed\n");
        return;
    }
 
    if (CreateProcessA(NULL, (char *)pEntry->cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
    {
        CloseHandle(si.hStdInput);
        dwWait = WaitForSingleObject(pi.hProcess, TIMEOUT);
        if (dwWait == WAIT_TIMEOUT)
        {
            TerminateProcess(pi.hProcess, 9999);
        }
        GetExitCodeProcess(pi.hProcess, &dwExitCode);
        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
    }
    else
    {
        dwExitCode = 8888;
    }
 
    ZeroMemory(szOut, sizeof(szOut));
    PeekNamedPipe(hOutputRead, szOut, ARRAYSIZE(szOut), &dwRead, NULL, NULL);
    szOut[ARRAYSIZE(szOut) - 1] = 0;
    bStdOutput = dwRead != 0;
 
    ZeroMemory(szErr, sizeof(szErr));
    PeekNamedPipe(hErrorRead, szErr, ARRAYSIZE(szErr), &dwRead, NULL, NULL);
    szErr[ARRAYSIZE(szErr) - 1] = 0;
    bStdError = dwRead != 0;
 
    if (si.hStdInput)
        CloseHandle(si.hStdInput);
    if (si.hStdOutput)
        CloseHandle(si.hStdOutput);
    if (si.hStdError)
        CloseHandle(si.hStdError);
 
    ok(pEntry->bStdOutput == bStdOutput || pEntry->bStdOutput == TRISTATE,
       "Line %u: bStdOutput %d vs %d\n",
       pEntry->line, pEntry->bStdOutput, bStdOutput);
 
    ok(pEntry->bStdError == bStdError || pEntry->bStdOutput == TRISTATE,
       "Line %u: bStdError %d vs %d\n",
       pEntry->line, pEntry->bStdError, bStdError);
 
    ok(pEntry->dwExitCode == dwExitCode,
       "Line %u: dwExitCode %ld vs %ld\n",
       pEntry->line, pEntry->dwExitCode, dwExitCode);
 
    if (pEntry->OutputContains)
    {
        ok(strstr(szOut, pEntry->OutputContains) != NULL,
           "Line %u: szOut was '%s'\n",
           pEntry->line, szOut);
    }
 
    if (pEntry->ErrorContains)
    {
        ok(strstr(szErr, pEntry->ErrorContains) != NULL,
           "Line %u: szErr was '%s'\n",
           pEntry->line, szErr);
    }
 
    if (pEntry->OutputNotContains)
    {
        ok(strstr(szOut, pEntry->OutputNotContains) == NULL,
           "Line %u: szOut was '%s'\n",
           pEntry->line, szOut);
    }
 
    if (pEntry->ErrorNotContains)
    {
        ok(strstr(szErr, pEntry->ErrorNotContains) == NULL,
           "Line %u: szErr was '%s'\n",
           pEntry->line, szErr);
    }
}

Referenced by START_TEST().

MyDuplicateHandle()

static BOOL MyDuplicateHandle ( HANDLE  hFile, PHANDLE  phFile, BOOL  bInherit  )

static

Definition at line 324 of file cmd.c.

{
    HANDLE hProcess = GetCurrentProcess();
    return DuplicateHandle(hProcess, hFile, hProcess, phFile, 0,
                           bInherit, DUPLICATE_SAME_ACCESS);
}

Referenced by PrepareForRedirect().

PrepareForRedirect()

static BOOL PrepareForRedirect ( STARTUPINFOA *  psi, PHANDLE  phInputWrite, PHANDLE  phOutputRead, PHANDLE  phErrorRead  )

static

Definition at line 331 of file cmd.c.

{
    HANDLE hInputRead = NULL, hInputWriteTmp = NULL;
    HANDLE hOutputReadTmp = NULL, hOutputWrite = NULL;
    HANDLE hErrorReadTmp = NULL, hErrorWrite = NULL;
    SECURITY_ATTRIBUTES sa = { sizeof(sa), NULL, TRUE };
 
    psi->hStdInput = NULL;
    psi->hStdOutput = NULL;
    psi->hStdError = NULL;
 
    if (phInputWrite)
    {
        if (CreatePipe(&hInputRead, &hInputWriteTmp, &sa, 0))
        {
            if (!MyDuplicateHandle(hInputWriteTmp, phInputWrite, FALSE))
                goto failed;
 
            CloseHandle(hInputWriteTmp);
        }
        else
            goto failed;
    }
 
    if (phOutputRead)
    {
        if (CreatePipe(&hOutputReadTmp, &hOutputWrite, &sa, 0))
        {
            if (!MyDuplicateHandle(hOutputReadTmp, phOutputRead, FALSE))
                goto failed;
 
            CloseHandle(hOutputReadTmp);
        }
        else
            goto failed;
    }
 
    if (phOutputRead && phOutputRead == phErrorRead)
    {
        if (!MyDuplicateHandle(hOutputWrite, &hErrorWrite, TRUE))
            goto failed;
    }
    else if (phErrorRead)
    {
        if (CreatePipe(&hErrorReadTmp, &hErrorWrite, &sa, 0))
        {
            if (!MyDuplicateHandle(hErrorReadTmp, phErrorRead, FALSE))
                goto failed;
            CloseHandle(hErrorReadTmp);
        }
        else
            goto failed;
    }
 
    if (phInputWrite)
        psi->hStdInput = hInputRead;
    if (phOutputRead)
        psi->hStdOutput = hOutputWrite;
    if (phErrorRead)
        psi->hStdError = hErrorWrite;
 
    return TRUE;
 
failed:
    CloseHandle(hInputRead);
    CloseHandle(hInputWriteTmp);
    CloseHandle(hOutputReadTmp);
    CloseHandle(hOutputWrite);
    CloseHandle(hErrorReadTmp);
    CloseHandle(hErrorWrite);
    return FALSE;
}

Referenced by DoTestEntry().

START_TEST() [1/5]

START_TEST

(

attrib

)

Definition at line 537 of file cmd.c.

{
    SIZE_T i;
    for (i = 0; i < ARRAYSIZE(s_attrib_entries); ++i)
    {
        DoTestEntry(&s_attrib_entries[i]);
    }
}

START_TEST() [2/5]

START_TEST

(

cd

)

Definition at line 519 of file cmd.c.

{
    SIZE_T i;
    for (i = 0; i < ARRAYSIZE(s_cd_entries); ++i)
    {
        DoTestEntry(&s_cd_entries[i]);
    }
}

START_TEST() [3/5]

START_TEST

(

echo

)

Definition at line 510 of file cmd.c.

{
    SIZE_T i;
    for (i = 0; i < ARRAYSIZE(s_echo_entries); ++i)
    {
        DoTestEntry(&s_echo_entries[i]);
    }
}

START_TEST() [4/5]

START_TEST

(

exit

)

Definition at line 501 of file cmd.c.

{
    SIZE_T i;
    for (i = 0; i < ARRAYSIZE(s_exit_entries); ++i)
    {
        DoTestEntry(&s_exit_entries[i]);
    }
}

START_TEST() [5/5]

START_TEST

(

pushd

)

Definition at line 528 of file cmd.c.

{
    SIZE_T i;
    for (i = 0; i < ARRAYSIZE(s_pushd_entries); ++i)
    {
        DoTestEntry(&s_pushd_entries[i]);
    }
}

Variable Documentation

s_attrib_entries

const TEST_ENTRY s_attrib_entries[]

static

Definition at line 129 of file cmd.c.

Referenced by START_TEST().

s_cd_entries

const TEST_ENTRY s_cd_entries[]

static

Initial value:

=
{
    { __LINE__, 0,      "cmd /c cd \"C:\\ " },
    { __LINE__, 0,      "cmd /c cd C:/" },
    { __LINE__, 0,      "cmd /c cd \"\"", TRUE, FALSE },
    { __LINE__, 0,      "cmd /c cd", TRUE, FALSE },
    { __LINE__, 1234,   "cmd /c cd C:\\Program Files && exit 1234" },
    { __LINE__, 1234,   "cmd /c cd \"C:\\ \" && exit 1234" },
    { __LINE__, 1234,   "cmd /c cd \"C:\\Program Files\" && exit 1234" },
    { __LINE__, 1234,   "cmd /c cd \"\" && exit 1234", TRUE, FALSE },
    { __LINE__, 1234,   "cmd /c cd \\ && exit 1234" },
}

Definition at line 45 of file cmd.c.

Referenced by START_TEST().

s_echo_entries

const TEST_ENTRY s_echo_entries[]

static

Initial value:

=
{
 
    { __LINE__, 0,      "cmd /c echo.", TRUE, FALSE, "\r\n" },
    { __LINE__, 0,      "cmd /c echo ABC", TRUE, FALSE, "ABC\r\n" },
}

Definition at line 38 of file cmd.c.

Referenced by START_TEST().

s_exit_entries

const TEST_ENTRY s_exit_entries[]

static

Initial value:

=
{
    { __LINE__, 0,      "cmd /c exit" },
    { __LINE__, 0,      "cmd /c exit 0" },
    { __LINE__, 0,      "cmd /c exit \"\"" },
    { __LINE__, 0,      "cmd /c exit ABC" },
    { __LINE__, 0,      "cmd /c exit \"ABC" },
    { __LINE__, 0,      "cmd /c exit \"ABC\"" },
    { __LINE__, 1234,   "cmd /c exit 1234" },
}

Definition at line 27 of file cmd.c.

Referenced by START_TEST().

s_pushd_entries

const TEST_ENTRY s_pushd_entries[]

static

Definition at line 58 of file cmd.c.

Referenced by START_TEST().