rtlbitmap.c

Wine-20031016

  ok(ulCount == 8+1, "count wrong");

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

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

static void test_RtlNumberOfClearBits()
{
  ULONG ulCount;

  if (!pRtlNumberOfClearBits)
    return;

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

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

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

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

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

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

/* Note: this tests RtlFindSetBits also */
static void test_RtlFindSetBitsAndClear()
{
  BOOLEAN bRet;
  ULONG ulPos;

  if (!pRtlFindSetBitsAndClear)
    return;

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

  pRtlSetBits(&bm, 0, 32);
  ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
  ok (ulPos == 0, "didnt find bits");
  if(ulPos == 0)
  {
    bRet = pRtlAreBitsClear(&bm, 0, 32);
    ok (bRet, "found but didnt clear");
  }

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

/* Note: this tests RtlFindClearBits also */
static void test_RtlFindClearBitsAndSet()
{
  BOOLEAN bRet;
  ULONG ulPos;

  if (!pRtlFindClearBitsAndSet)
    return;

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

  memset(buff, 0xff, sizeof(buff));
  pRtlSetBits(&bm, 0, 32);
  ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
  ok (ulPos == 0, "didnt find bits");
  if(ulPos == 0)
  {
      bRet = pRtlAreBitsClear(&bm, 0, 32);
      ok (bRet, "found but didnt clear");
  }

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

static void test_RtlFindMostSignificantBit()
{
  int i;
  CCHAR cPos;
  ULONGLONG ulLong;

  if (!pRtlFindMostSignificantBit)
    return;

  for (i = 0; i < 64; i++)
  {
    ulLong = 1ul;
    ulLong <<= i;

    cPos = pRtlFindMostSignificantBit(ulLong);
    ok (cPos == i, "didnt find MSB %llx %d %d", 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);
  }
  cPos = pRtlFindMostSignificantBit(0);
  ok (cPos == -1, "found bit when not set");
}

static void test_RtlFindLeastSignificantBit()
{
  int i;
  CCHAR cPos;
  ULONGLONG ulLong;

  if (!pRtlFindLeastSignificantBit)
    return;

  for (i = 0; i < 64; i++)
  {
    ulLong = (ULONGLONG)1 << i;

    cPos = pRtlFindLeastSignificantBit(ulLong);
    ok (cPos == i, "didnt find LSB %llx %d %d", ulLong, i, cPos);

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

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

/* Note: Also tests RtlFindLongestRunSet() */
static void test_RtlFindSetRuns()
{
  RTL_BITMAP_RUN runs[16];
  ULONG ulCount;

  if (!pRtlFindSetRuns)
    return;

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

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

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

  /* Set up 3 runs */
  memset(runs, 0, sizeof(runs));
  memset(buff, 0, sizeof(buff));
  pRtlSetBits(&bm, 7, 19);
  pRtlSetBits(&bm, 101, 3);
  pRtlSetBits(&bm, 1877, 33);

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

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

  /* 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");
  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101 ||
      runs[1].StartOfRun == 1877,"bad find");
  ok (runs[2].StartOfRun == 7 || runs[2].StartOfRun == 101 ||
      runs[2].StartOfRun == 1877,"bad find");
  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");

  if (pRtlFindLongestRunSet)
  {
    ULONG ulStart = 0;

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

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

/* Note: Also tests RtlFindLongestRunClear() */
static void test_RtlFindClearRuns()
{
  RTL_BITMAP_RUN runs[16];
  ULONG ulCount;

  if (!pRtlFindClearRuns)
    return;

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

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

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

  /* Set up 3 runs */
  memset(runs, 0, sizeof(runs));
  memset(buff, 0xff, sizeof(buff));
  pRtlClearBits(&bm, 7, 19);
  pRtlClearBits(&bm, 101, 3);
  pRtlClearBits(&bm, 1877, 33);

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

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

  /* 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");
  ok (runs[1].StartOfRun == 7 || runs[1].StartOfRun == 101 ||
      runs[1].StartOfRun == 1877,"bad find");
  ok (runs[2].StartOfRun == 7 || runs[2].StartOfRun == 101 ||
      runs[2].StartOfRun == 1877,"bad find");
  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");

  if (pRtlFindLongestRunClear)
  {
    ULONG ulStart = 0;

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

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

}

START_TEST(rtlbitmap)
{
  InitFunctionPtrs();

  if (pRtlInitializeBitMap)
  {
    test_RtlInitializeBitMap();
    test_RtlSetAllBits();
    test_RtlClearAllBits();
    test_RtlSetBits();
    test_RtlClearBits();
    test_RtlCheckBit();
    test_RtlAreBitsSet();
    test_RtlAreBitsClear();
    test_RtlNumberOfSetBits();
    test_RtlNumberOfClearBits();
    test_RtlFindSetBitsAndClear();
    test_RtlFindClearBitsAndSet();
    test_RtlFindMostSignificantBit();
    test_RtlFindLeastSignificantBit();
    test_RtlFindSetRuns();
    test_RtlFindClearRuns();
  }
}