[ros-diffs] [sedwards] 17137: added kernel32 wine tests

added kernel32 wine tests
Added: trunk/reactos/regtests/winetests/kernel32/
Added: trunk/reactos/regtests/winetests/kernel32/alloc.c
Added: trunk/reactos/regtests/winetests/kernel32/atom.c
Added: trunk/reactos/regtests/winetests/kernel32/change.c
Added: trunk/reactos/regtests/winetests/kernel32/codepage.c
Added: trunk/reactos/regtests/winetests/kernel32/comm.c
Added: trunk/reactos/regtests/winetests/kernel32/console.c
Added: trunk/reactos/regtests/winetests/kernel32/directory.c
Added: trunk/reactos/regtests/winetests/kernel32/drive.c
Added: trunk/reactos/regtests/winetests/kernel32/environ.c
Added: trunk/reactos/regtests/winetests/kernel32/file.c
Added: trunk/reactos/regtests/winetests/kernel32/format_msg.c
Added: trunk/reactos/regtests/winetests/kernel32/heap.c
Added: trunk/reactos/regtests/winetests/kernel32/kernel32_test.xml
Added: trunk/reactos/regtests/winetests/kernel32/locale.c
Added: trunk/reactos/regtests/winetests/kernel32/mailslot.c
Added: trunk/reactos/regtests/winetests/kernel32/module.c
Added: trunk/reactos/regtests/winetests/kernel32/path.c
Added: trunk/reactos/regtests/winetests/kernel32/pipe.c
Added: trunk/reactos/regtests/winetests/kernel32/process.c
Added: trunk/reactos/regtests/winetests/kernel32/profile.c
Added: trunk/reactos/regtests/winetests/kernel32/sync.c
Added: trunk/reactos/regtests/winetests/kernel32/testlist.c
Added: trunk/reactos/regtests/winetests/kernel32/thread.c
Added: trunk/reactos/regtests/winetests/kernel32/time.c
Added: trunk/reactos/regtests/winetests/kernel32/timer.c
Added: trunk/reactos/regtests/winetests/kernel32/virtual.c
  _____  

Added: trunk/reactos/regtests/winetests/kernel32/alloc.c
--- trunk/reactos/regtests/winetests/kernel32/alloc.c	2005-08-07
03:00:44 UTC (rev 17136)
+++ trunk/reactos/regtests/winetests/kernel32/alloc.c	2005-08-07
03:14:17 UTC (rev 17137)
@@ -0,0 +1,406 @@

