fc.c File Reference

#include "precomp.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <shlwapi.h>

Include dependency graph for fc.c:

Go to the source code of this file.

Classes
struct	TEST_ENTRY

Macros
#define	FILE1   "fc-test1.txt"
#define	FILE2   "fc-test2.txt"
#define	FILES   " " FILE1 " " FILE2
#define	COMPARING   "Comparing files fc-test1.txt and FC-TEST2.TXT\n"
#define	NO_DIFF   "FC: no differences encountered\n"
#define	RESYNC_FAILED   "Resync Failed. Files are too different.\n"
#define	TIMEOUT   (10 * 1000)
#define	ENGLISH_CP   437 /* English codepage */

Typedefs
typedef struct TEST_ENTRY	TEST_ENTRY

Functions
BOOL	DoDuplicateHandle (HANDLE hFile, PHANDLE phFile, BOOL bInherit)
static BOOL	PrepareForRedirect (STARTUPINFOA *psi, PHANDLE phInputWrite, PHANDLE phOutputRead, PHANDLE phErrorRead)
static void	ConvertOutput (LPSTR psz)
static void	DoTestEntry (const TEST_ENTRY *pEntry)
	START_TEST (fc)

Variables
static const TEST_ENTRY	s_entries []

Macro Definition Documentation

COMPARING

#define COMPARING   "Comparing files fc-test1.txt and FC-TEST2.TXT\n"

Definition at line 29 of file fc.c.

ENGLISH_CP

#define ENGLISH_CP   437 /* English codepage */

Definition at line 601 of file fc.c.

FILE1

#define FILE1   "fc-test1.txt"

Definition at line 26 of file fc.c.

FILE2

#define FILE2   "fc-test2.txt"

Definition at line 27 of file fc.c.

FILES

#define FILES   " " FILE1 " " FILE2

Definition at line 28 of file fc.c.

NO_DIFF

#define NO_DIFF   "FC: no differences encountered\n"

Definition at line 30 of file fc.c.

RESYNC_FAILED

#define RESYNC_FAILED   "Resync Failed. Files are too different.\n"

Definition at line 31 of file fc.c.

TIMEOUT

#define TIMEOUT   (10 * 1000)

Typedef Documentation

TEST_ENTRY

typedef struct TEST_ENTRY TEST_ENTRY

Function Documentation

ConvertOutput()

static void ConvertOutput ( LPSTR  psz )

static

Definition at line 497 of file fc.c.

{
    LPSTR pch1, pch2;
    pch1 = pch2 = psz;
    while (*pch1)
    {
        if (*pch1 != '\r')
        {
            *pch2++ = *pch1;
        }
        ++pch1;
    }
    *pch2 = 0;
}

Referenced by DoTestEntry().

DoDuplicateHandle()

BOOL DoDuplicateHandle	(	HANDLE	hFile,
		PHANDLE	phFile,
		BOOL	bInherit
	)

Definition at line 409 of file fc.c.

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

Referenced by PrepareForRedirect().

DoTestEntry()

static void DoTestEntry ( const TEST_ENTRY *  pEntry )

static

Definition at line 512 of file fc.c.

