Add trailing '\n's to ok() calls (ntdll 3)

Francois Gouget fgouget at free.fr
Fri Feb 6 07:00:08 CST 2004


Changelog:

 * dlls/ntdll/tests/rtlbitmap.c

   Add trailing '\n's to ok() calls.
   Spelling fixes in the ok() messages.


Index: dlls/ntdll/tests/rtlbitmap.c
===================================================================
RCS file: /home/cvs/wine/dlls/ntdll/tests/rtlbitmap.c,v
retrieving revision 1.5
diff -u -r1.5 rtlbitmap.c
--- dlls/ntdll/tests/rtlbitmap.c	5 Sep 2003 23:08:34 -0000	1.5
+++ dlls/ntdll/tests/rtlbitmap.c	6 Feb 2004 12:04:11 -0000
@@ -56,7 +56,7 @@
 static void InitFunctionPtrs()
 {
   hntdll = LoadLibraryA("ntdll.dll");
-  ok(hntdll != 0, "LoadLibrary failed");
+  ok(hntdll != 0, "LoadLibrary failed\n");
   if (hntdll)
   {
     pRtlInitializeBitMap = (void *)GetProcAddress(hntdll, "RtlInitializeBitMap");
@@ -89,15 +89,15 @@
   buff[79] = 77;

   pRtlInitializeBitMap(&bm, buff, 800);
-  ok(bm.SizeOfBitMap == 800, "size uninitialised");
-  ok(bm.BitMapBuffer == buff,"buffer uninitialised");
-  ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer");
+  ok(bm.SizeOfBitMap == 800, "size uninitialised\n");
+  ok(bm.BitMapBuffer == buff,"buffer uninitialised\n");
+  ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer\n");

   /* Test inlined version */
   RtlInitializeBitMap(&bm, buff, 800);
-  ok(bm.SizeOfBitMap == 800, "size uninitialised");
-  ok(bm.BitMapBuffer == buff,"buffer uninitialised");
-  ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer");
+  ok(bm.SizeOfBitMap == 800, "size uninitialised\n");
+  ok(bm.BitMapBuffer == buff,"buffer uninitialised\n");
+  ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer\n");
 }

 static void test_RtlSetAllBits(void)
@@ -110,15 +110,15 @@

   pRtlSetAllBits(&bm);
   ok(buff[0] == 0xff && buff[1] == 0xff && buff[2] == 0xff &&
-     buff[3] == 0xff, "didnt round up size");
-  ok(buff[4] == 0, "set more than rounded size");
+     buff[3] == 0xff, "didn't round up size\n");
+  ok(buff[4] == 0, "set more than rounded size\n");

   /* Test inlined version */
   memset(buff, 0 , sizeof(buff));
   RtlSetAllBits(&bm);
   ok(buff[0] == 0xff && buff[1] == 0xff && buff[2] == 0xff &&
-     buff[3] == 0xff, "didnt round up size");
-  ok(buff[4] == 0, "set more than rounded size");
+     buff[3] == 0xff, "didn't round up size\n");
+  ok(buff[4] == 0, "set more than rounded size\n");
 }

 static void test_RtlClearAllBits()
@@ -130,14 +130,14 @@
   pRtlInitializeBitMap(&bm, buff, 1);

   pRtlClearAllBits(&bm);
-  ok(!buff[0] && !buff[1] && !buff[2] && !buff[3], "didnt round up size");
-  ok(buff[4] == 0xff, "cleared more than rounded size");
+  ok(!buff[0] && !buff[1] && !buff[2] && !buff[3], "didn't round up size\n");
+  ok(buff[4] == 0xff, "cleared more than rounded size\n");

   /* Test inlined version */
   memset(buff, 0xff , sizeof(buff));
   RtlClearAllBits(&bm);
-  ok(!buff[0] && !buff[1] && !buff[2] && !buff[3] , "didnt round up size");
-  ok(buff[4] == 0xff, "cleared more than rounded size");
+  ok(!buff[0] && !buff[1] && !buff[2] && !buff[3] , "didn't round up size\n");
+  ok(buff[4] == 0xff, "cleared more than rounded size\n");
 }

 static void test_RtlSetBits()
