createnamedata.cpp

通信测试应用中

///////////////////////////////////////////////////////////////////////////////
//
// Create data for loadrunner scripts
// Rivulet 2005.4.6
//
///////////////////////////////////////////////////////////////////////////////
#define _WIN32_DCOM		// for using CoInitializeEx()

#include <windowsx.h>
#include <windows.h>
#include <TCHAR.H>
#include <shlobj.h>
#include <objbase.h>
#include <stdio.h>
#include "resource.h"

#define RIVULET_ERROR_SUCCESS				0
#define RIVULET_ERROR_CREATEFILEFAIL	    1
#define RIVULET_ERROR_ALLOCMEMFAIL			2
#define RIVULET_ERROR_GETTIMEFAIL			3
#define RIVULET_ERROR_RESELECT				4

// Set the CREATE and CLEAR button's states
#define SetBtnState(hDlg, wParam, lParam, offset) \
	if (HIWORD(wParam) == EN_CHANGE) \
	{ \
		BOOL bFlag = GetWindowTextLength((HWND)(lParam)) ? TRUE : FALSE; \
		if (bFlag) \
			byte |= (1 << (offset)); \
		else \
			byte &= ~(1 << (offset)); \
		EnableWindow(GetDlgItem((hDlg), IDC_CLEAR), byte); \
		EnableWindow(GetDlgItem((hDlg), IDOK), !(byte ^ 7)); \
	}


///////////////////////////////////////////////////////////////////////////////


HINSTANCE g_hInstance;	// global variable


///////////////////////////////////////////////////////////////////////////////


// The core codes of CreateUniqueData() function which implements the creations of 
// unique data.
int DoCreateUniqueData(HANDLE hFile, int iLines, LPCTSTR szFileName)
{
	int i = 0, j;
	DWORD dwLength;	// bytes of one line data
	DWORD dwBytesWritten;
	TCHAR szTemp[1024];
	LPTSTR lpszBuffer = NULL;
	FILETIME ftUTC;
	SYSTEMTIME stUTC, stLocal;

	ZeroMemory(szTemp, sizeof(szTemp));

	// Firstly, write the file name to the file at the first line
	lstrcpy(szTemp, szFileName);
	lstrcat(szTemp, TEXT("\r\n"));
	WriteFile(hFile, szTemp, lstrlen(szTemp) * sizeof(TCHAR),
		&dwBytesWritten, NULL);

	// Get the system time in the UTC format, then translate it into local time
	GetSystemTimeAsFileTime(&ftUTC);
	if (FileTimeToSystemTime(&ftUTC, &stUTC) == 0)
		return RIVULET_ERROR_GETTIMEFAIL;
	SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);

	// Calculate how long one line data is
	dwLength = wsprintf(szTemp, TEXT("GXLU - %02d/%02d/%04d %02d:%02d:%02d:%03d - %5d\r\n"),
		stLocal.wDay, stLocal.wMonth, stLocal.wYear, stLocal.wHour, stLocal.wMinute,
		stLocal.wSecond, stLocal.wMilliseconds, i);

	dwLength += 1;//我添加的，应该含有一个结束符的长度
	//引用MSDN：If the function succeeds, 
	//the return value is the number of characters stored in the output buffer, 
	//	not counting the terminating null character. 

	// If the parameter "iLines" exceeds 1000, divide into several "1000"s to write into file
	if (iLines <= 1000)
	{
		// Allocate memory to store data
		lpszBuffer = (LPTSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 
			(dwLength * iLines) * sizeof(TCHAR));
		if (lpszBuffer == NULL)
			return RIVULET_ERROR_ALLOCMEMFAIL;

		for (i = 0; i < iLines; i++)
		{
			wsprintf(lpszBuffer + i * dwLength, 
				TEXT("GXLU - %02d/%02d/%04d %02d:%02d:%02d:%03d - %5d\r\n"),
				stLocal.wDay, stLocal.wMonth, stLocal.wYear, stLocal.wHour, 
				stLocal.wMinute, stLocal.wSecond, stLocal.wMilliseconds, i);
		}
		WriteFile(hFile, lpszBuffer, (dwLength * iLines) * sizeof(TCHAR),
			&dwBytesWritten, NULL);

		HeapFree(GetProcessHeap(), 0, (LPVOID)lpszBuffer);	// Free the allocated memory
		lpszBuffer = NULL;
	}
	else
	{
		lpszBuffer = (LPTSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 
			dwLength * 1000 * sizeof(TCHAR));
		if (lpszBuffer == NULL)
			return RIVULET_ERROR_ALLOCMEMFAIL;

		for (j = 0; j < iLines / 1000; j++)
		{
			for (i = 0; i < 1000; i++)
			{
				wsprintf(lpszBuffer + i * dwLength, 
					TEXT("GXLU - %02d/%02d/%04d %02d:%02d:%02d:%03d - %5d\r\n"),
					stLocal.wDay, stLocal.wMonth, stLocal.wYear, stLocal.wHour, 
					stLocal.wMinute, stLocal.wSecond, stLocal.wMilliseconds, i + j * 1000);
			}
			WriteFile(hFile, lpszBuffer, dwLength * 1000 * sizeof(TCHAR),
				&dwBytesWritten, NULL);
		}

		int k = iLines - j * 1000;
		for (i = 0; i < k; i++)
		{
			wsprintf(lpszBuffer + i * dwLength,
				TEXT("GXLU - %02d/%02d/%04d %02d:%02d:%02d:%03d - %5d\r\n"),
				stLocal.wDay, stLocal.wMonth, stLocal.wYear, stLocal.wHour, 
				stLocal.wMinute, stLocal.wSecond, stLocal.wMilliseconds, i + j * 1000);
		}
		WriteFile(hFile, lpszBuffer, dwLength * i * sizeof(TCHAR), &dwBytesWritten, NULL);

		HeapFree(GetProcessHeap(), 0, (LPVOID)lpszBuffer);	
		lpszBuffer = NULL;
	}
	return RIVULET_ERROR_SUCCESS;
}


