"{ Package: 'stx:goodies/regression' }"

"{ NameSpace: RegressionTests }"

TestCase subclass:#ExternalInterfaceTests
	instanceVariableNames:''
	classVariableNames:''
	poolDictionaries:''
	category:'tests-Regression'
!

!ExternalInterfaceTests class methodsFor:'documentation'!

documentation
"
    documentation to be added.

    [author:]
	cg (cg@FUSI)

    [instance variables:]

    [class variables:]

    [see also:]

"
!

history
    "Created: / 23-04-2006 / 08:13:27 / cg"
! !

!ExternalInterfaceTests methodsFor:'procedures'!

CreateProcess: imageName commandLine: commandLine pSecurity: pSecurity tSecurity: tSecurity inheritHandles: inheritHandles creationFlags: creationFlags environment: environment currentDirectoryName: currentDirectoryName startupInfo: startupInfo processInfo: processInfo
    "Create a new process running in a separate address space. n.b., we use CreateProcessA
    (the ANSI version) rather than CreateProcessW (the UNICODE/wide version) as we want the
    daemon, vworad, to receive its command line arguments as ANSI strings not wide strings."

    <C: BOOL CreateProcessA(
	    LPCTSR imageName,
	    LPCTSTR commandLine,
	    struct SECURITY_ATTRIBUTES *pSecurity,
	    struct SECURITY_ATTRIBUTES *tSecurity,
	    BOOL inheritHandles,
	    DWORD creationFlags,
	    LPVOID environment,
	    LPTSTR currentDirectoryName,
	    struct STARTUPINFO *startupInfo,
	    struct PROCESS_INFORMATION *processInfo)>

"
self new
 CreateProcess: 'foo' commandLine: 'foo bla' pSecurity: nil tSecurity: nil inheritHandles: false
 creationFlags: 0 environment: nil currentDirectoryName: 'baz' startupInfo: nil processInfo: nil
"
!

TerminateProcess: hProcess exitCode: dwExitCode
	"Kill the specified process."

	self primTerminateProcess: hProcess exitCode: 1234
!

closeHandle: aHandle
	"Close an OS Handle decrementing it's use count."

	<C: int CloseHandle(HANDLE aHandle)>
!

primTerminateProcess: hProcess exitCode: dwExitCode
	"Kill the specified process."

	<C: BOOL TerminateProcess(HANDLE hProcess, DWORD dwExitCode)>
!

setCurrentDirectory: pathName
	"Set the current working directory."

	<C: BOOL _wincall SetCurrentDirectoryA(LPCTSTR pathName)>
	^self externalAccessFailedWith: _errorCode
! !

!ExternalInterfaceTests methodsFor:'structs'!

PROCESS_INFORMATION
	"Describes a created process and its main thread."

	<C: struct PROCESS_INFORMATION {
			HANDLE hProcess;
			HANDLE hThread;
			DWORD dwProcessId;
			DWORD dwThreadId;
		}>
!

SECURITY_ATTRIBUTES
	"Describes security of associated process."

	<C: struct SECURITY_ATTRIBUTES {
			DWORD nLength;
			LPVOID lpSecurityDescriptor;
			BOOL bInheritHandle;
		}>
!

STARTUPINFO
	"Describes how we want the process to be started."

	<C: struct STARTUPINFO {
			DWORD   cb;
			LPSTR           lpReserved;
			LPSTR           lpDesktop;
			LPSTR           lpTitle;
			DWORD           dwX;
			DWORD           dwY;
			DWORD           dwXSize;
			DWORD           dwYSize;
			DWORD           dwXCountChars;
			DWORD           dwYCountChars;
			DWORD           dwFillAttribute;
			DWORD           dwFlags;
			WORD            wShowWindow;
			WORD            cbReserved2;
			LPBYTE          lpReserved2;
			HANDLE  hStdInput;
			HANDLE  hStdOutput;
			HANDLE  hStdError;
		}>
! !

!ExternalInterfaceTests methodsFor:'tests'!

test_call_01
    |fn|

    OperatingSystem isMSWINDOWSlike ifFalse:[
	"This test makes sense only on windows"
	^ self.
    ].

    fn := ExternalLibraryFunction
	    name:'Beep'
	    module:'kernel32.dll'
	    returnType:(CType bool)
	    argumentTypes:(Array with:(CType unsignedLong) with:(CType unsignedLong)).

    fn beCallTypeAPI.
    fn invokeWith:440 with:1.

    "
     self run:#test_call_01
     self new test_call_01
    "
! !

!ExternalInterfaceTests methodsFor:'types'!

BOOL
    <C: typedef long BOOL>

    "
     self new BOOL
    "
!

BYTE
    <C: typedef unsigned char BYTE>

    "
     self new BYTE
    "
!

DWORD
    <C: typedef unsigned long DWORD>

    "
       self new DWORD
    "
!

HANDLE
    <C: typedef void * HANDLE>

    "
     self new HANDLE
    "
!

LPBYTE
    <C: typedef BYTE *LPBYTE>

    "
     self new LPBYTE
    "
!

LPCTSR
    <C: typedef void * LPCTSR>

    "
     self new LPCTSR
    "
!

LPCTSTR
    <C: typedef void * LPCTSTR>

    "
     self new LPCTSTR
    "
!

LPSIZE
    <C: typedef SIZE * LPSIZE>

    "
     self new LPSIZE
    "
!

LPSTR
    <C: typedef char * LPSTR>

    "
     self new LPSTR
    "
!

LPTSTR
    <C: typedef void * LPTSTR>

    "
     self new LPTSTR
    "
!

LPVOID
    <C: typedef void * LPVOID>

    "
     self new LPVOID
    "
!

SIZE
    <C: typedef struct {
	    long cx;
	    long cy;
    } SIZE>

    "
     self new SIZE
    "
!

WORD
    <C: typedef unsigned short WORD>

    "
     self new WORD
    "
!

fooType
   <C: struct foo {
	long l1;
	float f1;
   }>

    "
     self new fooType
    "
!

var1
    <C: #define var1 1234>

    "
     self new var1
    "
!

var2
    <C: #define var1 "hello">

    "
     self new var2
    "
!

var3
    <C: #define var1 1.2345>

    "
     self new var3
    "
! !

!ExternalInterfaceTests class methodsFor:'documentation'!

version
    ^ '$Header$'
! !