+/*
+ * Unit test suite for memory allocation functions.
+ *
+ * Copyright 2002 Geoffrey Hausheer
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
USA
+ */
+
+#include <stdarg.h>
+
+#include "wine/test.h"
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+
+
+ /* The following functions don't have tests, because either I don't
know how
+   to test them, or they are WinNT only, or require multiple threads.
+   Since the last two issues shouldn't really stop the tests from being
+   written, assume for now that it is all due to the first case
+       HeapCompact
+       HeapLock
+       HeapQueryInformation
+       HeapSetInformation
+       HeapUnlock
+       HeapValidate
+       HeapWalk
+*/
+/* In addition, these features aren't being tested
+       HEAP_NO_SERIALIZE
+       HEAP_GENERATE_EXCEPTIONS
+       STATUS_ACCESS_VIOLATION (error code from HeapAlloc)
+*/
+
+static void test_Heap(void)
+{
+    SYSTEM_INFO sysInfo;
+    ULONG memchunk;
+    HANDLE heap;
+    LPVOID mem1,mem1a,mem3;
+    UCHAR *mem2,*mem2a;
+    UINT error,i;
+    DWORD dwSize;
+
+/* Retrieve the page size for this system */
+    sysInfo.dwPageSize=0;
+    GetSystemInfo(&sysInfo);
+    ok(sysInfo.dwPageSize>0,"GetSystemInfo should return a valid page
size\n");
+
+/* Create a Heap with a minimum and maximum size */
+/* Note that Windows and Wine seem to behave a bit differently with
respect
+   to memory allocation.  In Windows, you can't access all the memory
+   specified in the heap (due to overhead), so choosing a reasonable
maximum
+   size for the heap was done mostly by trial-and-error on Win2k.  It
may need
+   more tweaking for otherWindows variants.
+*/
+    memchunk=10*sysInfo.dwPageSize;
+    heap=HeapCreate(0,2*memchunk,5*memchunk);
+
+/* Check that HeapCreate allocated the right amount of ram */
+    todo_wine {
+    /* Today HeapCreate seems to return a memory block larger than
specified.
+       MSDN says the maximum heap size should be dwMaximumSize rounded
up to the
+       nearest page boundary
+    */
+      mem1=HeapAlloc(heap,0,5*memchunk+1);
+      ok(mem1==NULL,"HeapCreate allocated more Ram than it should
have\n");
+      HeapFree(heap,0,mem1);
+    }
+
+/* Check that a normal alloc works */
+    mem1=HeapAlloc(heap,0,memchunk);
+    ok(mem1!=NULL,"HeapAlloc failed\n");
+    if(mem1) {
+      ok(HeapSize(heap,0,mem1)>=memchunk, "HeapAlloc should return a
big enough memory block\n");
+    }
+
+/* Check that a 'zeroing' alloc works */
+    mem2=HeapAlloc(heap,HEAP_ZERO_MEMORY,memchunk);
+    ok(mem2!=NULL,"HeapAlloc failed\n");
+    if(mem2) {
+      ok(HeapSize(heap,0,mem2)>=memchunk,"HeapAlloc should return a big
enough memory block\n");
+      error=0;
+      for(i=0;i<memchunk;i++) {
+        if(mem2[i]!=0) {
+          error=1;
+        }
+      }
+      ok(!error,"HeapAlloc should have zeroed out it's allocated
memory\n");
+    }
+
+/* Check that HeapAlloc returns NULL when requested way too much memory
*/
+    mem3=HeapAlloc(heap,0,5*memchunk);
+    ok(mem3==NULL,"HeapAlloc should return NULL\n");
+    if(mem3) {
+      ok(HeapFree(heap,0,mem3),"HeapFree didn't pass successfully\n");
+    }
+
+/* Check that HeapRealloc works */
+
mem2a=HeapReAlloc(heap,HEAP_ZERO_MEMORY,mem2,memchunk+5*sysInfo.dwPageSi
ze);
+    ok(mem2a!=NULL,"HeapReAlloc failed\n");
+    if(mem2a) {
+
ok(HeapSize(heap,0,mem2a)>=memchunk+5*sysInfo.dwPageSize,"HeapReAlloc
failed\n");
+      error=0;
+      for(i=0;i<5*sysInfo.dwPageSize;i++) {
+        if(mem2a[memchunk+i]!=0) {
+          error=1;
+        }
+      }
+      ok(!error,"HeapReAlloc should have zeroed out it's allocated
memory\n");
+    }
+
+/* Check that HeapRealloc honours HEAP_REALLOC_IN_PLACE_ONLY */
+    error=0;
+
mem1a=HeapReAlloc(heap,HEAP_REALLOC_IN_PLACE_ONLY,mem1,memchunk+sysInfo.
dwPageSize);
+    if(mem1a!=NULL) {
+      if(mem1a!=mem1) {
+        error=1;
+      }
+    }
+    ok(mem1a==NULL || error==0,"HeapReAlloc didn't honour
HEAP_REALLOC_IN_PLACE_ONLY\n");
+
+/* Check that HeapFree works correctly */
+   if(mem1a) {
+     ok(HeapFree(heap,0,mem1a),"HeapFree failed\n");
+   } else {
+     ok(HeapFree(heap,0,mem1),"HeapFree failed\n");
+   }
+   if(mem2a) {
+     ok(HeapFree(heap,0,mem2a),"HeapFree failed\n");
+   } else {
+     ok(HeapFree(heap,0,mem2),"HeapFree failed\n");
+   }
+
+   /* 0-length buffer */
+   mem1 = HeapAlloc(heap, 0, 0);
+   ok(mem1 != NULL, "Reserved memory\n");
+
+   dwSize = HeapSize(heap, 0, mem1);
+   /* should work with 0-length buffer */
+   ok((dwSize >= 0) && (dwSize < 0xFFFFFFFF),
+      "The size of the 0-length buffer\n");
+   ok(HeapFree(heap, 0, mem1), "Freed the 0-length buffer\n");
+
+/* Check that HeapDestry works */
+   ok(HeapDestroy(heap),"HeapDestroy failed\n");
+}
+
+/* The following functions don't have tests, because either I don't
know how
+   to test them, or they are WinNT only, or require multiple threads.
+   Since the last two issues shouldn't really stop the tests from being
+   written, assume for now that it is all due to the first case
+       GlobalFlags
+       GlobalMemoryStatus
+       GlobalMemoryStatusEx
+*/
+/* In addition, these features aren't being tested
+       GMEM_DISCADABLE
+       GMEM_NOCOMPACT
+*/
+static void test_Global(void)
+{
+    ULONG memchunk;
+    HGLOBAL mem1,mem2,mem2a,mem2b;
+    UCHAR *mem2ptr;
+    UINT error,i;
+    memchunk=100000;
+
+    SetLastError(NO_ERROR);
+/* Check that a normal alloc works */
+    mem1=GlobalAlloc(0,memchunk);
+    ok(mem1!=NULL,"GlobalAlloc failed\n");
+    if(mem1) {
+      ok(GlobalSize(mem1)>=memchunk, "GlobalAlloc should return a big
enough memory block\n");
+    }
+
+/* Check that a 'zeroing' alloc works */
+    mem2=GlobalAlloc(GMEM_ZEROINIT,memchunk);
+    ok(mem2!=NULL,"GlobalAlloc failed: error=%ld\n",GetLastError());
+    if(mem2) {
+      ok(GlobalSize(mem2)>=memchunk,"GlobalAlloc should return a big
enough memory block\n");
+      mem2ptr=GlobalLock(mem2);
+      ok(mem2ptr==mem2,"GlobalLock should have returned the same memory
as was allocated\n");
+      if(mem2ptr) {
+        error=0;
+        for(i=0;i<memchunk;i++) {
+          if(mem2ptr[i]!=0) {
+            error=1;
+          }
+        }
+        ok(!error,"GlobalAlloc should have zeroed out it's allocated
memory\n");
+      }
+   }
+/* Check that GlobalReAlloc works */
+/* Check that we can change GMEM_FIXED to GMEM_MOVEABLE */
+    mem2a=GlobalReAlloc(mem2,0,GMEM_MODIFY | GMEM_MOVEABLE);
+    if(mem2a!=NULL) {
+      mem2=mem2a;
+      mem2ptr=GlobalLock(mem2a);
+      ok(mem2ptr!=NULL &&
!GlobalUnlock(mem2a)&&GetLastError()==NO_ERROR,
+         "Converting from FIXED to MOVEABLE didn't REALLY work\n");
+    }
+
+/* Check that ReAllocing memory works as expected */
+    mem2a=GlobalReAlloc(mem2,2*memchunk,GMEM_MOVEABLE | GMEM_ZEROINIT);
+    ok(mem2a!=NULL,"GlobalReAlloc failed\n");
+    if(mem2a) {
+      ok(GlobalSize(mem2a)>=2*memchunk,"GlobalReAlloc failed\n");
+      mem2ptr=GlobalLock(mem2a);
+      ok(mem2ptr!=NULL,"GlobalLock Failed\n");
+      if(mem2ptr) {
+        error=0;
+        for(i=0;i<memchunk;i++) {
+          if(mem2ptr[memchunk+i]!=0) {
+            error=1;
+          }
+        }
+        ok(!error,"GlobalReAlloc should have zeroed out it's allocated
memory\n");
+
+/* Check that GlobalHandle works */
+        mem2b=GlobalHandle(mem2ptr);
+        ok(mem2b==mem2a,"GlobalHandle didn't return the correct memory
handle\n");
+
+/* Check that we can't discard locked memory */
+        mem2b=GlobalDiscard(mem2a);
+        if(mem2b==NULL) {
+          ok(!GlobalUnlock(mem2a) &&
GetLastError()==NO_ERROR,"GlobalUnlock Failed\n");
+        }
+      }
+    }
+    if(mem1) {
+      ok(GlobalFree(mem1)==NULL,"GlobalFree failed\n");
+    }
+    if(mem2a) {
+      ok(GlobalFree(mem2a)==NULL,"GlobalFree failed\n");
+    } else {
+      ok(GlobalFree(mem2)==NULL,"GlobalFree failed\n");
+    }
+}
+
+
+/* The following functions don't have tests, because either I don't
know how
+   to test them, or they are WinNT only, or require multiple threads.
+   Since the last two issues shouldn't really stop the tests from being
+   written, assume for now that it is all due to the first case
+       LocalDiscard
+       LocalFlags
+*/
+/* In addition, these features aren't being tested
+       LMEM_DISCADABLE
+       LMEM_NOCOMPACT
+*/
+static void test_Local(void)
+{
+    ULONG memchunk;
+    HLOCAL mem1,mem2,mem2a,mem2b;
+    UCHAR *mem2ptr;
+    UINT error,i;
+    memchunk=100000;
+
+/* Check that a normal alloc works */
+    mem1=LocalAlloc(0,memchunk);
+    ok(mem1!=NULL,"LocalAlloc failed: error=%ld\n",GetLastError());
+    if(mem1) {
+      ok(LocalSize(mem1)>=memchunk, "LocalAlloc should return a big
enough memory block\n");
+    }
+
+/* Check that a 'zeroing' and lock alloc works */
+    mem2=LocalAlloc(LMEM_ZEROINIT|LMEM_MOVEABLE,memchunk);
+    ok(mem2!=NULL,"LocalAlloc failed: error=%ld\n",GetLastError());
+    if(mem2) {
+      ok(LocalSize(mem2)>=memchunk,"LocalAlloc should return a big
enough memory block\n");
+      mem2ptr=LocalLock(mem2);
+      ok(mem2ptr!=NULL,"LocalLock: error=%ld\n",GetLastError());
+      if(mem2ptr) {
+        error=0;
+        for(i=0;i<memchunk;i++) {
+          if(mem2ptr[i]!=0) {
+            error=1;
+          }
+        }
+        ok(!error,"LocalAlloc should have zeroed out it's allocated
memory\n");
+        SetLastError(0);
+        error=LocalUnlock(mem2);
+        ok(error==0 && GetLastError()==NO_ERROR,
+           "LocalUnlock Failed: rc=%d err=%ld\n",error,GetLastError());
+      }
+    }
+   mem2a=LocalFree(mem2);
+   ok(mem2a==NULL, "LocalFree failed: %p\n",mem2a);
+
+/* Reallocate mem2 as moveable memory */
+   mem2=LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,memchunk);
+   ok(mem2!=NULL, "LocalAlloc failed to create moveable memory,
error=%ld\n",GetLastError());
+
+/* Check that ReAllocing memory works as expected */
+    mem2a=LocalReAlloc(mem2,2*memchunk,LMEM_MOVEABLE | LMEM_ZEROINIT);
+    ok(mem2a!=NULL,"LocalReAlloc failed, error=%ld\n",GetLastError());
+    if(mem2a) {
+      ok(LocalSize(mem2a)>=2*memchunk,"LocalReAlloc failed\n");
+      mem2ptr=LocalLock(mem2a);
+      ok(mem2ptr!=NULL,"LocalLock Failed\n");
+      if(mem2ptr) {
+        error=0;
+        for(i=0;i<memchunk;i++) {
+          if(mem2ptr[memchunk+i]!=0) {
+            error=1;
+          }
+        }
+        ok(!error,"LocalReAlloc should have zeroed out it's allocated
memory\n");
+/* Check that LocalHandle works */
+        mem2b=LocalHandle(mem2ptr);
+        ok(mem2b==mem2a,"LocalHandle didn't return the correct memory
handle\n");
+/* Check that we can't discard locked memory */
+        mem2b=LocalDiscard(mem2a);
+        ok(mem2b==NULL,"Discarded memory we shouldn't have\n");
+        SetLastError(NO_ERROR);
+        ok(!LocalUnlock(mem2a) && GetLastError()==NO_ERROR,
"LocalUnlock Failed\n");
+      }
+    }
+    if(mem1) {
+      ok(LocalFree(mem1)==NULL,"LocalFree failed\n");
+    }
+    if(mem2a) {
+      ok(LocalFree(mem2a)==NULL,"LocalFree failed\n");
+    } else {
+      ok(LocalFree(mem2)==NULL,"LocalFree failed\n");
+    }
+}
+
+/* The Virtual* routines are not tested as thoroughly,
+   since I don't really understand how to use them correctly :)
+   The following routines are not tested at all
+      VirtualAllocEx
+      VirtualFreeEx
+      VirtualLock
+      VirtualProtect
+      VirtualProtectEx
+      VirtualQuery
+      VirtualQueryEx
+      VirtualUnlock
+    And the only features (flags) being tested are
+      MEM_COMMIT
+      MEM_RELEASE
+      PAGE_READWRITE
+    Testing the rest requires using exceptions, which I really don't
+    understand well
+*/
+static void test_Virtual(void)
+{
+    SYSTEM_INFO sysInfo;
+    ULONG memchunk;
+    UCHAR *mem1;
+    UINT error,i;
+
+/* Retrieve the page size for this system */
+    sysInfo.dwPageSize=0;
+    GetSystemInfo(&sysInfo);
+    ok(sysInfo.dwPageSize>0,"GetSystemInfo should return a valid page
size\n");
+
+/* Choose a reasonable allocation size */
+    memchunk=10*sysInfo.dwPageSize;
+
+/* Check that a normal alloc works */
+    mem1=VirtualAlloc(NULL,memchunk,MEM_COMMIT,PAGE_READWRITE);
+    ok(mem1!=NULL,"VirtualAlloc failed\n");
+    if(mem1) {
+/* check that memory is initialized to 0 */
+      error=0;
+      for(i=0;i<memchunk;i++) {
+        if(mem1[i]!=0) {
+          error=1;
+        }
+      }
+      ok(!error,"VirtualAlloc did not initialize memory to '0's\n");
+/* Check that we can read/write to memory */
+      error=0;
+      for(i=0;i<memchunk;i+=100) {
+        mem1[i]='a';
+        if(mem1[i]!='a') {
+          error=1;
+        }
+      }
+      ok(!error,"Virtual memory was not writable\n");
+    }
+    ok(VirtualFree(mem1,0,MEM_RELEASE),"VirtualFree failed\n");
+}
+START_TEST(alloc)
+{
+    test_Heap();
+    test_Global();
+    test_Local();
+    test_Virtual();
+}
Property changes on: trunk/reactos/regtests/winetests/kernel32/alloc.c
___________________________________________________________________
Name: svn:executable
   + *
  _____  

Added: trunk/reactos/regtests/winetests/kernel32/atom.c
--- trunk/reactos/regtests/winetests/kernel32/atom.c	2005-08-07
03:00:44 UTC (rev 17136)
+++ trunk/reactos/regtests/winetests/kernel32/atom.c	2005-08-07
03:14:17 UTC (rev 17137)
@@ -0,0 +1,346 @@

+/*
+ * Unit tests for atom functions
+ *
+ * Copyright (c) 2002 Alexandre Julliard
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
USA
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "wine/test.h"
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+
+static const WCHAR foobarW[] =
{'f','o','o','b','a','r',0};
+static const WCHAR FOOBARW[] =
{'F','O','O','B','A','R',0};
+static const WCHAR _foobarW[] =
{'_','f','o','o','b','a','r',0};
+
+static BOOL unicode_OS;
+
+static void test_add_atom(void)
+{
+    ATOM atom, w_atom;
+    int i;
+
+    SetLastError( 0xdeadbeef );
+    atom = GlobalAddAtomA( "foobar" );
+    ok( atom >= 0xc000, "bad atom id %x\n", atom );
+    ok( GetLastError() == 0xdeadbeef, "GlobalAddAtomA set last error\n"
);
+
+    /* Verify that it can be found (or not) appropriately */
+    ok( GlobalFindAtomA( "foobar" ) == atom, "could not find atom
foobar\n" );
+    ok( GlobalFindAtomA( "FOOBAR" ) == atom, "could not find atom
FOOBAR\n" );
+    ok( !GlobalFindAtomA( "_foobar" ), "found _foobar\n" );
+
+    /* Add the same atom, specifying string as unicode; should
+     * find the first one, not add a new one */
+    SetLastError( 0xdeadbeef );
+    w_atom = GlobalAddAtomW( foobarW );
+    if (w_atom && GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+        unicode_OS = TRUE;
+    else
+        trace("WARNING: Unicode atom APIs are not supported on this
platform\n");
+
+    if (unicode_OS)
+    {
+        ok( w_atom == atom, "Unicode atom does not match ASCII\n" );
+        ok( GetLastError() == 0xdeadbeef, "GlobalAddAtomW set last
error\n" );
+    }
+
+    /* Verify that it can be found (or not) appropriately via unicode
name */
+    if (unicode_OS)
+    {
+        ok( GlobalFindAtomW( foobarW ) == atom, "could not find atom
foobar\n" );
+        ok( GlobalFindAtomW( FOOBARW ) == atom, "could not find atom
FOOBAR\n" );
+        ok( !GlobalFindAtomW( _foobarW ), "found _foobar\n" );
+    }
+
+    /* Test integer atoms
+     * (0x0001 .. 0xbfff) should be valid;
+     * (0xc000 .. 0xffff) should be invalid */
+
+    SetLastError( 0xdeadbeef );
+    ok( GlobalAddAtomA(0) == 0 && GetLastError() == 0xdeadbeef,
"succeeded to add atom 0\n" );
+    if (unicode_OS)
+    {
+        SetLastError( 0xdeadbeef );
+        ok( GlobalAddAtomW(0) == 0 && GetLastError() == 0xdeadbeef,
"succeeded to add atom 0\n" );
+    }
+
+    SetLastError( 0xdeadbeef );
+    for (i = 1; i <= 0xbfff; i++)
+    {
+        SetLastError( 0xdeadbeef );
+        ok( GlobalAddAtomA((LPCSTR)i) == i && GetLastError() ==
0xdeadbeef,
+            "failed to add atom %x\n", i );
+        if (unicode_OS)
+        {
+            SetLastError( 0xdeadbeef );
+            ok( GlobalAddAtomW((LPCWSTR)i) == i && GetLastError() ==
0xdeadbeef,
+                "failed to add atom %x\n", i );
+        }
+    }
+
+    for (i = 0xc000; i <= 0xffff; i++)
+    {
+        ok( !GlobalAddAtomA((LPCSTR)i), "succeeded adding %x\n", i );
+        if (unicode_OS)
+            ok( !GlobalAddAtomW((LPCWSTR)i), "succeeded adding %x\n", i
);
+    }
+}
+
+static void test_get_atom_name(void)
+{
+    char buf[10];
+    WCHAR bufW[10];
+    int i;
+    UINT len;
+    static const WCHAR resultW[] =
{'f','o','o','b','a','r',0,'.','.','.'};
+
+    ATOM atom = GlobalAddAtomA( "foobar" );
+
+    /* Get the name of the atom we added above */
+    memset( buf, '.', sizeof(buf) );
+    len = GlobalGetAtomNameA( atom, buf, 10 );
+    ok( len == strlen("foobar"), "bad length %d\n", len );
+    ok( !memcmp( buf, "foobar\0...", 10 ), "bad buffer contents\n"
);
+
+    /* Repeat, unicode-style */
+    if (unicode_OS)
+    {
+        for (i = 0; i < 10; i++) bufW[i] = '.';
+        SetLastError( 0xdeadbeef );
+        len = GlobalGetAtomNameW( atom, bufW, 10 );
+        ok( len && GetLastError() == 0xdeadbeef, "GlobalGetAtomNameW
failed\n" );
+        ok( len == lstrlenW(foobarW), "bad length %d\n", len );
+        ok( !memcmp( bufW, resultW, 10*sizeof(WCHAR) ), "bad buffer
contents\n" );
+    }
+
+    /* Check error code returns */
+    memset(buf, '.', 10);
+    ok( !GlobalGetAtomNameA( atom, buf,  0 ), "succeeded\n" );
+    ok( !memcmp( buf, "..........", 10 ), "should not touch
buffer\n"
);
+
+    if (unicode_OS)
+    {
+        static const WCHAR sampleW[10] =
{'.','.','.','.','.','.','.','.','.','.'};
+
+        for (i = 0; i < 10; i++) bufW[i] = '.';
+        ok( !GlobalGetAtomNameW( atom, bufW, 0 ), "succeeded\n" );
+        ok( !memcmp( bufW, sampleW, 10 * sizeof(WCHAR) ), "should not
touch buffer\n" );
+    }
+
+    /* Test integer atoms */
+    for (i = 0; i <= 0xbfff; i++)
+    {
+        memset( buf, 'a', 10 );
+        len = GlobalGetAtomNameA( (ATOM)i, buf, 10 );
+        if (i)
+        {
+            char res[20];
+            ok( (len > 1) && (len < 7), "bad length %d\n", len
);
+            sprintf( res, "#%d", i );
+            memset( res + strlen(res) + 1, 'a', 10 );
+            ok( !memcmp( res, buf, 10 ), "bad buffer contents %s\n",
buf );
+        }
+        else
+            ok( !len, "bad length %d\n", len );
+    }
+}
+
+static void test_error_handling(void)
+{
+    char buffer[260];
+    WCHAR bufferW[260];
+    int i;
+
+    memset( buffer, 'a', 256 );
+    buffer[256] = 0;
+    ok( !GlobalAddAtomA(buffer), "add succeeded\n" );
+    ok( !GlobalFindAtomA(buffer), "find succeeded\n" );
+
+    if (unicode_OS)
+    {
+        for (i = 0; i < 256; i++) bufferW[i] = 'b';
+        bufferW[256] = 0;
+        ok( !GlobalAddAtomW(bufferW), "add succeeded\n" );
+        ok( !GlobalFindAtomW(bufferW), "find succeeded\n" );
+    }
+}
+
+static void test_local_add_atom(void)
+{
+    ATOM atom, w_atom;
+    int i;
+
+    SetLastError( 0xdeadbeef );
+    atom = AddAtomA( "foobar" );
+    ok( atom >= 0xc000, "bad atom id %x\n", atom );
+    ok( GetLastError() == 0xdeadbeef, "AddAtomA set last error\n" );
+
+    /* Verify that it can be found (or not) appropriately */
+    ok( FindAtomA( "foobar" ) == atom, "could not find atom
foobar\n"
);
+    ok( FindAtomA( "FOOBAR" ) == atom, "could not find atom
FOOBAR\n"
);
+    ok( !FindAtomA( "_foobar" ), "found _foobar\n" );
+
+    /* Add the same atom, specifying string as unicode; should
+     * find the first one, not add a new one */
+    SetLastError( 0xdeadbeef );
+    w_atom = AddAtomW( foobarW );
+    if (w_atom && GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+        unicode_OS = TRUE;
+    else
+        trace("WARNING: Unicode atom APIs are not supported on this
platform\n");
+
+    if (unicode_OS)
+    {
+        ok( w_atom == atom, "Unicode atom does not match ASCII\n" );
+        ok( GetLastError() == 0xdeadbeef, "AddAtomW set last error\n"
);
+    }
+
+    /* Verify that it can be found (or not) appropriately via unicode
name */
+    if (unicode_OS)
+    {
+        ok( FindAtomW( foobarW ) == atom, "could not find atom
foobar\n" );
+        ok( FindAtomW( FOOBARW ) == atom, "could not find atom
FOOBAR\n" );
+        ok( !FindAtomW( _foobarW ), "found _foobar\n" );
+    }
+
+    /* Test integer atoms
+     * (0x0001 .. 0xbfff) should be valid;
+     * (0xc000 .. 0xffff) should be invalid */
+
+    SetLastError( 0xdeadbeef );
+    ok( AddAtomA(0) == 0 && GetLastError() == 0xdeadbeef, "succeeded to
add atom 0\n" );
+    if (unicode_OS)
+    {
+        SetLastError( 0xdeadbeef );
+        ok( AddAtomW(0) == 0 && GetLastError() == 0xdeadbeef,
"succeeded to add atom 0\n" );
+    }
+
+    SetLastError( 0xdeadbeef );
+    for (i = 1; i <= 0xbfff; i++)
+    {
+        SetLastError( 0xdeadbeef );
+        ok( AddAtomA((LPCSTR)i) == i && GetLastError() == 0xdeadbeef,
+            "failed to add atom %x\n", i );
+        if (unicode_OS)
+        {
+            SetLastError( 0xdeadbeef );
+            ok( AddAtomW((LPCWSTR)i) == i && GetLastError() ==
0xdeadbeef,
+                "failed to add atom %x\n", i );
+        }
+    }
+
+    for (i = 0xc000; i <= 0xffff; i++)
+    {
+        ok( !AddAtomA((LPCSTR)i), "succeeded adding %x\n", i );
+        if (unicode_OS)
+            ok( !AddAtomW((LPCWSTR)i), "succeeded adding %x\n", i );
+    }
+}
+
+static void test_local_get_atom_name(void)
+{
+    char buf[10];
+    WCHAR bufW[10];
+    int i;
+    UINT len;
+    static const WCHAR resultW[] =
{'f','o','o','b','a','r',0,'.','.','.'};
+
+    ATOM atom = AddAtomA( "foobar" );
+
+    /* Get the name of the atom we added above */
+    memset( buf, '.', sizeof(buf) );
+    len = GetAtomNameA( atom, buf, 10 );
+    ok( len == strlen("foobar"), "bad length %d\n", len );
+    ok( !memcmp( buf, "foobar\0...", 10 ), "bad buffer contents\n"
);
+
+    /* Repeat, unicode-style */
+    if (unicode_OS)
+    {
+        for (i = 0; i < 10; i++) bufW[i] = '.';
+        SetLastError( 0xdeadbeef );
+        len = GetAtomNameW( atom, bufW, 10 );
+        ok( len && GetLastError() == 0xdeadbeef, "GetAtomNameW
failed\n" );
+        ok( len == lstrlenW(foobarW), "bad length %d\n", len );
+        ok( !memcmp( bufW, resultW, 10*sizeof(WCHAR) ), "bad buffer
contents\n" );
+    }
+
+    /* Check error code returns */
+    memset(buf, '.', 10);
+    ok( !GetAtomNameA( atom, buf,  0 ), "succeeded\n" );
+    ok( !memcmp( buf, "..........", 10 ), "should not touch
buffer\n"
);
+
+    if (unicode_OS)
+    {
+        static const WCHAR sampleW[10] =
{'.','.','.','.','.','.','.','.','.','.'};
+
+        for (i = 0; i < 10; i++) bufW[i] = '.';
+        ok( !GetAtomNameW( atom, bufW, 0 ), "succeeded\n" );
+        ok( !memcmp( bufW, sampleW, 10 * sizeof(WCHAR) ), "should not
touch buffer\n" );
+    }
+
+    /* Test integer atoms */
+    for (i = 0; i <= 0xbfff; i++)
+    {
+        memset( buf, 'a', 10 );
+        len = GetAtomNameA( (ATOM)i, buf, 10 );
+        if (i)
+        {
+            char res[20];
+            ok( (len > 1) && (len < 7), "bad length %d\n", len
);
+            sprintf( res, "#%d", i );
+            memset( res + strlen(res) + 1, 'a', 10 );
+            ok( !memcmp( res, buf, 10 ), "bad buffer contents %s\n",
buf );
+        }
+        else
+            ok( !len, "bad length %d\n", len );
+    }
+}
+
+static void test_local_error_handling(void)
+{
+    char buffer[260];
+    WCHAR bufferW[260];
+    int i;
+
+    memset( buffer, 'a', 256 );
+    buffer[256] = 0;
+    ok( !AddAtomA(buffer), "add succeeded\n" );
+    ok( !FindAtomA(buffer), "find succeeded\n" );
+
+    if (unicode_OS)
+    {
+        for (i = 0; i < 256; i++) bufferW[i] = 'b';
+        bufferW[256] = 0;
+        ok( !AddAtomW(bufferW), "add succeeded\n" );
+        ok( !FindAtomW(bufferW), "find succeeded\n" );
+    }
+}
+
+
+START_TEST(atom)
+{
+    test_add_atom();
+    test_get_atom_name();
+    test_error_handling();
+    test_local_add_atom();
+    test_local_get_atom_name();
+    test_local_error_handling();
+}
Property changes on: trunk/reactos/regtests/winetests/kernel32/atom.c
___________________________________________________________________
Name: svn:executable
   + *
  _____  

Added: trunk/reactos/regtests/winetests/kernel32/change.c
--- trunk/reactos/regtests/winetests/kernel32/change.c	2005-08-07
03:00:44 UTC (rev 17136)
+++ trunk/reactos/regtests/winetests/kernel32/change.c	2005-08-07
03:14:17 UTC (rev 17137)
@@ -0,0 +1,242 @@

+/*
+ * Tests for file change notification functions
+ *
+ * Copyright (c) 2004 Hans Leidekker
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
USA
+ */
+
+/* TODO: - security attribute changes
+ *       - compound filter and multiple notifications
+ *       - subtree notifications
+ *       - non-documented flags FILE_NOTIFY_CHANGE_LAST_ACCESS and
+ *         FILE_NOTIFY_CHANGE_CREATION
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "wine/test.h"
+#include <windef.h>
+#include <winbase.h>
+
+static DWORD CALLBACK NotificationThread(LPVOID arg)
+{
+    HANDLE change = (HANDLE) arg;
+    BOOL ret = FALSE;
+    DWORD status;
+
+    status = WaitForSingleObject(change, 100);
+
+    if (status == WAIT_OBJECT_0 ) {
+        ret = FindNextChangeNotification(change);
+    }
+
+    ret = FindCloseChangeNotification(change);
+    ok( ret, "FindCloseChangeNotification error: %ld\n",
+       GetLastError());
+
+    ExitThread((DWORD)ret);
+}
+
+static HANDLE StartNotificationThread(LPCSTR path, BOOL subtree, DWORD
flags)
+{
+    HANDLE change, thread;
+    DWORD threadId;
+
+    change = FindFirstChangeNotificationA(path, subtree, flags);
+    ok(change != INVALID_HANDLE_VALUE, "FindFirstChangeNotification
error: %ld\n", GetLastError());
+
+    thread = CreateThread(NULL, 0, NotificationThread, (LPVOID)change,
+                          0, &threadId);
+    ok(thread != INVALID_HANDLE_VALUE, "CreateThread error: %ld\n",
GetLastError());
+
+    return thread;
+}
+
+static DWORD FinishNotificationThread(HANDLE thread)
+{
+    DWORD status, exitcode;
+
+    status = WaitForSingleObject(thread, 5000);
+    ok(status == WAIT_OBJECT_0, "WaitForSingleObject status %ld error
%ld\n", status, GetLastError());
+
+    ok(GetExitCodeThread(thread, &exitcode), "Could not retrieve thread
exit code\n");
+
+    return exitcode;
+}
+
+static void test_FindFirstChangeNotification(void)
+{
+    HANDLE change, file, thread;
+    DWORD attributes, count;
+    BOOL ret;
+
+    char workdir[MAX_PATH], dirname1[MAX_PATH], dirname2[MAX_PATH];
+    char filename1[MAX_PATH], filename2[MAX_PATH];
+    static const char prefix[] = "FCN";
+    char buffer[2048];
+
+    /* pathetic checks */
+
+    change = FindFirstChangeNotificationA("not-a-file", FALSE,
FILE_NOTIFY_CHANGE_FILE_NAME);
+    ok(change == INVALID_HANDLE_VALUE && GetLastError() ==
ERROR_FILE_NOT_FOUND,
+       "FindFirstChangeNotification error: %ld\n", GetLastError());
+
+    if (0) /* This documents win2k behavior. It crashes on win98. */
+    { 
+        change = FindFirstChangeNotificationA(NULL, FALSE,
FILE_NOTIFY_CHANGE_FILE_NAME);
+        ok(change == NULL && GetLastError() == ERROR_PATH_NOT_FOUND,
+        "FindFirstChangeNotification error: %ld\n", GetLastError());
+    }
+
+    ret = FindNextChangeNotification(NULL);
+    ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
"FindNextChangeNotification error: %ld\n",
+       GetLastError());
+
+    ret = FindCloseChangeNotification(NULL);
+    ok(!ret && GetLastError() == ERROR_INVALID_HANDLE,
"FindCloseChangeNotification error: %ld\n",
+       GetLastError());
+
+    ret = GetTempPathA(MAX_PATH, workdir);
+    ok(ret, "GetTempPathA error: %ld\n", GetLastError());
+
+    lstrcatA(workdir, "testFileChangeNotification");
+
+    ret = CreateDirectoryA(workdir, NULL);
+    ok(ret, "CreateDirectoryA error: %ld\n", GetLastError());
+
+    ret = GetTempFileNameA(workdir, prefix, 0, filename1);
+    ok(ret, "GetTempFileNameA error: %ld\n", GetLastError());
+
+    file = CreateFileA(filename1, GENERIC_WRITE|GENERIC_READ, 0, NULL,
CREATE_ALWAYS,
+                       FILE_ATTRIBUTE_NORMAL, 0);
+    ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %ld\n",
GetLastError());
+    ret = CloseHandle(file);
+    ok( ret, "CloseHandle error: %ld\n", GetLastError());
+
+    /* Try to register notification for a file. win98 and win2k behave
differently here */
+    change = FindFirstChangeNotificationA(filename1, FALSE,
FILE_NOTIFY_CHANGE_FILE_NAME);
+    ok(change == INVALID_HANDLE_VALUE && (GetLastError() ==
ERROR_DIRECTORY ||
+                                          GetLastError() ==
ERROR_FILE_NOT_FOUND),
+       "FindFirstChangeNotification error: %ld\n", GetLastError());
+
+    lstrcpyA(dirname1, filename1);
+    lstrcatA(dirname1, "dir");
+
+    ret = CreateDirectoryA(dirname1, NULL);
+    ok(ret, "CreateDirectoryA error: %ld\n", GetLastError());
+
+    /* What if we remove the directory we registered notification for?
*/
+    thread = StartNotificationThread(dirname1, FALSE,
FILE_NOTIFY_CHANGE_DIR_NAME);
+    ret = RemoveDirectoryA(dirname1);
+    ok(ret, "RemoveDirectoryA error: %ld\n", GetLastError());
+
+    /* win98 and win2k behave differently here */
+    ret = FinishNotificationThread(thread);
+    ok(ret || !ret, "You'll never read this\n");
+
+    /* functional checks */
+
+    /* Create a directory */
+    thread = StartNotificationThread(workdir, FALSE,
FILE_NOTIFY_CHANGE_DIR_NAME);
+    ret = CreateDirectoryA(dirname1, NULL);
+    ok(ret, "CreateDirectoryA error: %ld\n", GetLastError());
+    ok(FinishNotificationThread(thread), "Missed notification\n");
+
+    lstrcpyA(dirname2, dirname1);
+    lstrcatA(dirname2, "new");
+
+    /* Rename a directory */
+    thread = StartNotificationThread(workdir, FALSE,
FILE_NOTIFY_CHANGE_DIR_NAME);
+    ret = MoveFileA(dirname1, dirname2);
+    ok(ret, "MoveFileA error: %ld\n", GetLastError());
+    ok(FinishNotificationThread(thread), "Missed notification\n");
+
+    /* Delete a directory */
+    thread = StartNotificationThread(workdir, FALSE,
FILE_NOTIFY_CHANGE_DIR_NAME);
+    ret = RemoveDirectoryA(dirname2);
+    ok(ret, "RemoveDirectoryA error: %ld\n", GetLastError());
+    ok(FinishNotificationThread(thread), "Missed notification\n");
+
+    lstrcpyA(filename2, filename1);
+    lstrcatA(filename2, "new");
+
+    /* Rename a file */
+    thread = StartNotificationThread(workdir, FALSE,
FILE_NOTIFY_CHANGE_FILE_NAME);
+    ret = MoveFileA(filename1, filename2);
+    ok(ret, "MoveFileA error: %ld\n", GetLastError());
+    ok(FinishNotificationThread(thread), "Missed notification\n");
+
+    /* Delete a file */
+    thread = StartNotificationThread(workdir, FALSE,
FILE_NOTIFY_CHANGE_FILE_NAME);
+    ret = DeleteFileA(filename2);
+    ok(ret, "DeleteFileA error: %ld\n", GetLastError());
+    ok(FinishNotificationThread(thread), "Missed notification\n");
+
+    /* Create a file */
+    thread = StartNotificationThread(workdir, FALSE,
FILE_NOTIFY_CHANGE_FILE_NAME);
+    file = CreateFileA(filename2, GENERIC_WRITE|GENERIC_READ, 0, NULL,
CREATE_ALWAYS, 
+                       FILE_ATTRIBUTE_NORMAL, 0);
+    ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %ld\n",
GetLastError());
+    ret = CloseHandle(file);
+    ok( ret, "CloseHandle error: %ld\n", GetLastError());
+    ok(FinishNotificationThread(thread), "Missed notification\n");
+
+    attributes = GetFileAttributesA(filename2);
+    ok(attributes != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA
error: %ld\n", GetLastError());
+    attributes &= FILE_ATTRIBUTE_READONLY;
+
+    /* Change file attributes */
+    thread = StartNotificationThread(workdir, FALSE,
FILE_NOTIFY_CHANGE_ATTRIBUTES);
+    ret = SetFileAttributesA(filename2, attributes);
+    ok(ret, "SetFileAttributesA error: %ld\n", GetLastError());
+    ok(FinishNotificationThread(thread), "Missed notification\n");
+
+    /* Change last write time by writing to a file */
+    thread = StartNotificationThread(workdir, FALSE,
FILE_NOTIFY_CHANGE_LAST_WRITE);
+    file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, 
+                       FILE_ATTRIBUTE_NORMAL, 0);
+    ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %ld\n",
GetLastError());
+    ret = WriteFile(file, buffer, sizeof(buffer), &count, NULL);
+    ok(ret && count == sizeof(buffer), "WriteFile error: %ld\n",
GetLastError());
+    ret = CloseHandle(file);
+    ok( ret, "CloseHandle error: %ld\n", GetLastError());
+    ok(FinishNotificationThread(thread), "Missed notification\n");
+
+    /* Change file size by truncating a file */
+    thread = StartNotificationThread(workdir, FALSE,
FILE_NOTIFY_CHANGE_SIZE);
+    file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, 
+                       FILE_ATTRIBUTE_NORMAL, 0);
+    ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %ld\n",
GetLastError());
+    ret = WriteFile(file, buffer, sizeof(buffer) / 2, &count, NULL);
+    ok(ret && count == sizeof(buffer) / 2, "WriteFileA error: %ld\n",
GetLastError());
[truncated at 1000 lines; 12413 more skipped]