///////////////////////////////////////////////////////////////////////////////


// Create the unique data. Every line data is composed of the current time
// and the value of "i"
VOID CreateUniqueData(HWND hwnd, LPCTSTR lpszFileName, LPCTSTR lpszPath, int iLines)
{
	TCHAR szPathName[MAX_PATH];
	TCHAR szTemp[1024];
	HANDLE hFile;

	ZeroMemory(szPathName, sizeof(szPathName));
	ZeroMemory(szTemp, sizeof(szTemp));

	lstrcpy(szPathName, lpszPath);
	lstrcat(szPathName, lpszFileName);
	lstrcat(szPathName, TEXT(".dat"));

	hFile = CreateFile(szPathName, GENERIC_WRITE, 0, NULL, 
		CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hFile == INVALID_HANDLE_VALUE)
	{
		wsprintf(szTemp, TEXT("The file \" %s \" is already exists.\n")
			     TEXT("Do you want to overwrite it?"), szPathName);
		if (MessageBox(hwnd, szTemp, TEXT("Warning"), MB_YESNO | MB_ICONWARNING)
				== IDYES)
		{
			if ((hFile = CreateFile(szPathName, 
									GENERIC_WRITE, 0, NULL, 
									CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)) 
					== INVALID_HANDLE_VALUE)
			{
				MessageBox(hwnd, 
						   TEXT("Initialize file error.\nTrys again.")
						   TEXT("If you still have problems, please contact Xi Minggao."),
						   TEXT("Error"),
						   MB_OK | MB_ICONERROR);
				return;
			}
		}
		else
		{
			SetFocus(GetDlgItem(hwnd, IDC_FILENAME));
			return;
		}
	}

	int iReturnValue = DoCreateUniqueData(hFile, iLines, lpszFileName);
	if (iReturnValue == RIVULET_ERROR_GETTIMEFAIL)
		MessageBox(hwnd, 
				   TEXT("Get current time error.\nTrys again. ")
				   TEXT("If you still have problems, please contact Xi Minggao."),
				   TEXT("Error"),
				   MB_OK | MB_ICONERROR);
	else if (iReturnValue == RIVULET_ERROR_ALLOCMEMFAIL)
		MessageBox(hwnd, 
				   TEXT("Allocate memory error.\nTrys again.")
				   TEXT("If you still have problems, please contact Xi Minggao."),
				   TEXT("Error"),
				   MB_OK | MB_ICONERROR);
	else 
		MessageBox(hwnd, 
				   TEXT("Congratulations. Create successfully."),
				   TEXT("Success"),
				   MB_OK | MB_ICONINFORMATION);

	CloseHandle(hFile);
}


///////////////////////////////////////////////////////////////////////////////


