rtlbitmap.c

Wine-20031016

/* Unit test suite for Rtl bitmap functions
 *
 * Copyright 2002 Jon Griffiths
 *
 * 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
 *
 * NOTES
 * We use function pointers here as some of the bitmap functions exist only
 * in later versions of ntdll.
 */
#include <stdarg.h>

#include "wine/test.h"
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winnt.h"
#include "winreg.h"
#include "winternl.h"

/* Function ptrs for ordinal calls */
static HMODULE hntdll = 0;
static VOID (WINAPI *pRtlInitializeBitMap)(PRTL_BITMAP,LPBYTE,ULONG);
static VOID (WINAPI *pRtlSetAllBits)(PRTL_BITMAP);
static VOID (WINAPI *pRtlClearAllBits)(PRTL_BITMAP);
static VOID (WINAPI *pRtlSetBits)(PRTL_BITMAP,ULONG,ULONG);
static VOID (WINAPI *pRtlClearBits)(PRTL_BITMAP,ULONG,ULONG);
static BOOLEAN (WINAPI *pRtlAreBitsSet)(PRTL_BITMAP,ULONG,ULONG);
static BOOLEAN (WINAPI *pRtlAreBitsClear)(PRTL_BITMAP,ULONG,ULONG);
static ULONG (WINAPI *pRtlFindSetBitsAndClear)(PRTL_BITMAP,ULONG,ULONG);
static ULONG (WINAPI *pRtlFindClearBitsAndSet)(PRTL_BITMAP,ULONG,ULONG);
static CCHAR (WINAPI *pRtlFindMostSignificantBit)(ULONGLONG);
static CCHAR (WINAPI *pRtlFindLeastSignificantBit)(ULONGLONG);
static ULONG (WINAPI *pRtlFindSetRuns)(PRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
static ULONG (WINAPI *pRtlFindClearRuns)(PRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
static ULONG (WINAPI *pRtlNumberOfSetBits)(PRTL_BITMAP);
static ULONG (WINAPI *pRtlNumberOfClearBits)(PRTL_BITMAP);
static ULONG (WINAPI *pRtlFindLongestRunSet)(PRTL_BITMAP,PULONG);
static ULONG (WINAPI *pRtlFindLongestRunClear)(PRTL_BITMAP,PULONG);

static BYTE buff[256];
static RTL_BITMAP bm;

static void InitFunctionPtrs()
{
  hntdll = LoadLibraryA("ntdll.dll");
  ok(hntdll != 0, "LoadLibrary failed");
  if (hntdll)
  {
    pRtlInitializeBitMap = (void *)GetProcAddress(hntdll, "RtlInitializeBitMap");
    pRtlSetAllBits = (void *)GetProcAddress(hntdll, "RtlSetAllBits");
    pRtlClearAllBits = (void *)GetProcAddress(hntdll, "RtlClearAllBits");
    pRtlSetBits = (void *)GetProcAddress(hntdll, "RtlSetBits");
    pRtlClearBits = (void *)GetProcAddress(hntdll, "RtlClearBits");
    pRtlAreBitsSet = (void *)GetProcAddress(hntdll, "RtlAreBitsSet");
    pRtlAreBitsClear = (void *)GetProcAddress(hntdll, "RtlAreBitsClear");
    pRtlNumberOfSetBits = (void *)GetProcAddress(hntdll, "RtlNumberOfSetBits");
    pRtlNumberOfClearBits = (void *)GetProcAddress(hntdll, "RtlNumberOfClearBits");
    pRtlFindSetBitsAndClear = (void *)GetProcAddress(hntdll, "RtlFindSetBitsAndClear");
    pRtlFindClearBitsAndSet = (void *)GetProcAddress(hntdll, "RtlFindClearBitsAndSet");
    pRtlFindMostSignificantBit = (void *)GetProcAddress(hntdll, "RtlFindMostSignificantBit");
    pRtlFindLeastSignificantBit = (void *)GetProcAddress(hntdll, "RtlFindLeastSignificantBit");
    pRtlFindSetRuns = (void *)GetProcAddress(hntdll, "RtlFindSetRuns");
    pRtlFindClearRuns = (void *)GetProcAddress(hntdll, "RtlFindClearRuns");
    pRtlFindLongestRunSet = (void *)GetProcAddress(hntdll, "RtlFindLongestRunSet");
    pRtlFindLongestRunClear = (void *)GetProcAddress(hntdll, "RtlFindLongestRunClear");
  }
}

static void test_RtlInitializeBitMap(void)
{
  bm.SizeOfBitMap = 0;
  bm.BitMapBuffer = 0;

  memset(buff, 0, sizeof(buff));
  buff[0] = 77; /* Check buffer is not written to during init */
  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");

  /* 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");
}

static void test_RtlSetAllBits(void)
{
  if (!pRtlSetAllBits)
    return;

  memset(buff, 0 , sizeof(buff));
  pRtlInitializeBitMap(&bm, buff, 1);

  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");

  /* 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");
}

static void test_RtlClearAllBits()
{
  if (!pRtlClearAllBits)
    return;

  memset(buff, 0xff , sizeof(buff));
  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");

  /* 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");
}

static void test_RtlSetBits()
{
  if (!pRtlSetBits)
    return;

  memset(buff, 0 , sizeof(buff));
  pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

  pRtlSetBits(&bm, 0, 1);
  ok(buff[0] == 1, "didnt set 1st bit");

  buff[0] = 0;
  pRtlSetBits(&bm, 7, 2);
  ok(buff[0] == 0x80 && buff[1] == 1, "didnt span w/len < 8");

  buff[0] = buff[1] = 0;
  pRtlSetBits(&bm, 7, 10);
  ok(buff[0] == 0x80 && buff[1] == 0xff && buff[2] == 1, "didnt span w/len > 8");

  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");

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

static void test_RtlClearBits()
{
  if (!pRtlClearBits)
    return;

  memset(buff, 0xff , sizeof(buff));
  pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

  pRtlClearBits(&bm, 0, 1);
  ok(buff[0] == 0xfe, "didnt clear 1st bit");

  buff[0] = 0xff;
  pRtlClearBits(&bm, 7, 2);
  ok(buff[0] == 0x7f && buff[1] == 0xfe, "didnt span w/len < 8");

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

  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");

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

static void test_RtlCheckBit()
{
  BOOLEAN bRet;

  memset(buff, 0 , sizeof(buff));
  pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
  pRtlSetBits(&bm, 0, 1);
  pRtlSetBits(&bm, 7, 2);
  pRtlSetBits(&bm, sizeof(buff)*8-1, 1);

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

static void test_RtlAreBitsSet()
{
  BOOLEAN bRet;

  if (!pRtlAreBitsSet)
    return;

  memset(buff, 0 , sizeof(buff));
  pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

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

  pRtlSetBits(&bm, 0, 1);
  bRet = pRtlAreBitsSet(&bm, 0, 1);
  ok (bRet, "didnt find set bits");

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

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

  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");

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

static void test_RtlAreBitsClear()
{
  BOOLEAN bRet;

  if (!pRtlAreBitsClear)
    return;

  memset(buff, 0xff , sizeof(buff));
  pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

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

  pRtlClearBits(&bm, 0, 1);
  bRet = pRtlAreBitsClear(&bm, 0, 1);
  ok (bRet, "didnt find set bits");

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

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

  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");

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

static void test_RtlNumberOfSetBits()
{
  ULONG ulCount;

  if (!pRtlNumberOfSetBits)
    return;

  memset(buff, 0 , sizeof(buff));
  pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);

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

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

  pRtlSetBits(&bm, 7, 8); /* 8 more, spanning bytes 1-2 */
  ulCount = pRtlNumberOfSetBits(&bm);