test_ransBitPtr.cxx

Go to the documentation of this file.

// Copyright 2019-2023 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#define BOOST_TEST_MODULE Utility test
#define BOOST_TEST_MAIN
#define BOOST_TEST_DYN_LINK
 
#undef NDEBUG
#include <cassert>
 
#include <boost/test/unit_test.hpp>
#include <boost/mp11.hpp>
 
#include "rANS/internal/containers/BitPtr.h"
 
using namespace o2::rans;
using namespace o2::rans::internal;
using namespace o2::rans::utils;
 
using source_types = boost::mp11::mp_list<int8_t, int16_t, int32_t>;
 
BOOST_AUTO_TEST_CASE_TEMPLATE(test_BitPtrConstructors, source_type, source_types)
{
  BitPtr bitPtr{};
  BOOST_CHECK_EQUAL(bitPtr.getBitAddress(), 0);
  BOOST_CHECK_EQUAL(bitPtr.toPtr<source_type>(), nullptr);
  BOOST_CHECK_EQUAL(bitPtr.getOffset<source_type>(), 0);
 
  source_type* ptr = nullptr;
  bitPtr = BitPtr{ptr};
  BOOST_CHECK_EQUAL(bitPtr.getBitAddress(), 0);
  BOOST_CHECK_EQUAL(bitPtr.toPtr<source_type>(), nullptr);
  BOOST_CHECK_EQUAL(bitPtr.getOffset<source_type>(), 0);
 
  source_type v{};
  ptr = &v;
  bitPtr = BitPtr{ptr};
  BOOST_CHECK_EQUAL(bitPtr.getBitAddress(), adr2Bits(ptr));
  BOOST_CHECK_EQUAL(bitPtr.toPtr<source_type>(), ptr);
  BOOST_CHECK_EQUAL(bitPtr.getOffset<source_type>(), 0);
 
  intptr_t offset = 6;
  bitPtr = BitPtr{ptr, offset};
  BOOST_CHECK_EQUAL(bitPtr.getBitAddress(), adr2Bits(ptr) + offset);
  BOOST_CHECK_EQUAL(bitPtr.toPtr<source_type>(), ptr);
  BOOST_CHECK_EQUAL(bitPtr.getOffset<source_type>(), offset);
 
  offset = 13;
  bitPtr = BitPtr{ptr, offset};
  BOOST_CHECK_EQUAL(bitPtr.getBitAddress(), adr2Bits(ptr) + offset);
 
  if constexpr (sizeof(source_type) == 1) {
    BOOST_CHECK_EQUAL(bitPtr.toPtr<source_type>(), ptr + 1);
    BOOST_CHECK_EQUAL(bitPtr.getOffset<source_type>(), offset - 8);
  } else {
    BOOST_CHECK_EQUAL(bitPtr.toPtr<source_type>(), ptr);
    BOOST_CHECK_EQUAL(bitPtr.getOffset<source_type>(), offset);
  }
};
 
BOOST_AUTO_TEST_CASE_TEMPLATE(test_BitPtr, source_type, source_types)
{
  source_type v[5]{};
  source_type* smallPtr = &v[0];
  source_type* bigPtr = &v[4];
  BitPtr smallBitPtr{smallPtr};
  BitPtr bigBitPtr{bigPtr};
 
  BitPtr smallBitPtrPlusOne{smallPtr, 1};
 
  // test equal
  BOOST_CHECK_EQUAL(smallBitPtr, smallBitPtr);
  // test not equal
  BOOST_CHECK_NE(smallBitPtr, bigBitPtr);
  // test smaller
  BOOST_CHECK_LT(smallBitPtr, bigBitPtr);
  // test greater
  BOOST_CHECK_GT(bigBitPtr, smallBitPtr);
  // test greater-equals
  BOOST_CHECK_GE(bigBitPtr, smallBitPtr);
  BOOST_CHECK_GE(smallBitPtr, smallBitPtr);
  // test smaller-equals
  BOOST_CHECK_LE(smallBitPtr, bigBitPtr);
  BOOST_CHECK_LE(smallBitPtr, smallBitPtr);
 
  // test pre-increment
  BitPtr ptr = smallBitPtr;
  ++ptr;
  BOOST_CHECK_EQUAL(ptr, smallBitPtrPlusOne);
  // test post-increment
  ptr = smallBitPtr;
  BOOST_CHECK_EQUAL(ptr++, smallBitPtr);
  BOOST_CHECK_EQUAL(ptr, smallBitPtrPlusOne);
  // test pre-decrement
  ptr = smallBitPtrPlusOne;
  --ptr;
  BOOST_CHECK_EQUAL(ptr, smallBitPtr);
  // test post-decrement
  ptr = smallBitPtrPlusOne;
  BOOST_CHECK_EQUAL(ptr--, smallBitPtrPlusOne);
  BOOST_CHECK_EQUAL(ptr, smallBitPtr);
 
  intptr_t increment = toBits((bigPtr - smallPtr) * sizeof(source_type));
 
  // test +=
  ptr = smallBitPtr;
  ptr += increment;
  BOOST_CHECK_EQUAL(ptr, bigBitPtr);
  // test +
  ptr = smallBitPtr;
  BOOST_CHECK_EQUAL(smallBitPtr + increment, bigBitPtr);
  BOOST_CHECK_EQUAL(increment + smallBitPtr, bigBitPtr);
 
  // check -=
  ptr = bigBitPtr;
  ptr -= increment;
  BOOST_CHECK_EQUAL(ptr, smallBitPtr);
 
  // check -
  BOOST_CHECK_EQUAL(bigBitPtr - increment, smallBitPtr);
 
  // check -
  BOOST_CHECK_EQUAL(bigBitPtr - smallBitPtr, increment);
}
 
BOOST_AUTO_TEST_CASE_TEMPLATE(test_BitPtrCasts, source_type, source_types)
{
  source_type v[5]{};
 
  intptr_t distance = 3;
  intptr_t bitDistance = toBits<source_type>();
 
  const BitPtr begin{&v[0]};
  const BitPtr belowMinus{&v[1], -distance};
  const BitPtr below{&v[1]};
  BOOST_CHECK_EQUAL(begin.toPtr<source_type>(), belowMinus.toPtr<source_type>());
  const BitPtr ptr{&v[2]};
  const BitPtr above{&v[3]};
  const BitPtr abovePlus{&v[3], distance};
  BOOST_CHECK_EQUAL(abovePlus.toPtr<source_type>(), above.toPtr<source_type>());
 
  BOOST_CHECK_EQUAL(ptr - (bitDistance + distance), belowMinus);
  BOOST_CHECK_EQUAL(ptr - (bitDistance), below);
  BOOST_CHECK_EQUAL(ptr + (bitDistance), above);
  BOOST_CHECK_EQUAL(ptr + (bitDistance + distance), abovePlus);
}