@@ -149,23 +149,23 @@
   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

   pRtlSetBits(&bm, 0, 1);
-  ok(buff[0] == 1, "didnt set 1st bit");
+  ok(buff[0] == 1, "didn't set 1st bit\n");

   buff[0] = 0;
   pRtlSetBits(&bm, 7, 2);
-  ok(buff[0] == 0x80 && buff[1] == 1, "didnt span w/len < 8");
+  ok(buff[0] == 0x80 && buff[1] == 1, "didn't span w/len < 8\n");

   buff[0] = buff[1] = 0;
   pRtlSetBits(&bm, 7, 10);
-  ok(buff[0] == 0x80 && buff[1] == 0xff && buff[2] == 1, "didnt span w/len > 8");
+  ok(buff[0] == 0x80 && buff[1] == 0xff && buff[2] == 1, "didn't span w/len > 8\n");

   buff[0] = buff[1] = buff[2] = 0;
   pRtlSetBits(&bm, 0, 8); /* 1st byte */
-  ok(buff[0] == 0xff, "didnt set all bits");
-  ok(!buff[1], "set too many bits");
+  ok(buff[0] == 0xff, "didn't set all bits\n");
+  ok(!buff[1], "set too many bits\n");

   pRtlSetBits(&bm, sizeof(buff)*8-1, 1); /* last bit */
-  ok(buff[sizeof(buff)-1] == 0x80, "didnt set last bit");
+  ok(buff[sizeof(buff)-1] == 0x80, "didn't set last bit\n");
 }

 static void test_RtlClearBits()
@@ -177,23 +177,23 @@
   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

   pRtlClearBits(&bm, 0, 1);
-  ok(buff[0] == 0xfe, "didnt clear 1st bit");
+  ok(buff[0] == 0xfe, "didn't clear 1st bit\n");

   buff[0] = 0xff;
   pRtlClearBits(&bm, 7, 2);
-  ok(buff[0] == 0x7f && buff[1] == 0xfe, "didnt span w/len < 8");
+  ok(buff[0] == 0x7f && buff[1] == 0xfe, "didn't span w/len < 8\n");

   buff[0] = buff[1] = 0xff;
   pRtlClearBits(&bm, 7, 10);
-  ok(buff[0] == 0x7f && buff[1] == 0 && buff[2] == 0xfe, "didnt span w/len > 8");
+  ok(buff[0] == 0x7f && buff[1] == 0 && buff[2] == 0xfe, "didn't span w/len > 8\n");

   buff[0] = buff[1] = buff[2] = 0xff;
   pRtlClearBits(&bm, 0, 8);  /* 1st byte */
-  ok(!buff[0], "didnt clear all bits");
-  ok(buff[1] == 0xff, "cleared too many bits");
+  ok(!buff[0], "didn't clear all bits\n");
+  ok(buff[1] == 0xff, "cleared too many bits\n");

   pRtlClearBits(&bm, sizeof(buff)*8-1, 1);
-  ok(buff[sizeof(buff)-1] == 0x7f, "didnt set last bit");
+  ok(buff[sizeof(buff)-1] == 0x7f, "didn't set last bit\n");
 }

 static void test_RtlCheckBit()
@@ -207,17 +207,17 @@
   pRtlSetBits(&bm, sizeof(buff)*8-1, 1);

   bRet = RtlCheckBit(&bm, 0);
-  ok (bRet, "didnt find set bit");
+  ok (bRet, "didn't find set bit\n");
   bRet = RtlCheckBit(&bm, 7);
-  ok (bRet, "didnt find set bit");
+  ok (bRet, "didn't find set bit\n");
   bRet = RtlCheckBit(&bm, 8);
-  ok (bRet, "didnt find set bit");
+  ok (bRet, "didn't find set bit\n");
   bRet = RtlCheckBit(&bm, sizeof(buff)*8-1);