VOID SelectPath(HWND hwnd)
{
	BROWSEINFO bi = { 0 };
	LPMALLOC pMlc;
	TCHAR szDisplayName[MAX_PATH];
	TCHAR szPath[MAX_PATH];

	ZeroMemory(szDisplayName, sizeof(szDisplayName));	// Clear memory
	ZeroMemory(szPath, sizeof(szPath));

	if (SHGetMalloc(&pMlc) == E_FAIL)
	{
		MessageBox(hwnd, 
			TEXT("Call to SHGetMalloc() failed."),
			TEXT("Error"),
			MB_OK | MB_ICONERROR);
		return;
	}

	bi.hwndOwner = hwnd;
	bi.pidlRoot = NULL;
	bi.pszDisplayName = szDisplayName;
	bi.lpszTitle = TEXT("Please select the path to create the file:");
	bi.ulFlags = BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS;

	LPITEMIDLIST pIdl = SHBrowseForFolder(&bi);
	if (pIdl == NULL)
	{		
		pMlc->Release();
		return;
	}
	
	SHGetPathFromIDList(pIdl, szPath);
	if (szPath[lstrlen(szPath) - 1] != TEXT('\\'))
		lstrcat(szPath, TEXT("\\"));
	SetWindowText(GetDlgItem(hwnd, IDC_PATH), szPath);
//	GlobalFreePtr(pIdl);
	pMlc->Free(pIdl);
	pMlc->Release();
}


///////////////////////////////////////////////////////////////////////////////


INT_PTR CALLBACK AboutDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uMsg)
	{
	case WM_COMMAND:
		switch(LOWORD(wParam))
		{
		case IDCANCEL:
			EndDialog(hDlg, IDCANCEL);
			break;
		}
		return TRUE;
	}
	return FALSE;
}


///////////////////////////////////////////////////////////////////////////////


INT_PTR CALLBACK MainDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{	
	static int iLines;
	TCHAR szFileName[80];
	TCHAR szPath[MAX_PATH];
	TCHAR szLines[20];
	static BYTE byte = 0x00;	// Denote the CREATE and CLEAR button's state, 
								// if byte == 0x07, the CREATE button is enabled
								// if any one bit of "byte" is 1, the CLEAR button is enabled
	switch (uMsg)
	{
	case WM_INITDIALOG:
		SetFocus(GetDlgItem(hDlg, IDC_FILENAME));		
		return FALSE;

	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDC_FILENAME:
			SetBtnState(hDlg, wParam, lParam, 0);
			break;

		case IDC_LINES:
			SetBtnState(hDlg, wParam, lParam, 1);			
			break;

		case IDC_PATH:
			SetBtnState(hDlg, wParam, lParam, 2);
			break;

		case IDC_SELECTPATH:
			SelectPath(hDlg);
			break;

		case IDOK:
			ZeroMemory(szFileName, sizeof(szFileName));
			ZeroMemory(szPath, sizeof(szPath));
			ZeroMemory(szLines, sizeof(szLines));
			GetWindowText(GetDlgItem(hDlg, IDC_FILENAME), szFileName, 80);
			GetWindowText(GetDlgItem(hDlg, IDC_PATH), szPath, MAX_PATH);
			if (GetWindowText(GetDlgItem(hDlg, IDC_LINES), szLines, 20) != 0)
				iLines = _ttoi(szLines);
			CreateUniqueData(hDlg, szFileName, szPath, iLines);
			break;

		case IDC_CLEAR:
			SetWindowText(GetDlgItem(hDlg, IDC_FILENAME), TEXT(""));
			SetWindowText(GetDlgItem(hDlg, IDC_LINES), TEXT(""));
			SetWindowText(GetDlgItem(hDlg, IDC_PATH), TEXT(""));
			SetFocus(GetDlgItem(hDlg, IDC_FILENAME));
			break;

		case IDC_ABOUT:
			DialogBox(g_hInstance, MAKEINTRESOURCE(IDD_ABOUTDLG), hDlg, AboutDlgProc);
			break;

		case IDCANCEL:
			EndDialog(hDlg, IDCANCEL);			
			break;
		}
		return TRUE;
	}
	return FALSE;
}


///////////////////////////////////////////////////////////////////////////////


int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
				   LPTSTR lpCmdLine, int nShowCmd)
{
	LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPICON));
	if (CoInitializeEx(NULL, COINIT_APARTMENTTHREADED) == RPC_E_CHANGED_MODE)
	{
		MessageBox(NULL, 
			TEXT("Call to CoInitialize() failed because of the specified concurrency mode."),
			TEXT("Error"),
			MB_OK | MB_ICONERROR);
	}

	g_hInstance = hInstance;

	DialogBox(hInstance, MAKEINTRESOURCE(IDD_MAINDLG), NULL, MainDlgProc);

	CoUninitialize();	// Close the COM library
	return 0;
}