blob: 227b66429ce9eab6c135543d1bfc7c438dd690d2 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
// 2000-01-15 Anders Widell <awl@hem.passagen.se>
// Copyright (C) 2000, 2003, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <string>
#include <set>
#include <bitset>
#include <testsuite_hooks.h>
static char original_bits[1024];
static char left_shifted[1024];
static char right_shifted[1024];
char
random_bit() {
static long x = 1;
return ((x = (3432L*x + 6789L) % 9973L) & 1) + '0';
}
void
initialise(size_t size) {
for (size_t i=0; i<size; i++)
original_bits[i] = random_bit();
original_bits[size] = '\0';
left_shifted[size] = '\0';
right_shifted[size] = '\0';
}
void
shift_arrays(size_t shift_step, size_t size) {
for (size_t i=shift_step; i<size; i++) {
right_shifted[i] = original_bits[i-shift_step];
left_shifted[size-i-1] = original_bits[size+shift_step-i-1];
}
for (size_t i=0; i<shift_step && i<size; i++) {
right_shifted[i] = '0';
left_shifted[size-i-1] = '0';
}
}
template <size_t size>
bool
do_test() {
bool test __attribute__((unused)) = true;
std::bitset<size> shifted;
std::bitset<size> correct;
initialise(size);
//std::bitset<size> original = std::string(original_bits);
std::bitset<size> original = std::bitset<size> (std::string(original_bits));
for (size_t shift_step=0; shift_step==0 || shift_step<size; shift_step++) {
shift_arrays(shift_step, size);
shifted = original;
shifted <<= shift_step;
//correct = std::string(left_shifted);
correct = std::bitset<size> (std::string(left_shifted));
VERIFY( shifted == correct );
shifted = original;
shifted >>= shift_step;
//correct = std::string(right_shifted);
correct = std::bitset<size> (std::string(right_shifted));
VERIFY( shifted == correct );
}
return test;
}
bool
test01() {
bool test __attribute__((unused)) = true;
VERIFY( do_test<32>() );
VERIFY( do_test<48>() );
VERIFY( do_test<64>() );
VERIFY( do_test<511>() );
VERIFY( do_test<513>() );
VERIFY( do_test<997>() );
return test;
}
int
main()
{
test01();
return 0;
}
|