-  ok (bRet, "didnt find set bit");
+  ok (bRet, "didn't find set bit\n");
   bRet = RtlCheckBit(&bm, 1);
-  ok (!bRet, "found non set bit");
+  ok (!bRet, "found non set bit\n");
   bRet = RtlCheckBit(&bm, sizeof(buff)*8-2);
-  ok (!bRet, "found non set bit");
+  ok (!bRet, "found non set bit\n");
 }

 static void test_RtlAreBitsSet()
@@ -231,38 +231,38 @@
   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

   bRet = pRtlAreBitsSet(&bm, 0, 1);
-  ok (!bRet, "found set bits after init");
+  ok (!bRet, "found set bits after init\n");

   pRtlSetBits(&bm, 0, 1);
   bRet = pRtlAreBitsSet(&bm, 0, 1);
-  ok (bRet, "didnt find set bits");
+  ok (bRet, "didn't find set bits\n");

   buff[0] = 0;
   pRtlSetBits(&bm, 7, 2);
   bRet = pRtlAreBitsSet(&bm, 7, 2);
-  ok(bRet, "didnt find w/len < 8");
+  ok(bRet, "didn't find w/len < 8\n");
   bRet = pRtlAreBitsSet(&bm, 6, 3);
-  ok(!bRet, "found non set bit");
+  ok(!bRet, "found non set bit\n");
   bRet = pRtlAreBitsSet(&bm, 7, 3);
-  ok(!bRet, "found non set bit");
+  ok(!bRet, "found non set bit\n");

   buff[0] = buff[1] = 0;
   pRtlSetBits(&bm, 7, 10);
   bRet = pRtlAreBitsSet(&bm, 7, 10);
-  ok(bRet, "didnt find w/len < 8");
+  ok(bRet, "didn't find w/len < 8\n");
   bRet = pRtlAreBitsSet(&bm, 6, 11);
-  ok(!bRet, "found non set bit");
+  ok(!bRet, "found non set bit\n");
   bRet = pRtlAreBitsSet(&bm, 7, 11);
-  ok(!bRet, "found non set bit");
+  ok(!bRet, "found non set bit\n");

   buff[0] = buff[1] = buff[2] = 0;
   pRtlSetBits(&bm, 0, 8); /* 1st byte */
   bRet = pRtlAreBitsSet(&bm, 0, 8);
-  ok(bRet, "didn't find whole byte");
+  ok(bRet, "didn't find whole byte\n");

   pRtlSetBits(&bm, sizeof(buff)*8-1, 1);
   bRet = pRtlAreBitsSet(&bm, sizeof(buff)*8-1, 1);
-  ok(bRet, "didn't find last bit");
+  ok(bRet, "didn't find last bit\n");
 }

 static void test_RtlAreBitsClear()
@@ -276,38 +276,38 @@
   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

   bRet = pRtlAreBitsClear(&bm, 0, 1);
-  ok (!bRet, "found clear bits after init");
+  ok (!bRet, "found clear bits after init\n");

   pRtlClearBits(&bm, 0, 1);
   bRet = pRtlAreBitsClear(&bm, 0, 1);
-  ok (bRet, "didnt find set bits");
+  ok (bRet, "didn't find set bits\n");

   buff[0] = 0xff;
   pRtlClearBits(&bm, 7, 2);
   bRet = pRtlAreBitsClear(&bm, 7, 2);
-  ok(bRet, "didnt find w/len < 8");
+  ok(bRet, "didn't find w/len < 8\n");
   bRet = pRtlAreBitsClear(&bm, 6, 3);
-  ok(!bRet, "found non clear bit");
+  ok(!bRet, "found non clear bit\n");
   bRet = pRtlAreBitsClear(&bm, 7, 3);
-  ok(!bRet, "found non clear bit");
+  ok(!bRet, "found non clear bit\n");

   buff[0] = buff[1] = 0xff;
   pRtlClearBits(&bm, 7, 10);
   bRet = pRtlAreBitsClear(&bm, 7, 10);