{
    FILE *fp;
    STARTUPINFOA si = { sizeof(si) };
    PROCESS_INFORMATION pi;
    INT file1_size, file2_size;
    HANDLE hOutputRead;
    DWORD cbAvail, cbRead;
    CHAR szOutput[1024];
    BOOL ret;
    DWORD dwExitCode;
    LPSTR psz;
 
    file1_size = pEntry->file1_size;
    file2_size = pEntry->file2_size;
    if (file1_size == -1)
        file1_size = strlen(pEntry->file1_data);
    if (file2_size == -1)
        file2_size = strlen(pEntry->file2_data);
 
    fp = fopen(FILE1, "wb");
    fwrite(pEntry->file1_data, file1_size, 1, fp);
    fclose(fp);
 
    fp = fopen(FILE2, "wb");
    fwrite(pEntry->file2_data, file2_size, 1, fp);
    fclose(fp);
 
    ok(PathFileExistsA(FILE1), "Line %d: PathFileExistsA(FILE1) failed\n", pEntry->lineno);
    ok(PathFileExistsA(FILE2), "Line %d: PathFileExistsA(FILE2) failed\n", pEntry->lineno);
 
    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
 
    PrepareForRedirect(&si, NULL, &hOutputRead, &hOutputRead);
 
    psz = _strdup(pEntry->cmdline);
    ret = CreateProcessA(NULL, psz, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
    free(psz);
 
    ok(ret, "Line %d: CreateProcessA failed\n", pEntry->lineno);
 
#define TIMEOUT (10 * 1000)
    WaitForSingleObject(pi.hProcess, TIMEOUT);
 
    ZeroMemory(szOutput, sizeof(szOutput));
    if (PeekNamedPipe(hOutputRead, NULL, 0, NULL, &cbAvail, NULL))
    {
        if (cbAvail > 0)
        {
            if (cbAvail > sizeof(szOutput))
                cbAvail = sizeof(szOutput) - 1;
 
            ReadFile(hOutputRead, szOutput, cbAvail, &cbRead, NULL);
        }
    }
    ConvertOutput(szOutput);
 
    GetExitCodeProcess(pi.hProcess, &dwExitCode);
    ok(dwExitCode == pEntry->ret, "Line %d: dwExitCode was 0x%lx\n", pEntry->lineno, dwExitCode);
 
    if (StrCmpNIA(pEntry->output, szOutput, strlen(pEntry->output)) != 0)
    {
        ok(FALSE, "Line %d: Output was wrong\n", pEntry->lineno);
        printf("---FROM HERE\n");
        printf("%s\n", szOutput);
        printf("---UP TO HERE\n");
    }
    else
    {
        ok_int(TRUE, TRUE);
    }
 
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
 
    CloseHandle(hOutputRead);
    if (si.hStdInput != GetStdHandle(STD_INPUT_HANDLE))
        CloseHandle(si.hStdInput);
    if (si.hStdOutput != GetStdHandle(STD_OUTPUT_HANDLE))
        CloseHandle(si.hStdOutput);
    if (si.hStdError != GetStdHandle(STD_ERROR_HANDLE))
        CloseHandle(si.hStdError);
 
    DeleteFileA(FILE1);
    DeleteFileA(FILE2);
}

Referenced by START_TEST().

PrepareForRedirect()

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

static

Definition at line 417 of file fc.c.

{
    SECURITY_ATTRIBUTES sa;
    HANDLE hInputRead = NULL, hInputWriteTmp = NULL;
    HANDLE hOutputReadTmp = NULL, hOutputWrite = NULL;
    HANDLE hErrorReadTmp = NULL, hErrorWrite = NULL;
 
    sa.nLength = sizeof(sa);
    sa.lpSecurityDescriptor = NULL;
    sa.bInheritHandle = TRUE;
 
    if (phInputWrite)
    {
        if (CreatePipe(&hInputRead, &hInputWriteTmp, &sa, 0))
        {
            if (!DoDuplicateHandle(hInputWriteTmp, phInputWrite, FALSE))
                return FALSE;
            CloseHandle(hInputWriteTmp);
        }
        else
            goto failure;
    }
 
    if (phOutputRead)
    {
        if (CreatePipe(&hOutputReadTmp, &hOutputWrite, &sa, 0))
        {
            if (!DoDuplicateHandle(hOutputReadTmp, phOutputRead, FALSE))
                return FALSE;
            CloseHandle(hOutputReadTmp);
        }
        else
            goto failure;
    }
 
    if (phOutputRead && phOutputRead == phErrorRead)
    {
        if (!DoDuplicateHandle(hOutputWrite, &hErrorWrite, TRUE))
            return FALSE;
    }
    else if (phErrorRead)
    {
        if (CreatePipe(&hErrorReadTmp, &hErrorWrite, &sa, 0))
        {
            if (!DoDuplicateHandle(hErrorReadTmp, phErrorRead, FALSE))
                return FALSE;
            CloseHandle(hErrorReadTmp);
        }
        else
            goto failure;
    }
 
    if (phInputWrite)
    {
        psi->hStdInput = hInputRead;
        psi->dwFlags |= STARTF_USESTDHANDLES;
    }
    if (phOutputRead)
    {
        psi->hStdOutput = hOutputWrite;
        psi->dwFlags |= STARTF_USESTDHANDLES;
    }
    if (phErrorRead)
    {
        psi->hStdOutput = hErrorWrite;
        psi->dwFlags |= STARTF_USESTDHANDLES;
    }
    return TRUE;
 
failure:
    CloseHandle(hInputRead);
    CloseHandle(hInputWriteTmp);
    CloseHandle(hOutputReadTmp);
    CloseHandle(hOutputWrite);
    CloseHandle(hErrorReadTmp);
    CloseHandle(hErrorWrite);
    return FALSE;
}

Referenced by DoTestEntry().

START_TEST()

START_TEST

(

fc

)

Definition at line 603 of file fc.c.

{
    UINT i;
    UINT uOldCP = GetConsoleCP(), uOldOutputCP = GetConsoleOutputCP();
    SetConsoleCP(ENGLISH_CP);
    SetConsoleOutputCP(ENGLISH_CP);
 
    for (i = 0; i < _countof(s_entries); ++i)
    {
        DoTestEntry(&s_entries[i]);
    }
 
    SetConsoleCP(uOldCP);
    SetConsoleOutputCP(uOldOutputCP);
}

Variable Documentation

s_entries

const TEST_ENTRY s_entries[]

static

Definition at line 33 of file fc.c.

Referenced by START_TEST().