BitsTest.cpp File Reference

#include <cmath>
#include <folly/experimental/Bits.h>
#include <glog/logging.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
template<class T >
void	runSimpleTest8 ()
	TEST (Bits, Simple8)
	TEST (Bits, SimpleUnaligned8)
template<class T >
void	runSimpleTest64 ()
	TEST (Bits, Simple64)
	TEST (Bits, SimpleUnaligned64)
template<class T >
void	runMultiBitTest8 ()
	TEST (Bits, MultiBit8)
	TEST (Bits, MultiBitUnaligned8)
template<class T >
void	runSignedMultiBitTest8 ()
	TEST (Bits, SignedMultiBit8)
template<class T , class R = T>
void	runMultiBitTest64 ()
	TEST (Bits, MultiBit64)
	TEST (Bits, MultiBitSigned64)
	TEST (Bits, MultiBitUnaligned64)
	TEST (Bits, Boundaries)
template<size_t N>
void	accSize (size_t &w)
template<size_t N, typename T , bool NEG, bool aligned>
void	testSetLoop (size_t &w, size_t bufSize, uint8_t *buf)
template<size_t N, typename T , bool NEG, bool aligned>
void	testGetLoop (size_t &r, size_t bufSize, uint8_t *buf)
template<bool aligned>
void	testConcatenation ()
	TEST (Bits, ConcatenationUnalignedUnsigned)
	TEST (Bits, ConcatenationAligned)
int	main (int argc, char *argv[])

Function Documentation

template<size_t N>

void accSize

(

size_t &

w

)

Definition at line 263 of file BitsTest.cpp.