-  ok(bRet, "didnt find w/len < 8");
+  ok(bRet, "didn't find w/len < 8\n");
   bRet = pRtlAreBitsClear(&bm, 6, 11);
-  ok(!bRet, "found non clear bit");
+  ok(!bRet, "found non clear bit\n");
   bRet = pRtlAreBitsClear(&bm, 7, 11);
-  ok(!bRet, "found non clear bit");
+  ok(!bRet, "found non clear bit\n");

   buff[0] = buff[1] = buff[2] = 0xff;
   pRtlClearBits(&bm, 0, 8); /* 1st byte */
   bRet = pRtlAreBitsClear(&bm, 0, 8);
-  ok(bRet, "didn't find whole byte");
+  ok(bRet, "didn't find whole byte\n");

   pRtlClearBits(&bm, sizeof(buff)*8-1, 1);
   bRet = pRtlAreBitsClear(&bm, sizeof(buff)*8-1, 1);
-  ok(bRet, "didn't find last bit");
+  ok(bRet, "didn't find last bit\n");
 }

 static void test_RtlNumberOfSetBits()
@@ -321,23 +321,23 @@
   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

   ulCount = pRtlNumberOfSetBits(&bm);
-  ok(ulCount == 0, "set bits after init");
+  ok(ulCount == 0, "set bits after init\n");

   pRtlSetBits(&bm, 0, 1); /* Set 1st bit */
   ulCount = pRtlNumberOfSetBits(&bm);
-  ok(ulCount == 1, "count wrong");
+  ok(ulCount == 1, "count wrong\n");

   pRtlSetBits(&bm, 7, 8); /* 8 more, spanning bytes 1-2 */
   ulCount = pRtlNumberOfSetBits(&bm);
-  ok(ulCount == 8+1, "count wrong");
+  ok(ulCount == 8+1, "count wrong\n");

   pRtlSetBits(&bm, 17, 33); /* 33 more crossing ULONG boundary */
   ulCount = pRtlNumberOfSetBits(&bm);
-  ok(ulCount == 8+1+33, "count wrong");
+  ok(ulCount == 8+1+33, "count wrong\n");

   pRtlSetBits(&bm, sizeof(buff)*8-1, 1); /* Set last bit */
   ulCount = pRtlNumberOfSetBits(&bm);
-  ok(ulCount == 8+1+33+1, "count wrong");
+  ok(ulCount == 8+1+33+1, "count wrong\n");
 }

 static void test_RtlNumberOfClearBits()
@@ -351,23 +351,23 @@
   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

   ulCount = pRtlNumberOfClearBits(&bm);
-  ok(ulCount == 0, "cleared bits after init");
+  ok(ulCount == 0, "cleared bits after init\n");

   pRtlClearBits(&bm, 0, 1); /* Set 1st bit */
   ulCount = pRtlNumberOfClearBits(&bm);
-  ok(ulCount == 1, "count wrong");
+  ok(ulCount == 1, "count wrong\n");

   pRtlClearBits(&bm, 7, 8); /* 8 more, spanning bytes 1-2 */
   ulCount = pRtlNumberOfClearBits(&bm);
-  ok(ulCount == 8+1, "count wrong");
+  ok(ulCount == 8+1, "count wrong\n");

   pRtlClearBits(&bm, 17, 33); /* 33 more crossing ULONG boundary */
   ulCount = pRtlNumberOfClearBits(&bm);
-  ok(ulCount == 8+1+33, "count wrong");
+  ok(ulCount == 8+1+33, "count wrong\n");

   pRtlClearBits(&bm, sizeof(buff)*8-1, 1); /* Set last bit */
   ulCount = pRtlNumberOfClearBits(&bm);
-  ok(ulCount == 8+1+33+1, "count wrong");
+  ok(ulCount == 8+1+33+1, "count wrong\n");
 }

 /* Note: this tests RtlFindSetBits also */
