src/base/intmath.test.cc - public/gem5 - Git at Google

 /*
  * Copyright (c) 2021 ARM Limited
  *
  * The license below extends only to copyright in the software and shall
  * not be construed as granting a license to any other intellectual
  * property including but not limited to intellectual property relating
  * to a hardware implementation of the functionality of the software
  * licensed hereunder.  You may use the software subject to the license
  * terms below provided that you ensure that this notice is replicated
  * unmodified and in its entirety in all distributions of the software,
  * modified or unmodified, in source code or in binary form.
  *
  * Copyright (c) 2019 The Regents of the University of California
  * All rights reserved
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met: redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer;
  * redistributions in binary form must reproduce the above copyright
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution;
  * neither the name of the copyright holders nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include <gtest/gtest.h>
 #include <tuple>

 #include "base/intmath.hh"

 using namespace gem5;

 TEST(IntmathTest, isPowerOf2)
 {
     EXPECT_TRUE(isPowerOf2(1));
     EXPECT_TRUE(isPowerOf2(32));
     EXPECT_TRUE(isPowerOf2(65536));
     EXPECT_TRUE(isPowerOf2(131072));
     EXPECT_TRUE(isPowerOf2(262144));
     EXPECT_FALSE(isPowerOf2(0));
     EXPECT_FALSE(isPowerOf2(36));
     EXPECT_FALSE(isPowerOf2(2521));
     EXPECT_FALSE(isPowerOf2(1679616));
 }

 TEST(IntmathTest, floorLog2)
 {
     EXPECT_EQ(0, floorLog2(1));
     EXPECT_EQ(4, floorLog2(16));
     EXPECT_EQ(4, floorLog2(31));
     EXPECT_EQ(5, floorLog2(36));
     EXPECT_EQ(8, floorLog2(436));
     EXPECT_EQ(16, floorLog2(65537));
     EXPECT_EQ(20, floorLog2(1783592));
     EXPECT_EQ(41, floorLog2(2821109907456));

     // Test unsigned integers of various sizes.
     EXPECT_EQ(0, floorLog2((uint8_t)1));
     EXPECT_EQ(0, floorLog2((uint16_t)1));
     EXPECT_EQ(0, floorLog2((uint32_t)1));
     EXPECT_EQ(0, floorLog2((uint64_t)1));

     // Test signed integers of various sizes.
     EXPECT_EQ(0, floorLog2((int8_t)1));
     EXPECT_EQ(0, floorLog2((int16_t)1));
     EXPECT_EQ(0, floorLog2((int32_t)1));
     EXPECT_EQ(0, floorLog2((int64_t)1));
 }

 /* The IntmathDeathTest floorLog2 test is dependent on an assert being
  * triggered. We therefore only run this test for .debug and .opt (where
  * `TRACING_ON == 1`).
  */
 #if TRACING_ON
 TEST(IntmathDeathTest, floorLog2)
 {
     // Verify a non-positive input triggers an assert.
     EXPECT_DEATH_IF_SUPPORTED(floorLog2(0), "x > 0");
 }
 #endif

 TEST(IntmathTest, ceilLog2)
 {
     EXPECT_EQ(0, ceilLog2(1));
     EXPECT_EQ(4, ceilLog2(16));
     EXPECT_EQ(5, ceilLog2(31));
     EXPECT_EQ(6, ceilLog2(36));
     EXPECT_EQ(9, ceilLog2(436));
     EXPECT_EQ(17, ceilLog2(65537));
     EXPECT_EQ(21, ceilLog2(1783592));
     EXPECT_EQ(42, ceilLog2(2821109907456));
 }


 TEST(IntmathTest, divCeil)
 {
     EXPECT_EQ(5, divCeil(55, 13));
     EXPECT_EQ(90, divCeil(7922, 89));
     EXPECT_EQ(4, divCeil(4800, 1442));
     EXPECT_EQ(4, divCeil(75, 24));
     EXPECT_EQ(46, divCeil(451, 10));
 }

 TEST(IntmathTest, mulUnsignedNarrow)
 {
     uint8_t a = 0xff;
     uint8_t b = 0x02;
     uint8_t hi;
     uint8_t low;
     mulUnsigned<uint8_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0x1);
     EXPECT_EQ(low, 0xfe);

     a = 14;
     b = 9;
     mulUnsigned<uint8_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0);
     EXPECT_EQ(low, 0x7e);

     a = 0;
     b = 0x55;
     mulUnsigned<uint8_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0);
     EXPECT_EQ(low, 0);
 }

 TEST(IntmathTest, mulSignedNarrow)
 {
     int8_t a = -0x80;
     int8_t b = -0x7f;
     int8_t hi;
     int8_t low;
     mulSigned<int8_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0x3f);
     EXPECT_EQ(low, -0x80);

     a = 14;
     b = -9;
     mulSigned<int8_t>(hi, low, a, b);
     EXPECT_EQ(hi, -0x01);
     EXPECT_EQ(low, -0x7e);

     a = 0;
     b = -0x55;
     mulSigned<int8_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0);
     EXPECT_EQ(low, 0);
 }

 TEST(IntmathTest, mulUnsignedMid)
 {
     uint32_t a = 0xffffffffULL;
     uint32_t b = 0x00000002ULL;
     uint32_t hi;
     uint32_t low;
     mulUnsigned<uint32_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0x1);
     EXPECT_EQ(low, 0xfffffffe);

     a = 68026386;
     b = 5152;
     mulUnsigned<uint32_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0x51);
     EXPECT_EQ(low, 0x99c16a40);

     a = 0;
     b = 0x55555555;
     mulUnsigned<uint32_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0);
     EXPECT_EQ(low, 0);
 }

 TEST(IntmathTest, mulSignedMid)
 {
     int32_t a = -0x80000000;
     int32_t b = -0x7fffffff;
     int32_t hi;
     int32_t low;
     mulSigned<int32_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0x3fffffff);
     EXPECT_EQ(low, -0x80000000);

     a = -68026386;
     b = 5152;
     mulSigned<int32_t>(hi, low, a, b);
     EXPECT_EQ(hi, -0x52);
     EXPECT_EQ(low, -0x99c16a40);

     a = 0;
     b = -0x55555555;
     mulSigned<int32_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0);
     EXPECT_EQ(low, 0);
 }

 TEST(IntmathTest, mulUnsignedWide)
 {
     uint64_t a = 0xffffffffffffffffULL;
     uint64_t b = 0x0000000000000002ULL;
     uint64_t hi;
     uint64_t low;
     mulUnsigned<uint64_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0x1);
     EXPECT_EQ(low, 0xfffffffffffffffe);

     hi = 0;
     low = 0;
     mulUnsignedManual<uint64_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0x1);
     EXPECT_EQ(low, 0xfffffffffffffffe);

     hi = 0;
     low = 0;
     std::tie(hi, low) = mulUnsigned<uint64_t>(a, b);
     EXPECT_EQ(hi, 0x1);
     EXPECT_EQ(low, 0xfffffffffffffffe);

     a = 0;
     b = 0x5555555555555555;
     mulUnsigned<uint64_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0);
     EXPECT_EQ(low, 0);
 }

 TEST(IntmathTest, mulSignedWide)
 {
     int64_t a = -0x8000000000000000;
     int64_t b = -0x7fffffffffffffff;
     int64_t hi;
     int64_t low;
     mulSigned<int64_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0x3fffffffffffffff);
     EXPECT_EQ(low, -0x8000000000000000);

     hi = 0;
     low = 0;
     mulSignedManual<int64_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0x3fffffffffffffff);
     EXPECT_EQ(low, -0x8000000000000000);

     hi = 0;
     low = 0;
     std::tie(hi, low) = mulSigned<int64_t>(a, b);
     EXPECT_EQ(hi, 0x3fffffffffffffff);
     EXPECT_EQ(low, -0x8000000000000000);

     a = 0;
     b = -0x5555555555555555;
     mulSigned<int64_t>(hi, low, a, b);
     EXPECT_EQ(hi, 0);
     EXPECT_EQ(low, 0);
 }

 TEST(IntmathTest, roundUp)
 {
     EXPECT_EQ(4104, roundUp(4101, 4));
     EXPECT_EQ(4112, roundUp(4105, 8));
     EXPECT_EQ(4112, roundUp(4101, 16));
     EXPECT_EQ(8192, roundUp(7991, 256));
 }

 TEST(IntmathTest, roundDown)
 {
     EXPECT_EQ(4100, roundDown(4101, 4));
     EXPECT_EQ(4104, roundDown(4105, 8));
     EXPECT_EQ(4096, roundDown(4101, 16));
     EXPECT_EQ(7936, roundDown(7991, 256));
 }

 /** This is testing if log2i actually works.
  * at every iteration value is multiplied by 2 (left shift) and expected
  * is incremented by one. This until value reaches becomes negative (by
  * left shifting) which is when expected points to the MSB
  */
 TEST(IntmathTest, Log2i)
 {
     int expected = 0;
     for (int value = 1; value > 0; expected++, value <<= 1) {
         EXPECT_EQ(expected, log2i(value));
     }

     // Just as a sanity check for expected to point to the MSB
     EXPECT_EQ(expected, sizeof(int) * 8 - 1);
 }

 /** This is testing the assertions: what if invalid arguments are
  * provided to log2i:
  *
  * 1) value = 0
  * 2) value < 0
  * 3) value is not a power of 2
  */
 TEST(IntmathDeathTest, Log2iDeath)
 {

 #ifdef NDEBUG
     GTEST_SKIP() << "Skipping as assertions are "
         "stripped out of fast builds";
 #endif

     // 1) value = 0
     EXPECT_DEATH({
         const int value = 0;
         log2i(value);
     }, "value > 0.*failed");

     // 2) value < 0
     EXPECT_DEATH({
         const int value = -1;
         log2i(value);
     }, "value > 0.*failed");

     // 3) value is not a power of 2
     EXPECT_DEATH({
         const int value = 5;
         log2i(value);
     }, "isPowerOf2");
 }
	/*
	* Copyright (c) 2021 ARM Limited
	*
	* The license below extends only to copyright in the software and shall
	* not be construed as granting a license to any other intellectual
	* property including but not limited to intellectual property relating
	* to a hardware implementation of the functionality of the software
	* licensed hereunder. You may use the software subject to the license
	* terms below provided that you ensure that this notice is replicated
	* unmodified and in its entirety in all distributions of the software,
	* modified or unmodified, in source code or in binary form.
	*
	* Copyright (c) 2019 The Regents of the University of California
	* All rights reserved
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met: redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer;
	* redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution;
	* neither the name of the copyright holders nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <gtest/gtest.h>
	#include <tuple>

	#include "base/intmath.hh"

	using namespace gem5;

	TEST(IntmathTest, isPowerOf2)
	{
	EXPECT_TRUE(isPowerOf2(1));
	EXPECT_TRUE(isPowerOf2(32));
	EXPECT_TRUE(isPowerOf2(65536));
	EXPECT_TRUE(isPowerOf2(131072));
	EXPECT_TRUE(isPowerOf2(262144));
	EXPECT_FALSE(isPowerOf2(0));
	EXPECT_FALSE(isPowerOf2(36));
	EXPECT_FALSE(isPowerOf2(2521));
	EXPECT_FALSE(isPowerOf2(1679616));
	}

	TEST(IntmathTest, floorLog2)
	{
	EXPECT_EQ(0, floorLog2(1));
	EXPECT_EQ(4, floorLog2(16));
	EXPECT_EQ(4, floorLog2(31));
	EXPECT_EQ(5, floorLog2(36));
	EXPECT_EQ(8, floorLog2(436));
	EXPECT_EQ(16, floorLog2(65537));
	EXPECT_EQ(20, floorLog2(1783592));
	EXPECT_EQ(41, floorLog2(2821109907456));

	// Test unsigned integers of various sizes.
	EXPECT_EQ(0, floorLog2((uint8_t)1));
	EXPECT_EQ(0, floorLog2((uint16_t)1));
	EXPECT_EQ(0, floorLog2((uint32_t)1));
	EXPECT_EQ(0, floorLog2((uint64_t)1));

	// Test signed integers of various sizes.
	EXPECT_EQ(0, floorLog2((int8_t)1));
	EXPECT_EQ(0, floorLog2((int16_t)1));
	EXPECT_EQ(0, floorLog2((int32_t)1));
	EXPECT_EQ(0, floorLog2((int64_t)1));
	}

	/* The IntmathDeathTest floorLog2 test is dependent on an assert being
	* triggered. We therefore only run this test for .debug and .opt (where
	* `TRACING_ON == 1`).
	*/
	#if TRACING_ON
	TEST(IntmathDeathTest, floorLog2)
	{
	// Verify a non-positive input triggers an assert.
	EXPECT_DEATH_IF_SUPPORTED(floorLog2(0), "x > 0");
	}
	#endif

	TEST(IntmathTest, ceilLog2)
	{
	EXPECT_EQ(0, ceilLog2(1));
	EXPECT_EQ(4, ceilLog2(16));
	EXPECT_EQ(5, ceilLog2(31));
	EXPECT_EQ(6, ceilLog2(36));
	EXPECT_EQ(9, ceilLog2(436));
	EXPECT_EQ(17, ceilLog2(65537));
	EXPECT_EQ(21, ceilLog2(1783592));
	EXPECT_EQ(42, ceilLog2(2821109907456));
	}


	TEST(IntmathTest, divCeil)
	{
	EXPECT_EQ(5, divCeil(55, 13));
	EXPECT_EQ(90, divCeil(7922, 89));
	EXPECT_EQ(4, divCeil(4800, 1442));
	EXPECT_EQ(4, divCeil(75, 24));
	EXPECT_EQ(46, divCeil(451, 10));
	}

	TEST(IntmathTest, mulUnsignedNarrow)
	{
	uint8_t a = 0xff;
	uint8_t b = 0x02;
	uint8_t hi;
	uint8_t low;
	mulUnsigned<uint8_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0x1);
	EXPECT_EQ(low, 0xfe);

	a = 14;
	b = 9;
	mulUnsigned<uint8_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0);
	EXPECT_EQ(low, 0x7e);

	a = 0;
	b = 0x55;
	mulUnsigned<uint8_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0);
	EXPECT_EQ(low, 0);
	}

	TEST(IntmathTest, mulSignedNarrow)
	{
	int8_t a = -0x80;
	int8_t b = -0x7f;
	int8_t hi;
	int8_t low;
	mulSigned<int8_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0x3f);
	EXPECT_EQ(low, -0x80);

	a = 14;
	b = -9;
	mulSigned<int8_t>(hi, low, a, b);
	EXPECT_EQ(hi, -0x01);
	EXPECT_EQ(low, -0x7e);

	a = 0;
	b = -0x55;
	mulSigned<int8_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0);
	EXPECT_EQ(low, 0);
	}

	TEST(IntmathTest, mulUnsignedMid)
	{
	uint32_t a = 0xffffffffULL;
	uint32_t b = 0x00000002ULL;
	uint32_t hi;
	uint32_t low;
	mulUnsigned<uint32_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0x1);
	EXPECT_EQ(low, 0xfffffffe);

	a = 68026386;
	b = 5152;
	mulUnsigned<uint32_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0x51);
	EXPECT_EQ(low, 0x99c16a40);

	a = 0;
	b = 0x55555555;
	mulUnsigned<uint32_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0);
	EXPECT_EQ(low, 0);
	}

	TEST(IntmathTest, mulSignedMid)
	{
	int32_t a = -0x80000000;
	int32_t b = -0x7fffffff;
	int32_t hi;
	int32_t low;
	mulSigned<int32_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0x3fffffff);
	EXPECT_EQ(low, -0x80000000);

	a = -68026386;
	b = 5152;
	mulSigned<int32_t>(hi, low, a, b);
	EXPECT_EQ(hi, -0x52);
	EXPECT_EQ(low, -0x99c16a40);

	a = 0;
	b = -0x55555555;
	mulSigned<int32_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0);
	EXPECT_EQ(low, 0);
	}

	TEST(IntmathTest, mulUnsignedWide)
	{
	uint64_t a = 0xffffffffffffffffULL;
	uint64_t b = 0x0000000000000002ULL;
	uint64_t hi;
	uint64_t low;
	mulUnsigned<uint64_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0x1);
	EXPECT_EQ(low, 0xfffffffffffffffe);

	hi = 0;
	low = 0;
	mulUnsignedManual<uint64_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0x1);
	EXPECT_EQ(low, 0xfffffffffffffffe);

	hi = 0;
	low = 0;
	std::tie(hi, low) = mulUnsigned<uint64_t>(a, b);
	EXPECT_EQ(hi, 0x1);
	EXPECT_EQ(low, 0xfffffffffffffffe);

	a = 0;
	b = 0x5555555555555555;
	mulUnsigned<uint64_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0);
	EXPECT_EQ(low, 0);
	}

	TEST(IntmathTest, mulSignedWide)
	{
	int64_t a = -0x8000000000000000;
	int64_t b = -0x7fffffffffffffff;
	int64_t hi;
	int64_t low;
	mulSigned<int64_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0x3fffffffffffffff);
	EXPECT_EQ(low, -0x8000000000000000);

	hi = 0;
	low = 0;
	mulSignedManual<int64_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0x3fffffffffffffff);
	EXPECT_EQ(low, -0x8000000000000000);

	hi = 0;
	low = 0;
	std::tie(hi, low) = mulSigned<int64_t>(a, b);
	EXPECT_EQ(hi, 0x3fffffffffffffff);
	EXPECT_EQ(low, -0x8000000000000000);

	a = 0;
	b = -0x5555555555555555;
	mulSigned<int64_t>(hi, low, a, b);
	EXPECT_EQ(hi, 0);
	EXPECT_EQ(low, 0);
	}

	TEST(IntmathTest, roundUp)
	{
	EXPECT_EQ(4104, roundUp(4101, 4));
	EXPECT_EQ(4112, roundUp(4105, 8));
	EXPECT_EQ(4112, roundUp(4101, 16));
	EXPECT_EQ(8192, roundUp(7991, 256));
	}

	TEST(IntmathTest, roundDown)
	{
	EXPECT_EQ(4100, roundDown(4101, 4));
	EXPECT_EQ(4104, roundDown(4105, 8));
	EXPECT_EQ(4096, roundDown(4101, 16));
	EXPECT_EQ(7936, roundDown(7991, 256));
	}

	/** This is testing if log2i actually works.
	* at every iteration value is multiplied by 2 (left shift) and expected
	* is incremented by one. This until value reaches becomes negative (by
	* left shifting) which is when expected points to the MSB
	*/
	TEST(IntmathTest, Log2i)
	{
	int expected = 0;
	for (int value = 1; value > 0; expected++, value <<= 1) {
	EXPECT_EQ(expected, log2i(value));
	}

	// Just as a sanity check for expected to point to the MSB
	EXPECT_EQ(expected, sizeof(int) * 8 - 1);
	}

	/** This is testing the assertions: what if invalid arguments are
	* provided to log2i:
	*
	* 1) value = 0
	* 2) value < 0
	* 3) value is not a power of 2
	*/
	TEST(IntmathDeathTest, Log2iDeath)
	{

	#ifdef NDEBUG
	GTEST_SKIP() << "Skipping as assertions are "
	"stripped out of fast builds";
	#endif

	// 1) value = 0
	EXPECT_DEATH({
	const int value = 0;
	log2i(value);
	}, "value > 0.*failed");

	// 2) value < 0
	EXPECT_DEATH({
	const int value = -1;
	log2i(value);
	}, "value > 0.*failed");

	// 3) value is not a power of 2
	EXPECT_DEATH({
	const int value = 5;
	log2i(value);
	}, "isPowerOf2");
	}