Skip to content

Commit 58c3443

Browse files
martinmoenemartinmoene
committed
Fix std::bitset construction ambiguous overload resolution for VC10/VS2010
In EXPECT, consistently put result at right. Add several expectations for count*()
1 parent 0f68901 commit 58c3443

File tree

1 file changed

+80
-58
lines changed

1 file changed

+80
-58
lines changed

‎test/bit.t.cpp‎

Lines changed: 80 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -115,86 +115,86 @@ CASE( "has_single_bit(): single bit yields false for mutiple bits set" " [bit.po
115115

116116
#include <bitset>
117117

118+
// avoid ambiguous overload resolution for VS2010 (VC10):
119+
120+
template< typename T >
121+
std::bitset<8> bin( T v )
122+
{
123+
#if defined( _MSC_VER ) && _MSC_VER <= 1600
124+
return std::bitset<8>( static_cast<int>(v) );
125+
#else
126+
return std::bitset<8>( v );
127+
#endif
128+
}
129+
118130
CASE( "bit_ceil(): let N be the smallest power of 2 greater than or equal to x" " [bit.pow.two]" )
119131
{
120-
typedef std::bitset<8> bin;
121-
122-
EXPECT( bin( 1u ) == bin( bit_ceil( 0u ) ) );
123-
EXPECT( bin( 1u ) == bin( bit_ceil( 1u ) ) );
124-
EXPECT( bin( 2u ) == bin( bit_ceil( 2u ) ) );
125-
EXPECT( bin( 4u ) == bin( bit_ceil( 3u ) ) );
126-
EXPECT( bin( 4u ) == bin( bit_ceil( 4u ) ) );
127-
EXPECT( bin( 8u ) == bin( bit_ceil( 5u ) ) );
128-
EXPECT( bin( 8u ) == bin( bit_ceil( 6u ) ) );
129-
EXPECT( bin( 8u ) == bin( bit_ceil( 7u ) ) );
130-
EXPECT( bin( 8u ) == bin( bit_ceil( 8u ) ) );
131-
EXPECT( bin(16u ) == bin( bit_ceil( 9u ) ) );
132+
EXPECT( bin( bit_ceil( 0u ) ) == bin( 1u ) );
133+
EXPECT( bin( bit_ceil( 1u ) ) == bin( 1u ) );
134+
EXPECT( bin( bit_ceil( 2u ) ) == bin( 2u ) );
135+
EXPECT( bin( bit_ceil( 3u ) ) == bin( 4u ) );
136+
EXPECT( bin( bit_ceil( 4u ) ) == bin( 4u ) );
137+
EXPECT( bin( bit_ceil( 5u ) ) == bin( 8u ) );
138+
EXPECT( bin( bit_ceil( 6u ) ) == bin( 8u ) );
139+
EXPECT( bin( bit_ceil( 7u ) ) == bin( 8u ) );
140+
EXPECT( bin( bit_ceil( 8u ) ) == bin( 8u ) );
141+
EXPECT( bin( bit_ceil( 9u ) ) == bin(16u ) );
132142
}
133143

134144
CASE( "bit_floor(): x == 0, 0; otherwise the maximal value y such that has_single_bit(y) is true and y <= x" " [bit.pow.two]" )
135145
{
136-
typedef std::bitset<8> bin;
137-
138-
EXPECT( bin( 0u ) == bin( bit_floor( 0u ) ) );
139-
EXPECT( bin( 1u ) == bin( bit_floor( 1u ) ) );
140-
EXPECT( bin( 2u ) == bin( bit_floor( 2u ) ) );
141-
EXPECT( bin( 2u ) == bin( bit_floor( 3u ) ) );
142-
EXPECT( bin( 4u ) == bin( bit_floor( 4u ) ) );
143-
EXPECT( bin( 4u ) == bin( bit_floor( 5u ) ) );
144-
EXPECT( bin( 4u ) == bin( bit_floor( 6u ) ) );
145-
EXPECT( bin( 4u ) == bin( bit_floor( 7u ) ) );
146-
EXPECT( bin( 8u ) == bin( bit_floor( 8u ) ) );
147-
EXPECT( bin( 8u ) == bin( bit_floor( 9u ) ) );
146+
EXPECT( bin( bit_floor( 0u ) ) == bin( 0u ) );
147+
EXPECT( bin( bit_floor( 1u ) ) == bin( 1u ) );
148+
EXPECT( bin( bit_floor( 2u ) ) == bin( 2u ) );
149+
EXPECT( bin( bit_floor( 3u ) ) == bin( 2u ) );
150+
EXPECT( bin( bit_floor( 4u ) ) == bin( 4u ) );
151+
EXPECT( bin( bit_floor( 5u ) ) == bin( 4u ) );
152+
EXPECT( bin( bit_floor( 6u ) ) == bin( 4u ) );
153+
EXPECT( bin( bit_floor( 7u ) ) == bin( 4u ) );
154+
EXPECT( bin( bit_floor( 8u ) ) == bin( 8u ) );
155+
EXPECT( bin( bit_floor( 9u ) ) == bin( 8u ) );
148156
}
149157

150158
CASE( "bit_width: x == 0, 0; otherwise one plus the base-2 logarithm of x, with any fractional part discarded" " [bit.pow.two]" )
151159
{
152-
typedef std::bitset<8> bin;
153-
154-
EXPECT( bit_width( 0u ) == 0 );
155-
EXPECT( bit_width( 1u ) == 1 );
156-
EXPECT( bit_width( 2u ) == 2 );
157-
EXPECT( bit_width( 3u ) == 2 );
158-
EXPECT( bit_width( 4u ) == 3 );
159-
EXPECT( bit_width( 5u ) == 3 );
160-
EXPECT( bit_width( 6u ) == 3 );
161-
EXPECT( bit_width( 7u ) == 3 );
162-
EXPECT( bit_width( 8u ) == 4 );
160+
EXPECT( bit_width( 0u ) == 0u );
161+
EXPECT( bit_width( 1u ) == 1u );
162+
EXPECT( bit_width( 2u ) == 2u );
163+
EXPECT( bit_width( 3u ) == 2u );
164+
EXPECT( bit_width( 4u ) == 3u );
165+
EXPECT( bit_width( 5u ) == 3u );
166+
EXPECT( bit_width( 6u ) == 3u );
167+
EXPECT( bit_width( 7u ) == 3u );
168+
EXPECT( bit_width( 8u ) == 4u );
163169
}
164170

165171
CASE( "rotl(): r is 0, x; if r is positive, (x << r) | (x >> (N - r)); if r is negative, rotr(x, -r)" " [bit.rotate]" )
166172
{
167-
typedef std::bitset<8> bin;
168-
typedef unsigned char uint8_t;
169173
uint8_t i = 29; // 0b00011101;
170174

171-
EXPECT( bin( i ) == bin( i) );
172-
EXPECT( bin( rotl(i, 0) ) == bin( 29) );
173-
EXPECT( bin( rotl(i, 1) ) == bin( 58) );
174-
EXPECT( bin( rotl(i, 4) ) == bin(209) );
175-
EXPECT( bin( rotl(i, 9) ) == bin( 58) );
176-
EXPECT( bin( rotl(i,-1) ) == bin(142) );
175+
EXPECT( bin( i ) == bin( i ) );
176+
EXPECT( bin( rotl(i, 0) ) == bin( 29u) );
177+
EXPECT( bin( rotl(i, 1) ) == bin( 58u) );
178+
EXPECT( bin( rotl(i, 4) ) == bin(209u) );
179+
EXPECT( bin( rotl(i, 9) ) == bin( 58u) );
180+
EXPECT( bin( rotl(i,-1) ) == bin(142u) );
177181
}
178182

179183
CASE( "rotr(): r is 0, x; if r is positive, (x >> r) | (x << (N - r)); if r is negative, rotl(x, -r)" " [bit.rotate]" )
180184
{
181-
typedef std::bitset<8> bin;
182-
typedef unsigned char uint8_t;
183185
uint8_t i = 29; // 0b00011101;
184186

185-
EXPECT( bin( i ) == bin( i) );
186-
EXPECT( bin( rotr(i, 0) ) == bin( 29) );
187-
EXPECT( bin( rotr(i, 1) ) == bin(142) );
188-
EXPECT( bin( rotr(i, 4) ) == bin(209) );
189-
EXPECT( bin( rotr(i, 9) ) == bin(142) );
190-
EXPECT( bin( rotr(i,-1) ) == bin( 58) );
187+
EXPECT( bin( i ) == bin( i ) );
188+
EXPECT( bin( rotr(i, 0) ) == bin( 29u) );
189+
EXPECT( bin( rotr(i, 1) ) == bin(142u) );
190+
EXPECT( bin( rotr(i, 4) ) == bin(209u) );
191+
EXPECT( bin( rotr(i, 9) ) == bin(142u) );
192+
EXPECT( bin( rotr(i,-1) ) == bin( 58u) );
191193

192194
}
193195

194196
CASE( "countl_zero(): the number of consecutive 0 bits in the value of x, starting from the most significant bit" " [bit.count]" )
195197
{
196-
typedef unsigned char uint8_t;
197-
198198
EXPECT( countl_zero( uint8_t(0x80u) ) == 0 );
199199
EXPECT( countl_zero( uint8_t(0x40u) ) == 1 );
200200
EXPECT( countl_zero( uint8_t(0x20u) ) == 2 );
@@ -203,9 +203,13 @@ CASE( "countl_zero(): the number of consecutive 0 bits in the value of x, starti
203203
EXPECT( countl_zero( uint8_t(0x04u) ) == 5 );
204204
EXPECT( countl_zero( uint8_t(0x02u) ) == 6 );
205205
EXPECT( countl_zero( uint8_t(0x01u) ) == 7 );
206-
EXPECT( countl_zero( uint8_t( 0u) ) == 8 );
207206

208-
EXPECT( countl_zero( 0u ) == CHAR_BIT * sizeof(unsigned int) );
207+
EXPECT( countl_zero( uint8_t( 0u) ) == 8 );
208+
EXPECT( countl_zero( uint16_t( 0u) ) == 16 );
209+
EXPECT( countl_zero( uint32_t( 0u) ) == 32 );
210+
EXPECT( countl_zero( uint64_t( 0u) ) == 64 );
211+
212+
EXPECT( countl_zero( 0u ) == static_cast<int>( CHAR_BIT * sizeof(unsigned) ) );
209213
}
210214

211215
CASE( "countl_one(): the number of consecutive 1 bits in the value of x, starting from the most significant bit" " [bit.count]" )
@@ -220,7 +224,12 @@ CASE( "countl_one(): the number of consecutive 1 bits in the value of x, startin
220224
EXPECT( countl_one( uint8_t(0xfeu) ) == 7 );
221225
EXPECT( countl_one( uint8_t(0xffu) ) == 8 );
222226

223-
// EXPECT( countl_one( 0u ) == CHAR_BIT * sizeof(unsigned int) );
227+
EXPECT( countl_one( uint8_t( -1) ) == 8 );
228+
EXPECT( countl_one( uint16_t( -1) ) == 16 );
229+
EXPECT( countl_one( uint32_t( -1) ) == 32 );
230+
EXPECT( countl_one( uint64_t( -1) ) == 64 );
231+
232+
EXPECT( countl_one( unsigned(-1) ) == static_cast<int>( CHAR_BIT * sizeof(unsigned) ) );
224233
}
225234

226235
CASE( "countr_zero(): the number of consecutive 0 bits in the value of x, starting from the least significant bit" " [bit.count]" )
@@ -233,9 +242,13 @@ CASE( "countr_zero(): the number of consecutive 0 bits in the value of x, starti
233242
EXPECT( countr_zero( uint8_t(0x20u) ) == 5 );
234243
EXPECT( countr_zero( uint8_t(0x40u) ) == 6 );
235244
EXPECT( countr_zero( uint8_t(0x80u) ) == 7 );
236-
EXPECT( countr_zero( uint8_t( 0u) ) == 8 );
237245

238-
EXPECT( countr_zero( 0u ) == CHAR_BIT * sizeof(unsigned int) );
246+
EXPECT( countr_zero( uint8_t( 0u) ) == 8 );
247+
EXPECT( countr_zero( uint16_t( 0u) ) == 16 );
248+
EXPECT( countr_zero( uint32_t( 0u) ) == 32 );
249+
EXPECT( countr_zero( uint64_t( 0u) ) == 64 );
250+
251+
EXPECT( countr_zero( 0u ) == static_cast<int>( CHAR_BIT * sizeof(unsigned) ) );
239252
}
240253

241254
CASE( "countr_one(): the number of consecutive 1 bits in the value of x, starting from the least significant bit" " [bit.count]" )
@@ -249,6 +262,13 @@ CASE( "countr_one(): the number of consecutive 1 bits in the value of x, startin
249262
EXPECT( countr_one( uint8_t(0x3fu) ) == 6 );
250263
EXPECT( countr_one( uint8_t(0x7fu) ) == 7 );
251264
EXPECT( countr_one( uint8_t(0xffu) ) == 8 );
265+
266+
EXPECT( countr_one( uint8_t( -1) ) == 8 );
267+
EXPECT( countr_one( uint16_t( -1) ) == 16 );
268+
EXPECT( countr_one( uint32_t( -1) ) == 32 );
269+
EXPECT( countr_one( uint64_t( -1) ) == 64 );
270+
271+
EXPECT( countr_one( unsigned(-1) ) == static_cast<int>( CHAR_BIT * sizeof(unsigned) ) );
252272
}
253273

254274
CASE( "popcount(): the number of 1 bits in the value of x" " [bit.count]" )
@@ -262,6 +282,8 @@ CASE( "popcount(): the number of 1 bits in the value of x" " [bit.count]" )
262282
EXPECT( popcount( uint8_t(0xe7u) ) == 6 );
263283
EXPECT( popcount( uint8_t(0xefu) ) == 7 );
264284
EXPECT( popcount( uint8_t(0xffu) ) == 8 );
285+
286+
EXPECT( popcount( unsigned(-1) ) == static_cast<int>( CHAR_BIT * sizeof(unsigned) ) );
265287
}
266288

267289
CASE( "endian: little differs from big (corner-case when all scalars have size of 1 byte)" " [bit.endian]" )

0 commit comments

Comments
 (0)