@@ -384,21 +384,21 @@

   pRtlSetBits(&bm, 0, 32);
   ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
-  ok (ulPos == 0, "didnt find bits");
+  ok (ulPos == 0, "didn't find bits\n");
   if(ulPos == 0)
   {
     bRet = pRtlAreBitsClear(&bm, 0, 32);
-    ok (bRet, "found but didnt clear");
+    ok (bRet, "found but didn't clear\n");
   }

   memset(buff, 0 , sizeof(buff));
   pRtlSetBits(&bm, 40, 77);
   ulPos = pRtlFindSetBitsAndClear(&bm, 77, 0);
-  ok (ulPos == 40, "didnt find bits");
+  ok (ulPos == 40, "didn't find bits\n");
   if(ulPos == 40)
   {
     bRet = pRtlAreBitsClear(&bm, 40, 77);
-    ok (bRet, "found but didnt clear");
+    ok (bRet, "found but didn't clear\n");
   }
 }

@@ -416,21 +416,21 @@
   memset(buff, 0xff, sizeof(buff));
   pRtlSetBits(&bm, 0, 32);
   ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
-  ok (ulPos == 0, "didnt find bits");
+  ok (ulPos == 0, "didn't find bits\n");
   if(ulPos == 0)
   {
       bRet = pRtlAreBitsClear(&bm, 0, 32);
-      ok (bRet, "found but didnt clear");
+      ok (bRet, "found but didn't clear\n");
   }

   memset(buff, 0xff , sizeof(buff));
   pRtlClearBits(&bm, 40, 77);
   ulPos = pRtlFindClearBitsAndSet(&bm, 77, 50);
-  ok (ulPos == 40, "didnt find bits");
+  ok (ulPos == 40, "didn't find bits\n");
   if(ulPos == 40)
   {
     bRet = pRtlAreBitsSet(&bm, 40, 77);
-    ok (bRet, "found but didnt set");
+    ok (bRet, "found but didn't set\n");
   }
 }

@@ -449,16 +449,16 @@
     ulLong <<= i;

     cPos = pRtlFindMostSignificantBit(ulLong);
-    ok (cPos == i, "didnt find MSB %llx %d %d", ulLong, i, cPos);
+    ok (cPos == i, "didn't find MSB %llx %d %d\n", ulLong, i, cPos);

     /* Set all bits lower than bit i */
     ulLong = ((ulLong - 1) << 1) | 1;

     cPos = pRtlFindMostSignificantBit(ulLong);
-    ok (cPos == i, "didnt find MSB %llx %d %d", ulLong, i, cPos);
+    ok (cPos == i, "didn't find MSB %llx %d %d\n", ulLong, i, cPos);
   }
   cPos = pRtlFindMostSignificantBit(0);
-  ok (cPos == -1, "found bit when not set");
+  ok (cPos == -1, "found bit when not set\n");
 }

 static void test_RtlFindLeastSignificantBit()
@@ -475,15 +475,15 @@
     ulLong = (ULONGLONG)1 << i;

     cPos = pRtlFindLeastSignificantBit(ulLong);
-    ok (cPos == i, "didnt find LSB %llx %d %d", ulLong, i, cPos);
+    ok (cPos == i, "didn't find LSB %llx %d %d\n", ulLong, i, cPos);

     ulLong = ~((ULONGLONG)0) << i;

     cPos = pRtlFindLeastSignificantBit(ulLong);
-    ok (cPos == i, "didnt find LSB %llx %d %d", ulLong, i, cPos);
+    ok (cPos == i, "didn't find LSB %llx %d %d\n", ulLong, i, cPos);
   }
   cPos = pRtlFindLeastSignificantBit(0);
-  ok (cPos == -1, "found bit when not set");
+  ok (cPos == -1, "found bit when not set\n");
 }

 /* Note: Also tests RtlFindLongestRunSet() */
@@ -499,14 +499,14 @@

   memset(buff, 0, sizeof(buff));
   ulCount = pRtlFindSetRuns(&bm, runs, 16, TRUE);