References s.

                        {
  for (size_t s = 0; s <= N; ++s) {
    w += s;
  }
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 374 of file BitsTest.cpp.

References testing::InitGoogleTest(), and RUN_ALL_TESTS().

                                 {
  testing::InitGoogleTest(&argc, argv);
  gflags::ParseCommandLineFlags(&argc, &argv, true);
  return RUN_ALL_TESTS();
}

template<class T , class R = T>

void runMultiBitTest64

(

)

Definition at line 182 of file BitsTest.cpp.

References EXPECT_EQ, deadlock::load(), folly::Bits< T, Traits >::set(), and folly::T.

                         {
  auto load = detail::BitsTraits<T>::load;
  T buf[] = {0x123456789abcdef0, 0x13579bdf2468ace0};

  EXPECT_EQ(0x123456789abcdef0, load(Bits<T>::get(buf, 0, 64)));
  EXPECT_EQ(0xf0, load(Bits<T>::get(buf, 0, 8)));
  EXPECT_EQ(0x89abcdef, load(Bits<T>::get(buf, 4, 32)));
  EXPECT_EQ(0x189abcdef, load(Bits<T>::get(buf, 4, 33)));

  Bits<T>::set(buf, 4, 31, 0x55555555);
  EXPECT_EQ(0xd5555555, load(Bits<T>::get(buf, 4, 32)));
  EXPECT_EQ(0x1d5555555, load(Bits<T>::get(buf, 4, 33)));
  EXPECT_EQ(0xd55555550, load(Bits<T>::get(buf, 0, 36)));

  Bits<T>::set(buf, 0, 64, 0x23456789abcdef01);
  EXPECT_EQ(0x23456789abcdef01, load(Bits<T>::get(buf, 0, 64)));
}

template<class T >

void runMultiBitTest8

(

)

Definition at line 114 of file BitsTest.cpp.

References EXPECT_EQ, deadlock::load(), folly::Bits< T, Traits >::set(), and folly::T.

                        {
  auto load = detail::BitsTraits<T>::load;
  T buf[] = {0x12, 0x34, 0x56, 0x78};

  EXPECT_EQ(0x02, load(Bits<T>::get(buf, 0, 4)));
  EXPECT_EQ(0x1a, load(Bits<T>::get(buf, 9, 5)));
  EXPECT_EQ(0xb1, load(Bits<T>::get(buf, 13, 8)));

  Bits<T>::set(buf, 0, 4, 0x0b);
  EXPECT_EQ(0x1b, load(buf[0]));
  EXPECT_EQ(0x34, load(buf[1]));
  EXPECT_EQ(0x56, load(buf[2]));
  EXPECT_EQ(0x78, load(buf[3]));

  Bits<T>::set(buf, 9, 5, 0x0e);
  EXPECT_EQ(0x1b, load(buf[0]));
  EXPECT_EQ(0x1c, load(buf[1]));
  EXPECT_EQ(0x56, load(buf[2]));
  EXPECT_EQ(0x78, load(buf[3]));

  Bits<T>::set(buf, 13, 8, 0xaa);
  EXPECT_EQ(0x1b, load(buf[0]));
  EXPECT_EQ(0x5c, load(buf[1]));
  EXPECT_EQ(0x55, load(buf[2]));
  EXPECT_EQ(0x78, load(buf[3]));
}

template<class T >

void runSignedMultiBitTest8

(

)

Definition at line 150 of file BitsTest.cpp.

References EXPECT_EQ, deadlock::load(), folly::Bits< T, Traits >::set(), and folly::T.

                              {
  auto load = detail::BitsTraits<T>::load;
  T buf[] = {0x12, 0x34, 0x56, 0x78};

  EXPECT_EQ(0x02, load(Bits<T>::get(buf, 0, 4)));
  EXPECT_EQ(0x1a - 32, load(Bits<T>::get(buf, 9, 5)));
  EXPECT_EQ(0xb1 - 256, load(Bits<T>::get(buf, 13, 8)));

  Bits<T>::set(buf, 0, 4, 0x0b - 0x10);
  EXPECT_EQ(0x1b, load(buf[0]));
  EXPECT_EQ(0x34, load(buf[1]));
  EXPECT_EQ(0x56, load(buf[2]));
  EXPECT_EQ(0x78, load(buf[3]));

  Bits<T>::set(buf, 9, 5, 0x0e);
  EXPECT_EQ(0x1b, load(buf[0]));
  EXPECT_EQ(0x1c, load(buf[1]));
  EXPECT_EQ(0x56, load(buf[2]));
  EXPECT_EQ(0x78, load(buf[3]));

  Bits<T>::set(buf, 13, 8, 0xaa - 0x100);
  EXPECT_EQ(0x1b, load(buf[0]));
  EXPECT_EQ(0x5c, load(buf[1]));
  EXPECT_EQ(0x55, load(buf[2]));
  EXPECT_EQ(0x78, load(buf[3]));
}

template<class T >

void runSimpleTest64

(

)

Definition at line 69 of file BitsTest.cpp.

References folly::Bits< T, Traits >::clear(), EXPECT_EQ, deadlock::load(), folly::Bits< T, Traits >::set(), folly::T, and uint64_t.

                       {
  auto load = detail::BitsTraits<T>::load;

  EXPECT_EQ(0, Bits<T>::blockCount(0));
  EXPECT_EQ(1, Bits<T>::blockCount(1));
  EXPECT_EQ(1, Bits<T>::blockCount(8));
  EXPECT_EQ(1, Bits<T>::blockCount(9));
  EXPECT_EQ(1, Bits<T>::blockCount(64));
  EXPECT_EQ(2, Bits<T>::blockCount(65));
  EXPECT_EQ(32, Bits<T>::blockCount(2048));
  EXPECT_EQ(33, Bits<T>::blockCount(2049));

  EXPECT_EQ(0, Bits<T>::blockIndex(39));
  EXPECT_EQ(39, Bits<T>::bitOffset(39));
  EXPECT_EQ(4, Bits<T>::blockIndex(319));
  EXPECT_EQ(63, Bits<T>::bitOffset(319));
  EXPECT_EQ(5, Bits<T>::blockIndex(320));
  EXPECT_EQ(0, Bits<T>::bitOffset(320));

  T buf[256];
  std::fill(buf, buf + 256, T(0));

  Bits<T>::set(buf, 300);
  Bits<T>::set(buf, 319);
  EXPECT_EQ((uint64_t(1) << 44) | (uint64_t(1) << 63), load(buf[4]));
  EXPECT_EQ(0, load(buf[5]));
  Bits<T>::clear(buf, 319);
  EXPECT_EQ(uint64_t(1) << 44, load(buf[4]));
  EXPECT_EQ(0, load(buf[5]));
  Bits<T>::set(buf, 320);
  EXPECT_EQ(uint64_t(1) << 44, load(buf[4]));
  EXPECT_EQ(1, load(buf[5]));

  EXPECT_EQ(2, Bits<T>::count(buf, buf + 256));
}

template<class T >

void runSimpleTest8

(

)

Definition at line 28 of file BitsTest.cpp.

References folly::Bits< T, Traits >::clear(), EXPECT_EQ, deadlock::load(), folly::Bits< T, Traits >::set(), and folly::T.

                      {
  auto load = detail::BitsTraits<T>::load;

  EXPECT_EQ(0, Bits<T>::blockCount(0));
  EXPECT_EQ(1, Bits<T>::blockCount(1));
  EXPECT_EQ(1, Bits<T>::blockCount(8));
  EXPECT_EQ(2, Bits<T>::blockCount(9));
  EXPECT_EQ(256, Bits<T>::blockCount(2048));
  EXPECT_EQ(257, Bits<T>::blockCount(2049));

  EXPECT_EQ(4, Bits<T>::blockIndex(39));
  EXPECT_EQ(7, Bits<T>::bitOffset(39));
  EXPECT_EQ(5, Bits<T>::blockIndex(40));
  EXPECT_EQ(0, Bits<T>::bitOffset(40));

  T buf[256];
  std::fill(buf, buf + 256, T(0));

  Bits<T>::set(buf, 36);
  Bits<T>::set(buf, 39);
  EXPECT_EQ((1 << 7) | (1 << 4), load(buf[4]));
  EXPECT_EQ(0, load(buf[5]));
  Bits<T>::clear(buf, 39);
  EXPECT_EQ(1 << 4, load(buf[4]));
  EXPECT_EQ(0, load(buf[5]));
  Bits<T>::set(buf, 40);
  EXPECT_EQ(1 << 4, load(buf[4]));
  EXPECT_EQ(1, load(buf[5]));

  EXPECT_EQ(2, Bits<T>::count(buf, buf + 256));
}

TEST	(	Bits	,
		Simple8
	)

Definition at line 60 of file BitsTest.cpp.

                    {
  runSimpleTest8<uint8_t>();
}

TEST	(	Bits	,
		SimpleUnaligned8
	)

Definition at line 64 of file BitsTest.cpp.

                             {
  runSimpleTest8<Unaligned<uint8_t>>();
}

TEST	(	Bits	,
		Simple64
	)

Definition at line 105 of file BitsTest.cpp.

                     {
  runSimpleTest64<uint64_t>();
}

TEST	(	Bits	,
		SimpleUnaligned64
	)

Definition at line 109 of file BitsTest.cpp.

                              {
  runSimpleTest64<Unaligned<uint64_t>>();
}

TEST	(	Bits	,
		MultiBit8
	)

Definition at line 141 of file BitsTest.cpp.

                      {
  runMultiBitTest8<uint8_t>();
}

TEST	(	Bits	,
		MultiBitUnaligned8
	)

Definition at line 145 of file BitsTest.cpp.

                               {
  runMultiBitTest8<Unaligned<uint8_t>>();
}

TEST	(	Bits	,
		SignedMultiBit8
	)

Definition at line 177 of file BitsTest.cpp.

                            {
  runSignedMultiBitTest8<int8_t>();
}

TEST	(	Bits	,
		MultiBit64
	)

Definition at line 200 of file BitsTest.cpp.

                       {
  runMultiBitTest64<uint64_t>();
}

TEST	(	Bits	,
		MultiBitSigned64
	)

Definition at line 204 of file BitsTest.cpp.

                             {
  // runMultiBitTest64<int64_t>();
}

TEST	(	Bits	,
		MultiBitUnaligned64
	)

Definition at line 208 of file BitsTest.cpp.

References folly::Bits< T, Traits >::get(), folly::pushmi::operators::get, max, min, folly::gen::negate(), cpp.gmock_class::set, folly::Bits< T, Traits >::set(), start, folly::T, type, uint64_t, uint8_t, value, and folly::value().

                                {
  runMultiBitTest64<Unaligned<uint64_t>, uint64_t>();
}

TEST	(	Bits	,
		Boundaries
	)

Definition at line 251 of file BitsTest.cpp.

References EXPECT_EQ, int32_t, folly::size(), uint8_t, and folly::value().

                       {
  uint8_t buf[20];
  for (size_t offset = 0; offset <= 64; ++offset) {
    for (size_t size = 0; size <= 32; ++size) {
      int32_t value = testValue<int32_t>(size);
      testSet<true>(buf, offset, size, value);
      EXPECT_EQ(value, (testGet<true, int32_t>(buf, offset, size)));
    }
  }
}

TEST	(	Bits	,
		ConcatenationUnalignedUnsigned
	)

Definition at line 366 of file BitsTest.cpp.

                                           {
  testConcatenation<false>();
}

TEST	(	Bits	,
		ConcatenationAligned
	)

Definition at line 370 of file BitsTest.cpp.

                                 {
  testConcatenation<true>();
}

template<bool aligned>

void testConcatenation

(

)

Definition at line 289 of file BitsTest.cpp.

References buffer(), and uint8_t.

                         {
  // concatenate fields of length 1, 2, 3, ... 64, all unsigned, storing 2/3s
  // the maximum value in each.

  // calculate how much buffer size we need
  size_t bufSize = 0;
  {
    size_t w = 0;
    // Unsigned
    accSize<8>(w);
    accSize<16>(w);
    accSize<32>(w);
    accSize<64>(w);

    // Signed NEG=false
    accSize<7>(w);
    accSize<15>(w);
    accSize<31>(w);
    accSize<63>(w);

    // Signed NEG=true
    accSize<7>(w);
    accSize<15>(w);
    accSize<31>(w);
    accSize<63>(w);

    bufSize = w;
  }
  // bits->bytes, rounding up
  bufSize = (bufSize + 7) / 8;
  // round up to next multiple of 8
  bufSize = (bufSize + 7) / 8 * 8;
  std::vector<uint8_t> buffer(bufSize);
  uint8_t* buf = buffer.data();
  {
    size_t w = 0;
    // Unsigned
    testSetLoop<8, uint8_t, false, aligned>(w, bufSize, buf);
    testSetLoop<16, uint16_t, false, aligned>(w, bufSize, buf);
    testSetLoop<32, uint32_t, false, aligned>(w, bufSize, buf);
    testSetLoop<64, uint64_t, false, aligned>(w, bufSize, buf);

    // Signed NEG=false
    testSetLoop<7, int8_t, false, aligned>(w, bufSize, buf);
    testSetLoop<15, int16_t, false, aligned>(w, bufSize, buf);
    testSetLoop<31, int32_t, false, aligned>(w, bufSize, buf);
    testSetLoop<63, int64_t, false, aligned>(w, bufSize, buf);

    // Signed NEG=true
    testSetLoop<7, int8_t, true, aligned>(w, bufSize, buf);
    testSetLoop<15, int16_t, true, aligned>(w, bufSize, buf);
    testSetLoop<31, int32_t, true, aligned>(w, bufSize, buf);
    testSetLoop<63, int64_t, true, aligned>(w, bufSize, buf);
  }

  {
    size_t r = 0;
    // Unsigned
    testGetLoop<8, uint8_t, false, aligned>(r, bufSize, buf);
    testGetLoop<16, uint16_t, false, aligned>(r, bufSize, buf);
    testGetLoop<32, uint32_t, false, aligned>(r, bufSize, buf);
    testGetLoop<64, uint64_t, false, aligned>(r, bufSize, buf);

    // Signed NEG=false
    testGetLoop<7, int8_t, false, aligned>(r, bufSize, buf);
    testGetLoop<15, int16_t, false, aligned>(r, bufSize, buf);
    testGetLoop<31, int32_t, false, aligned>(r, bufSize, buf);
    testGetLoop<63, int64_t, false, aligned>(r, bufSize, buf);

    // Signed NEG=true
    testGetLoop<7, int8_t, true, aligned>(r, bufSize, buf);
    testGetLoop<15, int16_t, true, aligned>(r, bufSize, buf);
    testGetLoop<31, int32_t, true, aligned>(r, bufSize, buf);
    testGetLoop<63, int64_t, true, aligned>(r, bufSize, buf);
  }
}

template<size_t N, typename T , bool NEG, bool aligned>

void testGetLoop	(	size_t &	r,
		size_t	bufSize,
		uint8_t *	buf
	)

Definition at line 280 of file BitsTest.cpp.

References EXPECT_EQ, and s.

                                                          {
  for (size_t s = 0; s <= N; ++s) {
    CHECK_LE(s + r, 8 * bufSize);
    EXPECT_EQ((testValue<T, NEG>(s)), (testGet<aligned, T>(buf, r, s))) << s;
    r += s;
  }
}

template<size_t N, typename T , bool NEG, bool aligned>

void testSetLoop	(	size_t &	w,
		size_t	bufSize,
		uint8_t *	buf
	)

Definition at line 270 of file BitsTest.cpp.

References EXPECT_EQ, and s.

                                                          {
  for (size_t s = 0; s <= N; ++s) {
    CHECK_LE(s + w, 8 * bufSize) << s << ' ' << w << ' ' << bufSize;
    testSet<aligned>(buf, w, s, testValue<T, NEG>(s));
    EXPECT_EQ((testValue<T, NEG>(s)), (testGet<aligned, T>(buf, w, s))) << s;
    w += s;
  }
}