-  ok (ulCount == 0, "found set bits in empty bitmap");
+  ok (ulCount == 0, "found set bits in empty bitmap\n");

   memset(runs, 0, sizeof(runs));
   memset(buff, 0xff, sizeof(buff));
   ulCount = pRtlFindSetRuns(&bm, runs, 16, TRUE);
-  ok (ulCount == 1, "didnt find set bits");
-  ok (runs[0].StartOfRun == 0,"bad start");
-  ok (runs[0].SizeOfRun == sizeof(buff)*8,"bad size");
+  ok (ulCount == 1, "didn't find set bits\n");
+  ok (runs[0].StartOfRun == 0,"bad start\n");
+  ok (runs[0].SizeOfRun == sizeof(buff)*8,"bad size\n");

   /* Set up 3 runs */
   memset(runs, 0, sizeof(runs));
@@ -517,46 +517,46 @@

   /* Get first 2 */
   ulCount = pRtlFindSetRuns(&bm, runs, 2, FALSE);
-  ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101,"bad find");
-  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101,"bad find");
-  ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 19 + 3,"bad size");
-  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
-  ok (runs[2].StartOfRun == 0,"found extra run");
+  ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101,"bad find\n");
+  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101,"bad find\n");
+  ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 19 + 3,"bad size\n");
+  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+  ok (runs[2].StartOfRun == 0,"found extra run\n");

   /* Get longest 3 */
   memset(runs, 0, sizeof(runs));
   ulCount = pRtlFindSetRuns(&bm, runs, 2, TRUE);
-  ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 1877,"bad find");
-  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 1877,"bad find");
-  ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 33 + 19,"bad size");
-  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
-  ok (runs[2].StartOfRun == 0,"found extra run");
+  ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 1877,"bad find\n");
+  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 1877,"bad find\n");
+  ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 33 + 19,"bad size\n");
+  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+  ok (runs[2].StartOfRun == 0,"found extra run\n");

   /* Get all 3 */
   memset(runs, 0, sizeof(runs));
   ulCount = pRtlFindSetRuns(&bm, runs, 3, TRUE);
   ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101 ||
-      runs[0].StartOfRun == 1877,"bad find");
+      runs[0].StartOfRun == 1877,"bad find\n");
   ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101 ||
-      runs[1].StartOfRun == 1877,"bad find");
+      runs[1].StartOfRun == 1877,"bad find\n");
   ok (runs[2].StartOfRun == 7 || runs[2].StartOfRun == 101 ||
-      runs[2].StartOfRun == 1877,"bad find");
+      runs[2].StartOfRun == 1877,"bad find\n");
   ok (runs[0].SizeOfRun + runs[1].SizeOfRun
-      + runs[2].SizeOfRun == 19 + 3 + 33,"bad size");
-  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
-  ok (runs[1].StartOfRun != runs[2].StartOfRun,"found run twice");
-  ok (runs[3].StartOfRun == 0,"found extra run");
+      + runs[2].SizeOfRun == 19 + 3 + 33,"bad size\n");
+  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+  ok (runs[1].StartOfRun != runs[2].StartOfRun,"found run twice\n");
+  ok (runs[3].StartOfRun == 0,"found extra run\n");

   if (pRtlFindLongestRunSet)
   {
     ULONG ulStart = 0;

     ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
-    ok(ulCount == 33 && ulStart == 1877,"didn't find longest %ld %ld",ulCount,ulStart);
+    ok(ulCount == 33 && ulStart == 1877,"didn't find longest %ld %ld\n",ulCount,ulStart);

     memset(buff, 0, sizeof(buff));
     ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
-    ok(ulCount == 0,"found longest when none set");
+    ok(ulCount == 0,"found longest when none set\n");
   }
 }

@@ -573,14 +573,14 @@

   memset(buff, 0xff, sizeof(buff));
   ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
-  ok (ulCount == 0, "found clear bits in full bitmap");
+  ok (ulCount == 0, "found clear bits in full bitmap\n");

   memset(runs, 0, sizeof(runs));
   memset(buff, 0, sizeof(buff));
   ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
-  ok (ulCount == 1, "didnt find clear bits");
-  ok (runs[0].StartOfRun == 0,"bad start");
-  ok (runs[0].SizeOfRun == sizeof(buff)*8,"bad size");
+  ok (ulCount == 1, "didn't find clear bits\n");
+  ok (runs[0].StartOfRun == 0,"bad start\n");
+  ok (runs[0].SizeOfRun == sizeof(buff)*8,"bad size\n");

   /* Set up 3 runs */
   memset(runs, 0, sizeof(runs));
@@ -591,46 +591,46 @@

   /* Get first 2 */
   ulCount = pRtlFindClearRuns(&bm, runs, 2, FALSE);
-  ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101,"bad find");
-  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101,"bad find");
-  ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 19 + 3,"bad size");
-  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
-  ok (runs[2].StartOfRun == 0,"found extra run");
+  ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101,"bad find\n");
+  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101,"bad find\n");
+  ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 19 + 3,"bad size\n");
+  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+  ok (runs[2].StartOfRun == 0,"found extra run\n");

   /* Get longest 3 */
   memset(runs, 0, sizeof(runs));
   ulCount = pRtlFindClearRuns(&bm, runs, 2, TRUE);
-  ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 1877,"bad find");
-  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 1877,"bad find");
-  ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 33 + 19,"bad size");
-  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
-  ok (runs[2].StartOfRun == 0,"found extra run");
+  ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 1877,"bad find\n");
+  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 1877,"bad find\n");
+  ok (runs[0].SizeOfRun + runs[1].SizeOfRun == 33 + 19,"bad size\n");
+  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+  ok (runs[2].StartOfRun == 0,"found extra run\n");

   /* Get all 3 */
   memset(runs, 0, sizeof(runs));
   ulCount = pRtlFindClearRuns(&bm, runs, 3, TRUE);
   ok (runs[0].StartOfRun == 7 || runs[0].StartOfRun == 101 ||
-      runs[0].StartOfRun == 1877,"bad find");
+      runs[0].StartOfRun == 1877,"bad find\n");
   ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101 ||
-      runs[1].StartOfRun == 1877,"bad find");
+      runs[1].StartOfRun == 1877,"bad find\n");
   ok (runs[2].StartOfRun == 7 || runs[2].StartOfRun == 101 ||
-      runs[2].StartOfRun == 1877,"bad find");
+      runs[2].StartOfRun == 1877,"bad find\n");
   ok (runs[0].SizeOfRun + runs[1].SizeOfRun
-      + runs[2].SizeOfRun == 19 + 3 + 33,"bad size");
-  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice");
-  ok (runs[1].StartOfRun != runs[2].StartOfRun,"found run twice");
-  ok (runs[3].StartOfRun == 0,"found extra run");
+      + runs[2].SizeOfRun == 19 + 3 + 33,"bad size\n");
+  ok (runs[0].StartOfRun != runs[1].StartOfRun,"found run twice\n");
+  ok (runs[1].StartOfRun != runs[2].StartOfRun,"found run twice\n");
+  ok (runs[3].StartOfRun == 0,"found extra run\n");

   if (pRtlFindLongestRunClear)
   {
     ULONG ulStart = 0;

     ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
-    ok(ulCount == 33 && ulStart == 1877,"didn't find longest");
+    ok(ulCount == 33 && ulStart == 1877,"didn't find longest\n");

     memset(buff, 0xff, sizeof(buff));
     ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
-    ok(ulCount == 0,"found longest when none clear");
+    ok(ulCount == 0,"found longest when none clear\n");
   }

 }



-- 
Francois Gouget         fgouget at free.fr        http://fgouget.free.fr/
            "Lotto: A tax on people who are bad at math." -- unknown
          "Windows: Microsoft's tax on computer illiterates." -- WE7U



More information about the wine-patches mailing list