Hi,
I'm trying to build ustl on my ubuntu 12.04 server, after running:
- ./configure
- make
- make check
it says:
make: *** [bvt/run] Error 1
below is the full log, can you help me to figure it out?
Linking bvt/bvt09 ...
Linking bvt/bvt10 ...
Linking bvt/bvt11 ...
Linking bvt/bvt12 ...
Linking bvt/bvt13 ...
Linking bvt/bvt14 ...
Linking bvt/bvt15 ...
Linking bvt/bvt16 ...
Linking bvt/bvt17 ...
Linking bvt/bvt19 ...
Linking bvt/bvt20 ...
Linking bvt/bvt21 ...
Linking bvt/bvt22 ...
Linking bvt/bvt24 ...
Linking bvt/bvt25 ...
Linking bvt/bvt26 ...
Linking bvt/bvt27 ...
Linking bvt/bvt29 ...
Linking bvt/bvt18 ...
Linking bvt/bvt23 ...
Linking bvt/bvt28 ...
Running build verification tests:
Running bvt/bvt00
cmemlink{13}: Hello world!1,3d0
< cmemlink{13}: Hello world!
cmemlink{13}: Hello world!< cmemlink{13}: Hello world!
< cmemlink{8}: Hello wo
cmemlink{8}: Hello wo
Running bvt/bvt01
memlink{27}: abcdefghijklmnopqrstuvwzyz1,7d0
< memlink{27}: abcdefghijklmnopqrstuvwzyz
< memlink{27}: abcdefghijklmnopqrstuvwzyz
< memlink{26}: abcdefghijklmnopqrstuvwzyz
< memlink{26}: abcde---------fghijklmnopq
< memlink{26}: abcde----hijklmnopq=======
< memlink{26}: abcdeTESTTESTTESTpq=======
< memlink{26}: abcdeTESTTESTTESTpq=======
memlink{27}: abcdefghijklmnopqrstuvwzyzRunning bvt/bvt02
memlink{26}: abcdefghijklmnopqrstuvwzyz
memlink{26}: abcde---------fghijklmnopq
memlink{26}: abcde----hijklmnopq=======
memlink{26}: abcdeTESTTESTTESTpq=======
memlink{26}: abcdeTESTTESTTESTpq=======
memblock{26}: abcdefghijklmnopqrstuvwxyz
memblock{26}: abcdefghijklmnopqrstuvwxyz
memblock{26}: abcdefghijklmnopqrstuvwxyz
memblock{35}: abcde---------fghijklmnopqrstuvwxyz
memblock{28}: ab-----fghijklmnopqrs=======
memblock{28}: ab---TESTTESTTESTpqrs=======
memblock{50}: ab---TESTTESTTESTpqrs=====-+=-+=-+=-+=-+=-+=-+=-+=
memblock{0}:
memblock{39}: ab---TESTTESTTESTpqrs=====-+=-+=-+=-+=-
Capacity 64, shrunk 39
1,10d0
< memblock{26}: abcdefghijklmnopqrstuvwxyz
< memblock{26}: abcdefghijklmnopqrstuvwxyz
< memblock{26}: abcdefghijklmnopqrstuvwxyz
< memblock{35}: abcde---------fghijklmnopqrstuvwxyz
< memblock{28}: ab-----fghijklmnopqrs=======
< memblock{28}: ab---TESTTESTTESTpqrs=======
< memblock{50}: ab---TESTTESTTESTpqrs=====-+=-+=-+=-+=-+=-+=-+=-+=
< memblock{0}:
< memblock{39}: ab---TESTTESTTESTpqrs=====-+=-+=-+=-+=-
< Capacity 64, shrunk 39
Running bvt/bvt03
Correct number of bytes written
1,13d0
< Correct number of bytes written
< Values:
< char: 0x12
< u_char: 0x12
< bool: 1
< int: 0x12345678
< u_int: 0x12345678
< long: 0x12345678
< u_long: 0x12345678
< float: 0.12345678
< double: 0.1234567891234568
< short: 0x1234
< u_short: 0x1234
Running bvt/bvt04
Values:
char: 0x12
u_char: 0x12
bool: 1
int: 0x12345678
u_int: 0x12345678
long: 0x12345678
u_long: 0x12345678
float: 0.12345678
double: 0.1234567891234568
short: 0x1234
u_short: 0x1234
(1)
Reserved to capacity() == 32 (1 used, SIZE_MAX/elsize max)
(1,2,3,4,5,6,7,8,9,10,11,12,13,13,14,15,16,17,18)
front() = 1, back() = 18
(2,3,4,5,6,7,8,9,10,11,12,13,13,14,15,16,17)
(2,3,4,5,6,777,8,9,10,11,666,666,666,12,13,13,14,15,16,17)
(2,3,4,5,6,777,8,9,10,11,666,666,666,12,13)
v[5] == 777
v is now empty
(66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66)
(33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33)
(1,2,3,4,5,6,7,8,9,10,11,12,13,13,14,15,16,17,18)
v == v2
A::A
A::A
A::A
A::A
A::operator=
A::operator=
A::operator=
A::~A
Class insertion testing successful
{ 1 2 3 11 12 13 4 22 5 6 7 8 }
A::A(15)
A::~A
A::~A
A::~A
A::~A
1,28d0
< (1)
< Reserved to capacity() == 32 (1 used, SIZE_MAX/elsize max)
< (1,2,3,4,5,6,7,8,9,10,11,12,13,13,14,15,16,17,18)
< front() = 1, back() = 18
< (2,3,4,5,6,7,8,9,10,11,12,13,13,14,15,16,17)
< (2,3,4,5,6,777,8,9,10,11,666,666,666,12,13,13,14,15,16,17)
< (2,3,4,5,6,777,8,9,10,11,666,666,666,12,13)
< v[5] == 777
< v is now empty
< (66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66)
< (33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33,33)
< (1,2,3,4,5,6,7,8,9,10,11,12,13,13,14,15,16,17,18)
< v == v2
< A::A
< A::A
< A::A
< A::A
< A::operator=
< A::operator=
< A::operator=
< A::~A
< Class insertion testing successful
< { 1 2 3 11 12 13 4 22 5 6 7 8 }
< A::A(15)
< A::~A
< A::~A
< A::~A
< A::~A
Running bvt/bvt05
{ 1,132d0
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< swap(1,2)
< { 2 1 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< copy(0,8,9)
< { 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 16 17 18 }
< copy with back_inserter
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< copy with inserter
< { 1 2 3 1 2 3 4 5 4 5 }
< copy_n(0,8,9)
< { 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 16 17 18 }
< copy_if(is_even)
< { 2 4 6 8 10 10 12 14 16 18 }
< for_each(printint)
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< for_each(reverse_iterator, printint)
< { 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
< find(10)
< 10 found at offset 9
< count(13)
< 2 values of 13, 1 values of 18
< transform(sqr)
< { 1 4 9 16 25 36 49 64 81 100 100 121 144 169 169 196 225 256 289 324 }
< replace(13,666)
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 666 666 14 15 16 17 18 }
< fill(13)
< { 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 }
< fill_n(5, 13)
< { 13 13 13 13 13 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< fill 64083 uint8_t(0x41) works
< fill 64083 uint16_t(0x4142) works
< fill 64083 uint32_t(0x41424344) works
< fill 64083 float(0.4242) works
< fill 64083 uint64_t(0x4142434445464748) works
< copy 64083 uint8_t(0x41) works
< copy 64083 uint16_t(0x4142) works
< copy 64083 uint32_t(0x41424344) works
< copy 64083 float(0.4242) works
< copy 64083 uint64_t(0x4142434445464748) works
< generate(genint)
< { 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 }
< rotate(4)
< { 15 16 17 18 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 }
< merge with (3,5,10,11,11,14)
< { 1 2 3 3 4 5 5 6 7 8 9 10 10 10 11 11 11 12 13 13 14 14 15 16 17 18 }
< inplace_merge with (3,5,10,11,11,14)
< { 1 2 3 3 4 5 5 6 7 8 9 10 10 10 11 11 11 12 13 13 14 14 15 16 17 18 }
< remove(13)
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 14 15 16 17 18 }
< remove (elements 3, 4, 6, 15, and 45)
1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< { 1 2 3 6 8 9 10 10 11 12 13 13 15 16 17 18 }
< unique
< { 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 }
< reverse
< { 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
< lower_bound(10)
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< 10 begins at position 9
< upper_bound(10)
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< 10 ends at position 11
< equal_range(10)
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< Range of 10 is { 9, 11 }
< Range of 0 is { 0, 0 }
< Range of 100 is { 20, 20 }
< sort
< { 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< stable_sort
< { 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< is_sorted
< unsorted=false, sorted=true
< find_first_of
swap(1,2)
{ 2 1 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< found 14 at position 15
< lexicographical_compare
< LC1 < LC2 == true
< LC2 < LC2 == false
< LC3 < LC4 == true
< LC4 < LC1 == true
< LC1 < LC4 == false
< max_element
< max element is 18
< min_element
< min element is 1
< partial_sort
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< partial_sort_copy
< { 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
< partition
< { 2 4 6 8 10 10 12 14 16 18 1 3 5 7 9 11 13 13 15 17 }
< stable_partition
< { 2 4 6 8 10 10 12 14 16 18 1 3 5 7 9 11 13 13 15 17 }
< next_permutation
< { 1 2 3 }
< { 1 3 2 }
< { 2 1 3 }
< { 2 3 1 }
< { 3 1 2 }
< { 3 2 1 }
< prev_permutation
< { 3 2 1 }
< { 3 1 2 }
< { 2 3 1 }
< { 2 1 3 }
< { 1 3 2 }
< { 1 2 3 }
< reverse_copy
< { 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
< rotate_copy
< { 7 8 9 10 10 11 12 13 13 14 15 16 17 18 1 2 3 4 5 6 }
< search
< {5,6,7,8,9} at 4
< {10,10,11,14} at 20
< find_end
< {5,6,7,8,9} at 4
copy(0,8,9)
{ 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 16 17 18 }
copy with back_inserter
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
copy with inserter
{ 1 2 3 1 2 3 4 5 4 5 }
< {10,10,11,14} at 20
< search_n
< {14} at 15
< {13,13} at 13
< {10,10,10} at 20
< includes
< includes=true, not includes=false
< set_difference
< { 1 2 3 5 }
< set_symmetric_difference
< { 1 2 3 4 5 7 8 }
< set_intersection
< { 4 6 }
< set_union
< { 1 2 3 4 4 5 6 7 8 }
copy_n(0,8,9)
{ 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 16 17 18 }
copy_if(is_even)
{ 2 4 6 8 10 10 12 14 16 18 }
Running bvt/bvt06
for_each(printint)
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
for_each(reverse_iterator, printint)
{ 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
find(10)
10 found at offset 9
count(13)
2 values of 13, 1 values of 18
transform(sqr)
vector of 10 elements:
0
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
size() = 10, max_size() = SIZE_MAX/elsize, empty() = false
back()->size() = 5
back()->size() = 40
36 37 38 39 40 41 42 43 44
vector of 7 elements backwards:
28 29 30 31 32 33 34 35
21 22 23 24 25 26 27
6 7 8 9
3 4 5
1 2
0
1,29d0
< ---
< vector of 10 elements:
< ---
<
< 0
< 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
< ---
< size() = 10, max_size() = SIZE_MAX/elsize, empty() = false
< back()->size() = 5
< back()->size() = 40
< 36 37 38 39 40 41 42 43 44
< ---
< vector of 7 elements backwards:
< ---
< 28 29 30 31 32 33 34 35
< 21 22 23 24 25 26 27
< 6 7 8 9
< 3 4 5
< 1 2
< 0
<
< ---
{ 1 4 9 16 25 36 49 64 81 100 100 121 144 169 169 196 225 256 289 324 }
replace(13,666)
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 666 666 14 15 16 17 18 }
Running bvt/bvt07
fill(13)
{ 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 }
fill_n(5, 13)
{ 13 13 13 13 13 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
123456789012345678901234567890
abcdefghijklmnopqrstuvwxyz
123456789012345678901234567890
12345678901234567890
s3.size() = 20, max_size() = (SIZE_MAX/elsize)-1, capacity() = 63
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$
HelloWorld
Concatenated HelloWorld string.
s1 < s2
s1 == s1
s1 == s4
56789 == 56789
&s1[7] = 89012345678901234567890
initial: 123456789012345678901234567890
erase(5,find(9)-5) 123459012345678901234567890
erase(5,5) 1234545678901234567890
push_back('x') 1234545678901234567890x
pop_back()
insert(10,#) 1234545678#901234567890
replace(0,5,@) @45678#901234567890
8 found at 7
9 found at 8
7 rfound at 26
7 rfound again at 16
67 rfound at 25
X was not rfound
[456] found at 3
[456] last found at 25
s2 is empty [], capacity 5 bytes
<31 bytes of 31> Format '<const] 42, [rfile>, 0xDEADBEEF'
Custom vararg MyFormat: '<const] 42, [rfile>, 0xDEADBEEF'
hash_value(s2) = 95A714F3, string::hash(s2) = 95A714F3
fill 64083 uint8_t(0x41) works
fill 64083 uint16_t(0x4142) works
fill 64083 uint32_t(0x41424344) works
fill 64083 float(0.4242) works
fill 64083 uint64_t(0x4142434445464748) 1,32d0
< 123456789012345678901234567890
< abcdefghijklmnopqrstuvwxyz
< 123456789012345678901234567890
< 12345678901234567890
< s3.size() = 20, max_size() = (SIZE_MAX/elsize)-1, capacity() = 63
< abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$
< HelloWorld
< Concatenated HelloWorld string.
< s1 < s2
< s1 == s1
< s1 == s4
< 56789 == 56789
< &s1[7] = 89012345678901234567890
< initial: 123456789012345678901234567890
< erase(5,find(9)-5) 123459012345678901234567890
< erase(5,5) 1234545678901234567890
< push_back('x') 1234545678901234567890x
< pop_back()
< insert(10,#) 1234545678#901234567890
< replace(0,5,@) @45678#901234567890
< 8 found at 7
< 9 found at 8
< 7 rfound at 26
< 7 rfound again at 16
< 67 rfound at 25
< X was not rfound
< [456] found at 3
< [456] last found at 25
< s2 is empty [], capacity 5 bytes
< <31 bytes of 31> Format '<const] 42, [rfile>, 0xDEADBEEF'
< Custom vararg MyFormat: '<const] 42, [rfile>, 0xDEADBEEF'
< hash_value(s2) = 95A714F3, string::hash(s2) = 95A714F3
Running bvt/bvt08
works
copy 64083 uint8_t(0x41) works
copy 64083 uint16_t(0x4142) works
copy 64083 uint32_t(0x41424344) works
copy 64083 float(0.4242) works
copy 64083 uint64_t(0x4142434445464748) 1,30d0
< Hello world!
< Hello again!
< element3
< element4
< element5_long_element5
< element3 found at position 2
< After erase (end,end):
< Hello world!
< Hello again!
< element3
Hello world!< element4
< element5_long_element5
< After erase (2,2):
Hello again!
element3
element4
element5_long_element5< Hello world!
element3 found at position < Hello again!
< element5_long_element5
< After pop_back():
< Hello world!
2
After erase (end,end):
Hello world!
Hello again!
element3
element4
element5_long_element5
After erase (2,2):
Hello world!
Hello again!
element5_long_element5< Hello again!
After pop_back():
Hello world!
Hello again!
element3
element4
After insert(1,1,3):
Hello world!
Hello again!
element3
element4
Hello again!
element3
element4
element5_long_element5
< element3
< element4
< After insert(1,1,3):
< Hello world!
< Hello again!
< element3
< element4
< Hello again!
< element3
< element4
< element5_long_element5
Running bvt/bvt09
works
generate(genint)
{ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 }
rotate(4)
{ 15 16 17 18 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 }
merge with (3,5,10,11,11,14)
{ 1 2 3 3 4 5 5 6 7 8 9 10 10 10 11 11 11 12 13 13 14 14 15 16 17 18 }
84 bytes written
Values:
char: 'c'
u_char: 'c'
bool: 1
int: -12345678
u_int: 12345678
long: -12345678
u_long: 12345678
float: 123.46
double: 123456789123456.78
short: 1234
u_short: 1234
Dump:
c
c
true
-12345678
12345678
-12345678
12345678
123.46
123456789123456.78
1234
1234
1,28d0
< 84 bytes written
< Values:
< char: 'c'
< u_char: 'c'
< bool: 1
< int: -12345678
< u_int: 12345678
< long: -12345678
< u_long: 12345678
< float: 123.46
< double: 123456789123456.78
< short: 1234
< u_short: 1234
inplace_merge with (3,5,10,11,11,14)
{ 1 2 3 3 4 5 5 6 7 8 9 10 10 10 11 11 11 12 13 13 14 14 15 16 17 18 }
remove(13)
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 14 15 16 17 18 }
remove (elements 3, 4, 6, 15, and 45)
{ 1 2 3 6 8 9 10 10 11 12 13 13 15 16 17 18 }
<
< Dump:
< c
< c
< true
< -12345678
< 12345678
< -12345678
< 12345678
< 123.46
< 123456789123456.78
< 1234
< 1234
<
<
Running bvt/bvt10
unique
{ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 }
reverse
{ 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
lower_bound(10)
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
10 begins at position 9
upper_bound(10)
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
10 ends at position 11
equal_range(10)
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
Range of 10 is { 9, 11 }
Range of 0 is { 0, 0 }
Range of 100 is { 20, 20 }
sort
{ 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
stable_sort
{ 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
is_sorted
unsorted=false, sorted=true
find_first_of
found 14 at position 15
lexicographical_compare
LC1 < LC2 == true
LC2 < LC2 == false
LC3 < LC4 == true
LC4 < LC1 == true
LC1 < LC4 == false
max_element
max element is 18
min_element
min element is 1
partial_sort
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
partial_sort_copy
{ 1 2 3 4 5 6 7 8 9 10 10 11 12 13 13 14 15 16 17 18 }
partition
{ 2 4 6 8 10 10 12 14 16 18 1 3 5 7 9 11 13 13 15 17 }
stable_partition
{ 2 4 6 8 10 10 12 14 16 18 1 3 5 7 9 11 13 13 15 17 }
next_permutation
{ 1 2 3 }
{ 1 3 2 }
{ 2 1 3 }
{ 2 3 1 }
{ 3 1 2 }
{ 3 2 1 }
prev_permutation
{ 3 2 1 }
{ 3 1 2 }
{ 2 3 1 }
{ 2 1 3 }
{ 1 3 2 }
{ 1 2 3 }
reverse_copy
{ 18 17 16 15 14 13 13 12 11 10 10 9 8 7 6 5 4 3 2 1 }
rotate_copy
{ 7 8 9 10 10 11 12 13 13 14 15 16 17 18 1 2 3 4 5 6 }
search
{5,6,7,8,9} at 4
{10,10,11,14} at 20
find_end
{5,6,7,8,9} at 4
{10,10,11,14} at 20
search_n
{14} at 15
{13,13} at 13
{10,10,10} at 20
includes
includes=true, not includes=false
set_difference
{ 1 2 3 5 }
set_symmetric_difference
{ 1 2 3 4 5 7 8 }
set_intersection
{ 4 6 }
set_union
{ 1 2 3 4 4 5 6 7 8 }
start: { 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 }
plus: { 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 }
minus: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
divides: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
multiplies: { 4 1 4 1 4 1 4 1 4 1 4 1 4 1 4 1 4 1 4 1 }
modulus: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
logical_and: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
logical_or: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
equal_to: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
not_equal_to: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
greater: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
less: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
greater_equal: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
less_equal: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
compare: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
negate: { -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 }
logical_not: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
unary_neg(negate): { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
binder1st(plus,5): { 7 6 7 6 7 6 7 6 7 6 7 6 7 6 7 6 7 6 7 6 }
binder2nd(minus,1): { 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 }
compose1(-,+5): { -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 }
1,27d0
compose1(-,-4): { 2 3 2 3 2 3 2 3 2 3 2 3 2 3 2 3 2 3 2 3 }
compose2(/,+6,-4): { -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 }
mem_var(plus,6): { 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 }
14 found at position 8
18 found at position 12
add next: { 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 25 }
< start: { 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 }
< plus: { 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 }
< minus: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
< divides: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
< multiplies: { 4 1 4 1 4 1 4 1 4 1 4 1 4 1 4 1 4 1 4 1 }
< modulus: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
< logical_and: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
< logical_or: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
< equal_to: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
< not_equal_to: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
< greater: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
< less: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
< greater_equal: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
< less_equal: { 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 }
< compare: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
< negate: { -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 -2 -1 }
< logical_not: { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
< unary_neg(negate): { 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 }
< binder1st(plus,5): { 7 6 7 6 7 6 7 6 7 6 7 6 7 6 7 6 7 6 7 6 }
< binder2nd(minus,1): { 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 }
< compose1(-,+5): { -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 -7 -6 }
< compose1(-,-4): { 2 3 2 3 2 3 2 3 2 3 2 3 2 3 2 3 2 3 2 3 }
< compose2(/,+6,-4): { -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 -4 -2 }
< mem_var(plus,6): { 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 }
< 14 found at position 8
< 18 found at position 12
< add next: { 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 25 }
Running bvt/bvt11
set: 1,7d0
< set: { 1 2 3 4 6 8 9 }
< erase(3): { 1 2 4 6 8 9 }
< multiset: { 1 1 1 1 2 3 3 4 4 6 8 9 }
< count(1) = 4
< find(4) = 7
< find(5) = false
< erase(3): { 1 1 1 1 2 4 4 6 8 9 }
{ 1 2 3 4 6 8 9 }
erase(3): { 1 2 4 6 8 9 }Running bvt/bvt12
multiset: { 1 1 1 1 2 3 3 4 4 6 8 9 }
count(1) = 4
find(4) = 7
find(5) = false
erase(3): { 1 1 1 1 2 4 4 6 8 9 }
Write const void_, pos is right
Write void_, pos is right
Write string, pos is right
Write const string_, pos is right
Write string_, pos is right
Write vector<uint16_t>(7), pos is right
Read const void_, pos is right, value is right
Read void_, pos is right, value is right
Read string, pos is right, value is TestString
Read const string_, pos is right, value is right
Read string_, pos is right, value is right
Read vector<uint16_t>(7), pos is right, value is right
1,12d0
< Write const void_, pos is right
< Write void_, pos is right
< Write string, pos is right
< Write const string_, pos is right
< Write string_, pos is right
< Write vector<uint16_t>(7), pos is right
< Read const void_, pos is right, value is right
< Read void_, pos is right, value is right
< Read string, pos is right, value is TestString
< Read const string_, pos is right, value is right
< Read string_, pos is right, value is right
< Read vector<uint16_t>(7), pos is right, value is right
Running bvt/bvt13
Testing string reads
A string printed to stdout
1,7d0
< Testing string reads
< A string printed to stdout
< 4 numbers: 12345678, 4321, 0x78675645, 1.234567890123456
< A ustl::string object printed 3 times
< A ustl::string object printed 3 times
< A ustl::string object printed 3 times
< All done.
4 numbers: 12345678, 4321, 0x78675645, 1.234567890123456
A ustl::string object printed 3 times
Running bvt/bvt14
A ustl::string object printed 3 times
A ustl::string object printed 3 times
All done.
There are 1,23d0
< There are 31 days in january.
< There are 30 days in september.
< There are 31 days in december.
< may found at index 8
< Alphabetical listing:
< april has 30 days.
< august has 31 days.
< december has 31 days.
< february has 28 days.
< january has 31 days.
< july has 31 days.
< june has 30 days.
< march has 31 days.
< may has 31 days.
< november has 30 days.
< october has 31 days.
< september has 30 days.
< After erasing may:
< april august december february january july june march november october september
< After erasing months 2, 3, 4, and the last one:
31 days in january.< april january july june march may november october
< After inserting frobuary,42:
< april august december february frobuary january july june march may november october september
There are 30 days in september.
There are 31 days in december.
may found at index 8
Alphabetical listing:
april has 30 days.
august has 31 days.
december has 31 days.
february has 28 days.
january has 31 days.
july has 31 days.
june has 30 days.
march has 31 days.
may has 31 days.
november has 30 days.
october has 31 days.
september has 30 days.
After erasing may:
april august december february january july june march november october september
After erasing months 2, 3, 4, and the last one:
april january july june march may november october
After inserting frobuary,42:
april august december february frobuary january july june march may november october september
Running bvt/bvt15
As-inserted listing:
Dumb - $15000
Dave - $27000
Jim - $27000
Gail - $47000
Barbara - $47000
Mary - $47000
BigBoss - $99000
Alphabetical listing:
1,30d0
Dumb - $15000
Dave - $27000
Jim - $27000
Barbara - $< As-inserted listing:
< Dumb - $15000
< Dave - $27000
< Jim - $27000
< Gail - $47000
< Barbara - $47000
< Mary - $47000
< BigBoss - $99000
< Alphabetical listing:
< Dumb - $15000
< Dave - $27000
< Jim - $27000
< Barbara - $47000
< Gail - $47000
< Mary - $47000
< BigBoss - $99000
< Employees making $47000: Barbara Gail Mary
< Dave makes $27000
< There are 2 low-paid employees
< Firing all low-paid employees:
< Dumb - $15000
< Barbara - $47000
< Gail - $47000
< Mary - $47000
< BigBoss - $99000
< Firing dumb employees:
< Barbara - $47000
< Gail - $47000
< Mary - $47000
< BigBoss - $99000
47000
Gail - $47000
Mary - $47000
BigBoss - $99000
Employees making $Running bvt/bvt16
47000: Barbara Gail Mary
Dave makes $27000
There are 2 low-paid employees
Firing all low-paid employees:
Dumb - $15000
Barbara - $47000
Gail - $47000
Mary - $47000
BigBoss - $99000
Firing dumb employees:
Barbara - $47000
Gail - $47000
MaryGenerating Unicode characters - $47000
BigBoss - $99000
1,11d0
< Generating Unicode characters 0 - 65534
< Encoding to utf8.
< Decoding back.
< Comparing.
< src = 65535 chars, encoded = 194429 chars, decoded = 65535
< 0 differences between src and decoded.
< Testing wide character string::insert
< Values[17]: 1234 49 50 3456 4567 3456 4567 2345 51 52 53 54 55 56 57 48 5678
< Character offsets: 0 2 3 4 7 10 13 16 19 20 21 22 23 24 25 26 27
< Erasing character 16: 1234 49 50 3456 4567 3456 4567 2345 51 52 53 54 55 56 57 48
< Erasing 2 characters after '2': 1234 49 50 3456 4567 2345 51 52 53 54 55 56 57 48
Running bvt/bvt17
1,33d0
< bitset<30> bs1: capacity() = 32, sizeof() = 4
< 000000000000000000000000000000
< 111111111111111111111110111111
< 000000000000000000000001000000
< 111111111111111111111110111111
< 011010011001011001011000100100
< count = 13
< 000000000000000000000000000000
< any = false, none = true, count = 0
< 111111111111111111111111111111
< any = true, none = false, count = 32
< 000000000000000000000110010000
< test(7) == true, [9] = false, [8] = true
< any = true, none = false, count = 3
< ~bs1 == 111111111111111111111001101111
< to_value == 0x190
< bitset<70> bs2: capacity() = 96, sizeof() = 12
< 0000000000000000000000000000000000000000000000000000000000000000101101
< bs2.set(34,40,13)
< 0000000000000000000000000000000011010000000000000000000000000000101101
< bs2.at(34,40) = 13
< bitset<256> bs3: capacity() = 256, sizeof() = 32
< bs3.to_value() == 0x3030
< bs4 == bs1
< bs4 = 0x50505050: 010000010100000101000001010000
< bs1 = 0x30303030: 110000001100000011000000110000
< bs4 &= bs1; bs4 = 010000000100000001000000010000
< bs4 & bs1; bs4 = 010000000100000001000000010000
< bs4 |= bs1; bs4 = 110000011100000111000001110000
< bs4 | bs1; bs4 = 110000011100000111000001110000
< bs4 ^= bs1; bs4 = 100000011000000110000001100000
< bs4 ^ bs1; bs4 = 100000011000000110000001100000
< stream[4]; bs4 = 100000011000000110000001100000
Running bvt/bvt18
bitset<30> bs1: capacity() = 32, sizeof() = 4
000000000000000000000000000000
111111111111111111111110111111
000000000000000000000001000000
111111111111111111111110111111
011010011001011001011000100100
count = 13
000000000000000000000000000000
any = false, none = true, count = 0
111111111111111111111111111111
any = true, none = false, count = 32
000000000000000000000110010000
test(7) == true, [9] = false, [8] = true
any = true, none = false, count = 3
~bs1 == ================================================111111111111111111111001101111
to_value == 0x190
bitset<70> bs2: capacity() = 96, sizeof() = 12
0000000000000000000000000000000000000000000000000000000000000000101101
Testing tuple<4,float>
bs2.set(34,40,13)
0000000000000000000000000000000011010000000000000000000000000000101101
bs2.at(34,40) = 13
bitset<256> bs3: capacity() = 256, sizeof() = 32
bs3.to_value() == 0x3030
bs4 == bs1
bs4 = 0x50505050: 010000010100000101000001010000
bs1 = 0x30303030: 110000001100000011000000110000
bs4 &= bs1; bs4 = 010000000100000001000000010000
bs4 & bs1; bs4 = 010000000100000001000000010000
bs4 |= bs1; bs4 = 110000011100000111000001110000
bs4 | bs1; bs4 = 110000011100000111000001110000
bs4 ^= bs1; bs4 = 100000011000000110000001100000
bs4 ^ bs1; bs4 = 1000000110000001100000011000001,184d0
stream[4]; bs4 = 100000011000000110000001100000
< ================================================
< Testing tuple<4,float>
< ================================================
pt1: size = 4, value = (1.00,2.00,3.00,4.00)
pt2: (5.00,6.00,7.00,8.00)
pt2: < pt1: size = 4, value = (1.00,2.00,3.00,4.00)
< pt2: (5.00,6.00,7.00,8.00)
< pt2: (10.00,11.00,12.00,13.00)
(10.00,11.00,12.00,13.00)
pt1 *= 3: (3.00,6.00,9.00,12.00)
pt1 /= 3: (1.00,2.00,3.00,4.00)
pt1 += 3: (4.00,5.00,6.00,7.00)
pt1 -= 3: (1.00,2.00,3.00,4.00)
pt1 *= pt2: (10.00,22.00,36.00,52.00)
pt1 /= pt2: < pt1 *= 3: (3.00,6.00,9.00,12.00)
< pt1 /= 3: (1.00,2.00,3.00,4.00)
< pt1 += 3: (4.00,5.00,6.00,7.00)
< pt1 -= 3: (1.00,2.00,3.00,4.00)
< pt1 *= pt2: (10.00,22.00,36.00,52.00)
< pt1 /= pt2: (1.00,2.00,3.00,4.00)
< pt1 += pt2: (11.00,13.00,15.00,17.00)
< pt1 -= pt2: (1.00,2.00,3.00,4.00)
< pt1 = pt1 * pt2: (10.00,22.00,36.00,52.00)
< pt1 = pt1 / pt2: (1.00,2.00,3.00,4.00)
< pt1 = pt1 + pt2: (11.00,13.00,15.00,17.00)
< pt1 = pt1 - pt2: (1.00,2.00,3.00,4.00)
< ================================================
< Testing tuple<2,float>
< ================================================
(1.00,2.00,3.00,4.00)
pt1 += pt2: (11.00,13.00,15.00,17.00)
pt1 -= pt2: (1.00,2.00,3.00,4.00)
pt1 = pt1 * pt2: < pt1: size = 2, value = (1.00,2.00)
(10.00,22.00,36.00,52.00)
pt1 = pt1 / pt2: (1.00,2.00,3.00,4.00)
pt1 = pt1 + pt2: (11.00,13.00,15.00,17.00)
pt1 = pt1 - pt2: < pt2: (5.00,6.00)
< pt2: (10.00,11.00)
< pt1 *= 3: (3.00,6.00)
< pt1 /= 3: (1.00,2.00)
< pt1 += 3: (4.00,5.00)
< pt1 -= 3: (1.00,2.00)
(1.00,2.00,3.00,4.00)
Testing tuple<2,float>
================================================< pt1 *= pt2: (10.00,22.00)
< pt1 /= pt2: (1.00,2.00)
< pt1 += pt2: (11.00,13.00)
< pt1 -= pt2: (1.00,2.00)
< pt1 = pt1 * pt2: (10.00,22.00)
< pt1 = pt1 / pt2: (1.00,2.00)
< pt1 = pt1 + pt2: (11.00,13.00)
< pt1 = pt1 - pt2: (1.00,2.00)
< ================================================
< Testing tuple<4,int32_t>
< ================================================
pt1: size = 2, value = (1.00,2.00)
pt2: (5.00,6.00)
pt2: (10.00,11.00)
pt1 *= 3: (3.00,6.00)
pt1 /= 3: (1.00,2.00)
pt1 += 3: (4.00,5.00)
pt1 -= 3: (1.00,2.00)
pt1 *= pt2: (10.00,22.00)
pt1 /= pt2: (1.00,2.00)
pt1 += pt2: (11.00,13.00)
pt1 -= pt2: (1.00,2.00)
pt1 = pt1 * pt2: (10.00,22.00)
pt1 = pt1 / pt2: < pt1: size = 4, value = (1,2,3,4)
< pt2: (5,6,7,8)
< pt2: (10,11,12,13)
< pt1 *= 3: (3,6,9,12)
< pt1 /= 3: (1,2,3,4)
(1.00,2.00)
pt1 = pt1 + pt2: (11.00,13.00)
pt1 = pt1 - pt2: (1.00,2.00)
Testing tuple<4,int32_t>
pt1: size = 4, value = (1,2,3,4)
pt2: (5,6,7,8)
pt2: (10,11,12,13)
pt1 *= 3: (3,6,9,12)
pt1 /= 3: (1,2,3,4)
pt1 += 3: (4,5,6,7)
pt1 -= 3: (1,2,3,4)
pt1 *= pt2: (10,22,36,52)
pt1 /= pt2: (1,2,3,4)
pt1 += pt2: (11,13,15,17)
pt1 -= pt2: (1,2,3,4)
pt1 = pt1 * pt2: (10,22,36,52)
pt1 = pt1 / pt2: (1,2,3,4)
pt1 = pt1 + pt2: (11,13,15,17)
pt1 = pt1 - pt2: (1,2,3,4)
================================================< pt1 += 3: (4,5,6,7)
Testing tuple<4,uint32_t>
pt1: size = 4, value = (1,2,3,4)
pt2: (5,6,7,8)
pt2: (10,11,12,13)
pt1 *= 3: (3,6,9,12)
pt1 /= 3: (1,2,3,4)
pt1 += 3: (4,5,6,7)
pt1 -= 3: < pt1 -= 3: (1,2,3,4)
< pt1 *= pt2: (10,22,36,52)
(1,2,3,4)
pt1 *= pt2: (10,22,36,52)
pt1 /= pt2: (1,2,3,4)
pt1 += pt2: (11,13,15,17)
pt1 -= pt2: (1,2,3,4)
pt1 = pt1 * pt2: (10,22,36,52)
pt1 = pt1 / pt2: (1,2,3,4)
pt1 = pt1 + pt2: (11,13,15,17)
pt1 = pt1 - pt2: (1,2,3,4)
Testing tuple<2,int32_t>
pt1: size = 2, value = (1,2)
pt2: (5,6)
pt2: (10,11)
pt1 *= 3: (3,6)
pt1 /= 3: (1,2)
pt1 += 3: < pt1 /= pt2: (1,2,3,4)
(4,5)
pt1 -= 3: (1,2)
pt1 *= pt2: (10,22)
pt1 /= pt2: (1,2)
pt1 += pt2: (11,13)
pt1 -= pt2: (1,2)
pt1 = pt1 * pt2: (10,22)
pt1 = pt1 / pt2: (1,2)
pt1 = pt1 + pt2: (11,13)
pt1 = pt1 - pt2: (1,2)
================================================< pt1 += pt2: (11,13,15,17)
< pt1 -= pt2: (1,2,3,4)
< pt1 = pt1 * pt2: (10,22,36,52)
< pt1 = pt1 / pt2: (1,2,3,4)
< pt1 = pt1 + pt2: (11,13,15,17)
< pt1 = pt1 - pt2: (1,2,3,4)
< ================================================
< Testing tuple<4,uint32_t>
< ================================================
< pt1: size = 4, value = (1,2,3,4)
< pt2: (5,6,7,8)
< pt2: (10,11,12,13)
< pt1 *= 3: (3,6,9,12)
< pt1 /= 3: (1,2,3,4)
Testing tuple<2,uint32_t>
pt1: size = 2, value = (1,2)
pt2: (5,6)
pt2: (10,11)
pt1 *= 3: (3,6)
pt1 /= 3: (1,2)
pt1 += 3: (4,5)
pt1 -= 3: (1,2)
pt1 *= pt2: (10,22)
pt1 /= pt2: (1,2)
pt1 += pt2: (11,13)
pt1 -= pt2: (1,2)
pt1 = pt1 * pt2: (10,22)
pt1 = pt1 / pt2: (1,2)
pt1 = pt1 + pt2: (11,13)
pt1 = pt1 - pt2: (1,2)
Testing tuple<4,int16_t>
pt1: size = 4, value = (1,2,3,4)
pt2: (5,6,7,8)
pt2: (10,11,12,13)
pt1 *= 3: (3,6,9,12)
pt1 /= 3: (1,2,3,4)
pt1 += 3: (4,5,6,7)
pt1 -= 3: (1,2,3,4)
pt1 *= pt2: (10,22,36,52)
pt1 /= pt2: (1,2,3,4)
pt1 += pt2: (11,13,15,17)
pt1 -= pt2: (1,2,3,4)
pt1 = pt1 * pt2: (10,22,36,52)
pt1 = pt1 / pt2: (1,2,3,4)
pt1 = pt1 + pt2: (11,13,15,17)
pt1 = pt1 - pt2: (1,2,3,4)
Testing tuple<4,uint16_t>
pt1: size = 4, value = (1,2,3,4)
pt2: (5,6,7,8)
pt2: (10,11,12,13)
pt1 *= 3: (3,6,9,12)
pt1 /= 3: (1,2,3,4)
pt1 += 3: (4,5,6,7)
pt1 -= 3: (1,2,3,4)
pt1 *= pt2: (10,22,36,52)
pt1 /= pt2: (1,2,3,4)
pt1 += pt2: (11,13,15,17)
pt1 -= pt2: (1,2,3,4)
pt1 =< pt1 += 3: (4,5,6,7)
pt1 * pt2: (10,22,36,52)
pt1 = pt1 / pt2: (1,2,3,4)
pt1 = pt1 + pt2: (11,13,15,17)
pt1 = pt1 - pt2: (1,2,3,4)
Testing tuple<8,int8_t>
pt1: size = 8, value = (1,2,3,4,5,6,7,8)
pt2: (5,6,7,8,0,0,0,0)
pt2: (10,11,12,13,14,15,16,17)
pt1 *= 3: (3,6,9,12,15,18,21,24)
pt1 /= 3: (1,2,3,4,5,6,7,8)
pt1 += 3: (4,5,6,7,8,9,10,11)
pt1 -= 3: (1,2,3,4,5,6,7,8)
pt1 *= pt2: (10,22,'$','4','F','Z','p',-120)
pt1 /= pt2: (1,2,3,4,5,6,7,-7)
pt1 += pt2: (11,13,15,17,19,21,23,10)
pt1 -= pt2: (1,2,3,4,5,6,7,-7)
pt1 = pt1 * pt2: (10,22,'$','4','F','Z','p',-119)
pt1 = pt1 / pt2: (1,2,3,4,5,6,7,-7)
pt1 = pt1 + pt2: (11,13,15,17,19,21,23,10)
pt1 = pt1 - pt2: (1,2,3,4,5,6,7,-7)
Testing tuple<8,uint8_t>
pt1: size = 8, value = (1,2,3,4,5,6,7,8)
pt2: (5,6,7,8,0,0,0,0)
pt2: (10,11,12,13,14,15,16,17)
pt1 *= 3: (3,6,9,< pt1 -= 3: (1,2,3,4)
12,15,18,21,24)
pt1 /= 3: (1,2,3,4,5,6,7,8)
pt1 += 3: (4,5,6,7,8,9,10,11)
pt1 -= 3: (1,2,3,4,5,6,7,8)
pt1 *= pt2: (10,22,'$','4','F','Z','p',136)
pt1 /= pt2: (1,2,3,4,5,6,7,8)
pt1 += pt2: (11,13,15,17,19,21,23,25)
pt1 -= pt2: (1,2,3,4,5,6,7,8)
pt1 = pt1 * pt2: (10,22,'$','4','F','Z','p',136)
pt1 = pt1 / pt2: (1,2,3,4,5,6,7,8)
pt1 = pt1 + pt2: (11,13,15,17,19,21,23,25)
pt1 = pt1 - pt2: (1,2,3,4,5,6,7,8)
Testing tuple<3,string>
======================< pt1 *= pt2: (10,22,36,52)
str: (str0,str1,str2)
< pt1 /= pt2: (1,2,3,4)
< pt1 += pt2: (11,13,15,17)
< pt1 -= pt2: (1,2,3,4)
< pt1 = pt1 * pt2: (10,22,36,52)
< pt1 = pt1 / pt2: (1,2,3,4)
< pt1 = pt1 + pt2: (11,13,15,17)
< pt1 = pt1 - pt2: (1,2,3,4)
< ================================================
< Testing tuple<2,int32_t>
< ================================================
< pt1: size = 2, value = (1,2)
< pt2: (5,6)
< pt2: (10,11)
< pt1 *= 3: (3,6)
< pt1 /= 3: (1,2)
< pt1 += 3: (4,5)
< pt1 -= 3: (1,2)
< pt1 *= pt2: (10,22)
< pt1 /= pt2: (1,2)
< pt1 += pt2: (11,13)
< pt1 -= pt2: (1,2)
< pt1 = pt1 * pt2: (10,22)
< pt1 = pt1 / pt2: (1,2)
< pt1 = pt1 + pt2: (11,13)
< pt1 = pt1 - pt2: (1,2)
< ================================================
< Testing tuple<2,uint32_t>
< ================================================
< pt1: size = 2, value = (1,2)
< pt2: (5,6)
< pt2: (10,11)
< pt1 *= 3: (3,6)
< pt1 /= 3: (1,2)
< pt1 += 3: (4,5)
< pt1 -= 3: (1,2)
< pt1 *= pt2: (10,22)
< pt1 /= pt2: (1,2)
< pt1 += pt2: (11,13)
< pt1 -= pt2: (1,2)
< pt1 = pt1 * pt2: (10,22)
< pt1 = pt1 / pt2: (1,2)
< pt1 = pt1 + pt2: (11,13)
< pt1 = pt1 - pt2: (1,2)
< ================================================
< Testing tuple<4,int16_t>
< ================================================
< pt1: size = 4, value = (1,2,3,4)
< pt2: (5,6,7,8)
< pt2: (10,11,12,13)
< pt1 *= 3: (3,6,9,12)
< pt1 /= 3: (1,2,3,4)
< pt1 += 3: (4,5,6,7)
< pt1 -= 3: (1,2,3,4)
< pt1 *= pt2: (10,22,36,52)
< pt1 /= pt2: (1,2,3,4)
< pt1 += pt2: (11,13,15,17)
< pt1 -= pt2: (1,2,3,4)
< pt1 = pt1 * pt2: (10,22,36,52)
< pt1 = pt1 / pt2: (1,2,3,4)
< pt1 = pt1 + pt2: (11,13,15,17)
< pt1 = pt1 - pt2: (1,2,3,4)
< ================================================
< Testing tuple<4,uint16_t>
< ================================================
< pt1: size = 4, value = (1,2,3,4)
< pt2: (5,6,7,8)
< pt2: (10,11,12,13)
< pt1 *= 3: (3,6,9,12)
< pt1 /= 3: (1,2,3,4)
< pt1 += 3: (4,5,6,7)
< pt1 -= 3: (1,2,3,4)
< pt1 *= pt2: (10,22,36,52)
< pt1 /= pt2: (1,2,3,4)
< pt1 += pt2: (11,13,15,17)
< pt1 -= pt2: (1,2,3,4)
< pt1 = pt1 * pt2: (10,22,36,52)
< pt1 = pt1 / pt2: (1,2,3,4)
< pt1 = pt1 + pt2: (11,13,15,17)
< pt1 = pt1 - pt2: (1,2,3,4)
< ================================================
< Testing tuple<8,int8_t>
< ================================================
< pt1: size = 8, value = (1,2,3,4,5,6,7,8)
< pt2: (5,6,7,8,0,0,0,0)
< pt2: (10,11,12,13,14,15,16,17)
< pt1 *= 3: (3,6,9,12,15,18,21,24)
< pt1 /= 3: (1,2,3,4,5,6,7,8)
< pt1 += 3: (4,5,6,7,8,9,10,11)
< pt1 -= 3: (1,2,3,4,5,6,7,8)
< pt1 *= pt2: (10,22,'$','4','F','Z','p',-120)
< pt1 /= pt2: (1,2,3,4,5,6,7,-7)
< pt1 += pt2: (11,13,15,17,19,21,23,10)
< pt1 -= pt2: (1,2,3,4,5,6,7,-7)
< pt1 = pt1 * pt2: (10,22,'$','4','F','Z','p',-119)
< pt1 = pt1 / pt2: (1,2,3,4,5,6,7,-7)
< pt1 = pt1 + pt2: (11,13,15,17,19,21,23,10)
< pt1 = pt1 - pt2: (1,2,3,4,5,6,7,-7)
< ================================================
< Testing tuple<8,uint8_t>
< ================================================
< pt1: size = 8, value = (1,2,3,4,5,6,7,8)
< pt2: (5,6,7,8,0,0,0,0)
< pt2: (10,11,12,13,14,15,16,17)
< pt1 *= 3: (3,6,9,12,15,18,21,24)
< pt1 /= 3: (1,2,3,4,5,6,7,8)
< pt1 += 3: (4,5,6,7,8,9,10,11)
< pt1 -= 3: (1,2,3,4,5,6,7,8)
< pt1 *= pt2: (10,22,'$','4','F','Z','p',136)
< pt1 /= pt2: (1,2,3,4,5,6,7,8)
< pt1 += pt2: (11,13,15,17,19,21,23,25)
< pt1 -= pt2: (1,2,3,4,5,6,7,8)
< pt1 = pt1 * pt2: (10,22,'$','4','F','Z','p',136)
< pt1 = pt1 / pt2: (1,2,3,4,5,6,7,8)
< pt1 = pt1 + pt2: (11,13,15,17,19,21,23,25)
< pt1 = pt1 - pt2: (1,2,3,4,5,6,7,8)
< ================================================
< Testing tuple<3,string>
< ================================================
< str: (str0,str1,str2)
Running bvt/bvt19
Testing operator+
apple = apple
peach = 1,3d0
< Testing operator+
< apple = apple
< peach = peach
peach
Running bvt/bvt20
Testing stack: popping: 5 4 3 2 1
Testing queue: popping: 1 2 3 4 5
1,2d0
< Testing stack: popping: 5 4 3 2 1
< Testing queue: popping: 1 2 3 4 5
Running bvt/bvt21
0 - 65534
Encoding to utf8.
Decoding back.
DivRU(13,5) = 1,68d0
< DivRU(13,5) = 3
< DivRU(15,5) = 3
< DivRU(-12,5) = -3
<
< Align(5) = 8
< Align(5,2) = 6
< Align(17,7) = 21
< Align(14,7) = 14
<
< NextPow2(0) = 1
< NextPow2(1) = 2
< NextPow2(4) = 4
< NextPow2(3827) = 4096
< NextPow2(0xFFFFFFF0) = 1
<
< advance(42,0) = 42
< advance(42,3) = 45
< cvp = 1234
< vp = 4321
< advance(cvp,5) = 1239
< advance(vp,4) = 4325
< distance(cvp,vp) = 30ED
< abs_distance(vp,cvp) = 30ED
<
< size_of_elements(3, c_Numbers) = 12
< VectorSize(c_Numbers[5]) = 5
< VectorSize(c_Numbers[0]) = 0
<
< BitsInType(uint32_t) = 32
< BitsInType(int16_t) = 16
< BitsInType(char) = 8
<
< BitMask(uint32_t,12) = FFF
< BitMask(uint16_t,1) = 1
< BitMask(uint8_t,8) = FF
< BitMask(uint16_t,0) = 0
<
< pack_type(uint8_t, uint16_t) = 4242
< pack_type(uint8_t, uint32_t) = 42424242
< pack_type(uint16_t, uint32_t) = 42434243
< pack_type(uint8_t, uint64_t) = 4242424242424242
< pack_type(uint32_t, uint64_t) = 4243444542434445
<
< bswap(1234) = 3412
< le_to_native(1234) = ok
< native_to_le(1234) = ok
< be_to_native(1234) = ok
< native_to_be(1234) = ok
< bswap(12345678) = 78563412
< le_to_native(12345678) = ok
< native_to_le(12345678) = ok
< be_to_native(12345678) = ok
< native_to_be(12345678) = ok
< bswap(123456789ABCDEF0) = F0DEBC9A78563412
< le_to_native(123456789ABCDEF0) = ok
< native_to_le(123456789ABCDEF0) = ok
< be_to_native(123456789ABCDEF0) = ok
< native_to_be(123456789ABCDEF0) = ok
<
< absv(12) = 12
< absv(-12) = 12
< sign(12) = 1
< sign(-12) = -1
< sign(0) = 0
< min(3,4) = 3
< min(6U,1U) = 1
< max(-3,-6) = -3
< max(-3L,6L) = 6
3
DivRU(15,5) = Running bvt/bvt22
3
DivRU(-12,5) = -3
Align(5) = 8
Align(5,2) = Comparing.
src = 65535 chars, encoded = 194429 chars, decoded = 65535
0 differences between src and decoded.
Testing wide character string::insert
Values[17]: 1234 49 50 3456 4567 3456 4567 2345 51 52 53 54 55 56 57 48 5678
Character offsets: 0 2 3 4 7 10 13 16 19 20 21 22 23 24 25 26 27
Erasing character 16: 1234 49 50 3456 4567 3456 4567 2345 51 52 53 54 55 56 57 48
6
Align(17,7) = 21
Align(14,7) = Erasing 2 characters after '2': 1234 49 50 3456 4567 2345 51 52 53 54 55 56 57 48
14
NextPow2(0) = 1
NextPow2(1) = 2
NextPow2(4) = 4
NextPow2(3827) = 4096
NextPow2(0xFFFFFFF0) = 1
advance(42,0) = 42
advance(42,3) = 45
cvp = 1234
vp = 4321
advance(cvp,5) = 1,58d0
< ========================================
< Testing 4x4 int matrix:
< ========================================
< load_identity(m1)
< m1 = ((1,0,0,0)(0,1,0,0)(0,0,1,0)(0,0,0,1))
< m1 = m2
< m2 = ((1,0,0,0)(0,1,0,0)(0,0,1,0)(0,0,0,1))
1239
advance(vp,4) = 4325
distance(cvp,vp) = 30ED
abs_distance(vp,cvp) = ========================================
Testing 4x4 int matrix:
30ED
size_of_elements(3, c_Numbers) = 12
VectorSize(c_Numbers[5]) = 5
VectorSize(c_Numbers[0]) = < m1 += m2
load_identity(m1)
m1 = ((1,0,0,0)(0,1,0,0)(0,0,1,0)(0,0,0,1))
m1 = m2
m2 = ((1,0,0,0)(0,1,0,0)(0,0,1,0)(0,0,0,1))
m1 += m2
m1 = ((2,0,0,0)(0,2,0,0)(0,0,2,0)(0,0,0,2))
m1 /= 2
m1 = ((1,0,0,0)(0,1,0,0)(0,0,1,0)(0,0,0,1))
m1 = m1 * m2
m1 = ((1,0,0,0)(0,1,0,0)(0,0,1,0)(0,0,0,1))
m1 += 3
m1 = ((4,3,3,3)(3,4,3,3)(3,3,4,3)(3,3,3,4))
m1 *= I(2)
m1 = ((8,6,6,6)(6,8,6,6)(6,6,8,6)(6,6,6,8))
m1 = iota(1)
m1 = ((1,2,3,4)(5,6,7,8)(9,10,11,12)(13,14,15,16))
m1 row [1] = (5,6,7,8)
m1 column [2] = (3,7,11,15)
m1 *= I(2)
m1 = ((2,4,6,8)(10,12,14,16)(18,20,22,24)(26,28,30,32))
v = iota(1)
v = (1,2,3,4)
m2 = I(2) + T(1)
m2 = ((2,0,0,0)(0,2,0,0)(0,0,2,0)(1,1,1,2))
vt = v * m2
vt = (6,8,10,8)
Testing 4x4 float matrix:
load_identity(m1)
m1 = ((1.0,0.0,0.0,0.0)(0.0,1.0,0.0,0.0)(0.0,0.0,1.0,0.0)(0.0,0.0,0.0,1.0))
m1 = m2
m2 = ((1.0,0.0,0.0,0.0)(0.0,1.0,0.0,0.0)(0.0,0.0,1.0,0.0)(0.0,0.0,0.0,1.0))
m1 += m2
m1 = ((2.0,0.0,0.0,0.0)(0.0,2.0,0.0,0.0)(0.0,0.0,2.0,0.0)(0.0,0.0,0.0,2.0))
m1 /= 2
m1 = ((1.0,0.0,0.0,0.0)(0.0,1.0,0.0,0.0)(0.0,0.0,1.0,0.0)(0.0,0.0,0.0,1.0))
m1 = m1 * m2
m1 = ((1.0,0.0,0.0,0.0)(0.0,1.0,0.0,0.0)(0.0,0.0,1.0,0.0)(0.0,0.0,0.0,1.0))
m1 += 3
m1 = ((4.0,3.0,3.0,3.0)(3.0,4.0,3.0,3.0)(3.0,3.0,4.0,3.0)(3.0,3.0,3.0,4.0))
m1 *= I(2)
m1 = ((8.0,6.0,6.0,6.0)(6.0,8.0,6.0,6.0)(6.0,6.0,8.0,6.0)(6.0,6.0,6.0,8.0))
m1 = iota(1)
m1 = ((1.0,2.0,3.0,4.0)(5.0,6.0,7.0,8.0)(9.0,10.0,11.0,12.0)(13.0,14.0,15.0,16.0))
m1 row [1] = (5.0,6.0,7.0,8.0)
m1 column [2] = (3.0,7.0,11.0,15.0)
m1 *= I(2)
m1 = ((2.0,4.0,6.0,8.0)(10.0,12.0,14.0,16.0)(18.0,20.0,22.0,24.0)(26.0,28.0,30.0,32.0))
v = iota(1)
v = (1.0,2.0,3.0,4.0)
m2 = I(2) + T(1)
m2 = ((2.0,0.0,0.0,0.0)(0.0,2.0,0.0,0.0)(0.0,0.0,2.0,0.0)(1.0,1.0,1.0,2.0))
vt = v * m2
vt = (6.0,8.0,10.0,8.0)
0
BitsInType(uint32_t) = 32
BitsInType(int16_t) = 16
BitsInType(char) = 8
BitMask(uint32_t,12) = < m1 = ((2,0,0,0)(0,2,0,0)(0,0,2,0)(0,0,0,2))
< m1 /= 2
< m1 = ((1,0,0,0)(0,1,0,0)(0,0,1,0)(0,0,0,1))
< m1 = m1 * m2
< m1 = ((1,0,0,0)(0,1,0,0)(0,0,1,0)(0,0,0,1))
< m1 += 3
< m1 = ((4,3,3,3)(3,4,3,3)(3,3,4,3)(3,3,3,4))
< m1 *= I(2)
< m1 = ((8,6,6,6)(6,8,6,6)(6,6,8,6)(6,6,6,8))
< m1 = iota(1)
< m1 = ((1,2,3,4)(5,6,7,8)(9,10,11,12)(13,14,15,16))
< m1 row [1] = (5,6,7,8)
< m1 column [2] = (3,7,11,15)
< m1 *= I(2)
< m1 = ((2,4,6,8)(10,12,14,16)(18,20,22,24)(26,28,30,32))
< v = iota(1)
< v = (1,2,3,4)
< m2 = I(2) + T(1)
< m2 = ((2,0,0,0)(0,2,0,0)(0,0,2,0)(1,1,1,2))
< vt = v * m2
< vt = (6,8,10,8)
< ========================================
< Testing 4x4 float matrix:
FFF
BitMask(uint16_t,1) = 1
BitMask(uint8_t,8) = FF
BitMask(uint16_t,0) = 0
pack_type(uint8_t, uint16_t) = 4242
pack_type(uint8_t, uint32_t) = 42424242
pack_type(uint16_t, uint32_t) = 42434243
pack_type(uint8_t, uint64_t) = < ========================================
< load_identity(m1)
< m1 = ((1.0,0.0,0.0,0.0)(0.0,1.0,0.0,0.0)(0.0,0.0,1.0,0.0)(0.0,0.0,0.0,1.0))
< m1 = m2
< m2 = ((1.0,0.0,0.0,0.0)(0.0,1.0,0.0,0.0)(0.0,0.0,1.0,0.0)(0.0,0.0,0.0,1.0))
< m1 += m2
< m1 = ((2.0,0.0,0.0,0.0)(0.0,2.0,0.0,0.0)(0.0,0.0,2.0,0.0)(0.0,0.0,0.0,2.0))
< m1 /= 2
< m1 = ((1.0,0.0,0.0,0.0)(0.0,1.0,0.0,0.0)(0.0,0.0,1.0,0.0)(0.0,0.0,0.0,1.0))
< m1 = m1 * m2
< m1 = ((1.0,0.0,0.0,0.0)(0.0,1.0,0.0,0.0)(0.0,0.0,1.0,0.0)(0.0,0.0,0.0,1.0))
< m1 += 3
< m1 = ((4.0,3.0,3.0,3.0)(3.0,4.0,3.0,3.0)(3.0,3.0,4.0,3.0)(3.0,3.0,3.0,4.0))
< m1 *= I(2)
< m1 = ((8.0,6.0,6.0,6.0)(6.0,8.0,6.0,6.0)(6.0,6.0,8.0,6.0)(6.0,6.0,6.0,8.0))
< m1 = iota(1)
< m1 = ((1.0,2.0,3.0,4.0)(5.0,6.0,7.0,8.0)(9.0,10.0,11.0,12.0)(13.0,14.0,15.0,16.0))
< m1 row [1] = (5.0,6.0,7.0,8.0)
< m1 column [2] = (3.0,7.0,11.0,15.0)
< m1 *= I(2)
< m1 = ((2.0,4.0,6.0,8.0)(10.0,12.0,14.0,16.0)(18.0,20.0,22.0,24.0)(26.0,28.0,30.0,32.0))
< v = iota(1)
< v = (1.0,2.0,3.0,4.0)
< m2 = I(2) + T(1)
< m2 = ((2.0,0.0,0.0,0.0)(0.0,2.0,0.0,0.0)(0.0,0.0,2.0,0.0)(1.0,1.0,1.0,2.0))
< vt = v * m2
< vt = (6.0,8.0,10.0,8.0)
4242424242424242
pack_type(uint32_t, uint64_t) = 4243444542434445
bswap(1234) = 3412
le_to_native(1234) = ok
native_to_le(Running bvt/bvt23
1234) = ok
be_to_native(1234) = ok
native_to_be(1234) = ok
bswap(12345678) = 78563412
le_to_native(12345678) = ok
native_to_le(12345678) = ok
be_to_native(12345678) = ok
native_to_be(12345678) = ok
bswap(123456789ABCDEF0) = F0DEBC9A78563412
le_to_native(123456789ABCDEF0) = ok
native_to_le(123456789ABCDEF0) = ok
be_to_native(123456789ABCDEF0) = ok
native_to_be(123456789ABCDEF0) = ok
absv(12) = 12
absv(-12) = 12
sign(12) = 1
sign(-12) = -1
sign(0) = 0
min(3,4) = 3
min(6U,1U) = 1
max(-3,-6) = -3
max(-3L,6L) = ================================================
Testing uint8_t[8]
op1 = (2,2,2,2,2,2,2,2)
op2 = (1,2,3,4,5,6,7,8)
passign(op2,op3) = (1,2,3,4,5,6,7,8)
padd(op1,op2) = (3,4,5,6,7,8,9,10)
psub(op1,op2) = (1,2,3,4,5,6,7,8)
pmul(op1,op2) = (2,4,6,8,10,12,14,16)
pdiv(op1,op2) = (1,2,3,4,5,6,7,8)
pand(op1,op2) = (0,2,2,0,0,2,2,0)
por(op1,op2) = (3,2,3,6,7,6,7,10)
pxor(op1,op2) = (3,0,1,6,7,4,5,10)
pshl(op1,op2) = (4,8,12,16,20,24,28,' ')
pshr(op1,op2) = (0,0,0,1,1,1,1,2)
pmin(op3,op2) = (1,2,3,4,4,3,2,1)
pmax(op3,op2) = (8,7,6,5,5,6,7,8)
pavg(op3,op2) = (5,5,5,5,5,5,5,5)
Testing int8_t[8]
op1 = (2,2,2,2,2,2,2,2)
op2 = (1,2,3,4,5,6,7,8)
passign(op2,op3) = (1,2,3,4,5,6,7,8)
padd(op1,op2) = (3,4,5,6,7,8,9,10)
psub(op1,op2) = (1,2,3,4,5,6,7,8)
pmul(op1,op2) = (2,4,6,8,10,12,14,16)
pdiv(op1,op2) = (1,2,3,4,5,6,7,8)
pand(op1,op2) = (0,2,2,0,0,2,2,0)
por(op1,op2) = (3,2,3,6,7,6,7,10)
pxor(op1,op2) = (3,0,1,6,7,4,5,10)
pshl(op1,op2) = (4,8,12,16,20,24,28,' ')
pshr(op1,op2) = (0,0,0,1,1,1,1,2)
pmin(op3,op2) = (1,2,3,4,4,3,2,1)
pmax(op3,op2) = (8,7,6,5,5,6,7,8)
pavg(op3,op2) = (5,5,5,5,5,5,5,5)
Testing uint16_t[4]
op1 = (2,2,2,2)
op2 = (1,2,3,4)
passign(op2,op3) = (1,2,3,4)
padd(op1,op2) = (3,4,5,6)
psub(op1,op2) = (1,2,3,4)
pmul(op1,op2) = (2,4,6,8)
pdiv(op1,op2) = (1,2,3,4)
pand(op1,op2) = (0,2,2,0)
por(op1,op2) = (3,2,3,6)
pxor(op1,op2) = (3,0,1,6)
pshl(op1,op2) = (4,8,12,16)
pshr(op1,op2) = (0,0,0,1)
pmin(op3,op2) = (1,2,2,1)
pmax(op3,op2) = (4,3,3,4)
pavg(op3,op2) = (3,3,3,3)
Testing int16_t[4]
op1 = (2,2,2,2)
op2 = (1,2,3,4)
passign(op2,op3) = (1,2,3,4)
padd(op1,op2) = (3,4,5,6)
psub(op1,op2) = (1,2,3,4)
pmul(op1,op2) = (2,4,6,8)
pdiv(op1,op2) = (1,2,3,4)
pand(op1,op2) = (0,2,2,0)
por(op1,op2) = (3,2,3,6)
pxor(op1,op2) = (3,0,1,6)
pshl(op1,op2) = (4,8,12,16)
pshr(op1,op2) = (0,0,0,1)
pmin(op3,op2) = (1,2,2,1)
pmax(op3,op2) = (4,3,3,4)
pavg(op3,op2) = (3,3,3,3)
Testing uint32_t[2]
op1 = (2,2)
op2 = (1,2)
passign(op2,op3) = (1,2)
padd(op1,op2) = (3,4)
psub(op1,op2) = (1,2)
pmul(op1,op2) = (2,4)
pdiv(op1,op2) = (1,2)
pand(op1,op2) = (0,2)
por(op1,op2) = (3,2)
pxor(op1,op2) = (3,0)
pshl(op1,op2) = (4,8)
pshr(op1,op2) = (0,0)
pmin(op3,op2) = (1,1)
pmax(op3,op2) = (2,2)
pavg(op3,op2) = (2,2)
Testing int32_t[2]
op1 = (2,2)
op2 = (1,2)
passign(op2,op3) = (1,2)
padd(op1,op2) = (3,4)
psub(op1,op2) = (1,2)
pmul(op1,op2) = (2,4)
pdiv(op1,op2) = (1,2)
pand(op1,op2) = (0,2)
por(op1,op2) = (3,2)
pxor(op1,op2) = (3,0)
pshl(op1,op2) = (4,8)
pshr(op1,op2) = (0,0)
pmin(op3,op2) = (1,1)
pmax(op3,op2) = (2,2)
pavg(op3,op2) = (2,2)
Testing uint64_t[1]
op1 = (2)
op2 = (1)
passign(op2,op3) = (1)
padd(op1,op2) = (3)
psub(op1,op2) = (1)
pmul(op1,op2) = (2)
pdiv(op1,op2) = (1)
pand(op1,op2) = (0)
por(op1,op2) = (3)
pxor(op1,op2) = (3)
pshl(op1,op2) = (4)
pshr(op1,op2) = (0)
pmin(op3,op2) = (1)
pmax(op3,op2) = (1)
pavg(op3,op2) = (1)
Testing int64_t[1]
op1 = (2)
op2 = (1)
passign(op2,op3) = (1)
padd(op1,op2) = (3)
psub(op1,op2) = (1)
pmul(op1,op2) = (2)
pdiv(op1,op2) = (1)
pand(op1,op2) = (0)
por(op1,op2) = (3)
pxor(op1,op2) = (3)
pshl(op1,op2) = (4)
pshr(op1,op2) = (0)
pmin(op3,op2) = (1)
pmax(op3,op2) = (1)
pavg(op3,op2) = (1)
Testing float[2]
op1 = (2.00,2.00)
op2 = (1.00,2.00)
passign(op2,op3) = (1.00,2.00)
padd(op1,op2) = (3.00,4.00)
psub(op1,op2) = (1.00,2.00)
pmul(op1,op2) = (2.00,4.00)
pdiv(op1,op2) = (1.00,2.00)
pmin(op3,op2) = (1.00,1.00)
pmax(op3,op2) = (2.00,2.00)
pavg(op3,op2) = (1.50,1.50)
Testing float[4]
op1 = (2.00,2.00,2.00,2.00)
op2 = (1.00,2.00,3.00,4.00)
passign(op2,op3) = (1.00,2.00,3.00,4.00)
padd(op1,op2) = (3.00,4.00,5.00,6.00)
psub(op1,op2) = (1.00,2.00,3.00,4.00)
pmul(op1,op2) = (2.00,4.00,6.00,8.00)
pdiv(op1,op2) = (1.00,2.00,3.00,4.00)
pmin(op3,op2) = (1.00,2.00,2.00,1.00)
pmax(op3,op2) = (4.00,3.00,3.00,4.00)
pavg(op3,op2) = (2.50,2.50,2.50,2.50)
Testing uint32_t[7]
op1 = (2,2,2,2,2,2,2)
op2 = (1,2,3,4,5,6,7)
passign(op2,op3) = (1,2,3,4,5,6,7)
padd(op1,op2) = (3,4,5,6,7,8,9)
psub(op1,op2) = (1,2,3,4,5,6,7)
pmul(op1,op2) = (2,4,6,8,10,12,14)
pdiv(op1,op2) = (1,2,3,4,5,6,7)
pand(op1,op2) = (0,2,2,0,0,2,2)
por(op1,op2) = (3,2,3,6,7,6,7)
pxor(op1,op2) = (3,0,1,6,7,4,5)
pshl(op1,op2) = (4,8,12,16,20,24,28)
pshr(op1,op2) = (0,0,0,1,1,1,1)
pmin(op3,op2) = (1,2,3,4,3,2,1)
pmax(op3,op2) = (7,6,5,4,5,6,7)
pavg(op3,op2) = (4,4,4,4,4,4,4)
Testing fround int32_t -> float
(-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
(-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
(-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
Testing fround int32_t -> double
(-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
(-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
(-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
Testing fround float -> int32_t
(-1.40,-0.40,0.60,1.60) -> (-1,0,1,2)
(-1.50,-0.50,0.50,1.50) -> (-2,0,0,2)
(-1.70,-0.70,0.30,1.30) -> (-2,-1,0,1)
Testing fround double -> int32_t
(-1.40,-0.40,0.60,1.60) -> (-1,0,1,2)
(-1.50,-0.50,0.50,1.50) -> (-2,0,0,2)
(-1.70,-0.70,0.30,1.30) -> (-2,-1,0,1)
Testing fcast float -> int32_t
(-1.40,-0.40,0.60,1.60) -> (-1,0,0,1)
(-1.50,-0.50,0.50,1.50) -> (-1,0,0,1)
(-1.70,-0.70,0.30,1.30) -> (-1,0,0,1)
6
1,218d0
< ================================================
< Testing uint8_t[8]
< ================================================
< op1 = (2,2,2,2,2,2,2,2)
< op2 = (1,2,3,4,5,6,7,8)
< passign(op2,op3) = (1,2,3,4,5,6,7,8)
< padd(op1,op2) = (3,4,5,6,7,8,9,10)
< psub(op1,op2) = (1,2,3,4,5,6,7,8)
< pmul(op1,op2) = (2,4,6,8,10,12,14,16)
< pdiv(op1,op2) = (1,2,3,4,5,6,7,8)
< pand(op1,op2) = (0,2,2,0,0,2,2,0)
< por(op1,op2) = (3,2,3,6,7,6,7,10)
< pxor(op1,op2) = (3,0,1,6,7,4,5,10)
< pshl(op1,op2) = (4,8,12,16,20,24,28,' ')
< pshr(op1,op2) = (0,0,0,1,1,1,1,2)
< pmin(op3,op2) = (1,2,3,4,4,3,2,1)
< pmax(op3,op2) = (8,7,6,5,5,6,7,8)
< pavg(op3,op2) = (5,5,5,5,5,5,5,5)
< ================================================
< Testing int8_t[8]
< ================================================
< op1 = (2,2,2,2,2,2,2,2)
< op2 = (1,2,3,4,5,6,7,8)
< passign(op2,op3) = (1,2,3,4,5,6,7,8)
< padd(op1,op2) = (3,4,5,6,7,8,9,10)
< psub(op1,op2) = (1,2,3,4,5,6,7,8)
< pmul(op1,op2) = (2,4,6,8,10,12,14,16)
< pdiv(op1,op2) = (1,2,3,4,5,6,7,8)
< pand(op1,op2) = (0,2,2,0,0,2,2,0)
< por(op1,op2) = (3,2,3,6,7,6,7,10)
< pxor(op1,op2) = (3,0,1,6,7,4,5,10)
< pshl(op1,op2) = (4,8,12,16,20,24,28,' ')
< pshr(op1,op2) = (0,0,0,1,1,1,1,2)
< pmin(op3,op2) = (1,2,3,4,4,3,2,1)
< pmax(op3,op2) = (8,7,6,5,5,6,7,8)
< pavg(op3,op2) = (5,5,5,5,5,5,5,5)
< ================================================
< Testing uint16_t[4]
< ================================================
< op1 = (2,2,2,2)
< op2 = (1,2,3,4)
< passign(op2,op3) = (1,2,3,4)
< padd(op1,op2) = (3,4,5,6)
< psub(op1,op2) = (1,2,3,4)
< pmul(op1,op2) = (2,4,6,8)
< pdiv(op1,op2) = (1,2,3,4)
< pand(op1,op2) = (0,2,2,0)
< por(op1,op2) = (3,2,3,6)
< pxor(op1,op2) = (3,0,1,6)
< pshl(op1,op2) = (4,8,12,16)
< pshr(op1,op2) = (0,0,0,1)
< pmin(op3,op2) = (1,2,2,1)
< pmax(op3,op2) = (4,3,3,4)
< pavg(op3,op2) = (3,3,3,3)
< ================================================
< Testing int16_t[4]
< ================================================
< op1 = (2,2,2,2)
< op2 = (1,2,3,4)
< passign(op2,op3) = (1,2,3,4)
< padd(op1,op2) = (3,4,5,6)
< psub(op1,op2) = (1,2,3,4)
< pmul(op1,op2) = (2,4,6,8)
< pdiv(op1,op2) = (1,2,3,4)
< pand(op1,op2) = (0,2,2,0)
< por(op1,op2) = (3,2,3,6)
< pxor(op1,op2) = (3,0,1,6)
< pshl(op1,op2) = (4,8,12,16)
< pshr(op1,op2) = (0,0,0,1)
< pmin(op3,op2) = (1,2,2,1)
< pmax(op3,op2) = (4,3,3,4)
< pavg(op3,op2) = (3,3,3,3)
< ================================================
< Testing uint32_t[2]
< ================================================
< op1 = (2,2)
< op2 = (1,2)
< passign(op2,op3) = (1,2)
< padd(op1,op2) = (3,4)
< psub(op1,op2) = (1,2)
< pmul(op1,op2) = (2,4)
< pdiv(op1,op2) = (1,2)
< pand(op1,op2) = (0,2)
< por(op1,op2) = (3,2)
< pxor(op1,op2) = (3,0)
< pshl(op1,op2) = (4,8)
< pshr(op1,op2) = (0,0)
< pmin(op3,op2) = (1,1)
< pmax(op3,op2) = (2,2)
< pavg(op3,op2) = (2,2)
< ================================================
< Testing int32_t[2]
< ================================================
< op1 = (2,2)
< op2 = (1,2)
< passign(op2,op3) = (1,2)
< padd(op1,op2) = (3,4)
< psub(op1,op2) = (1,2)
< pmul(op1,op2) = (2,4)
< pdiv(op1,op2) = (1,2)
< pand(op1,op2) = (0,2)
< por(op1,op2) = (3,2)
< pxor(op1,op2) = (3,0)
< pshl(op1,op2) = (4,8)
< pshr(op1,op2) = (0,0)
< pmin(op3,op2) = (1,1)
< pmax(op3,op2) = (2,2)
< pavg(op3,op2) = (2,2)
< ================================================
< Testing uint64_t[1]
< ================================================
< op1 = (2)
< op2 = (1)
< passign(op2,op3) = (1)
< padd(op1,op2) = (3)
< psub(op1,op2) = (1)
< pmul(op1,op2) = (2)
< pdiv(op1,op2) = (1)
< pand(op1,op2) = (0)
< por(op1,op2) = (3)
< pxor(op1,op2) = (3)
< pshl(op1,op2) = (4)
< pshr(op1,op2) = (0)
< pmin(op3,op2) = (1)
< pmax(op3,op2) = (1)
< pavg(op3,op2) = (1)
< ================================================
< Testing int64_t[1]
< ================================================
< op1 = (2)
< op2 = (1)
< passign(op2,op3) = (1)
< padd(op1,op2) = (3)
< psub(op1,op2) = (1)
< pmul(op1,op2) = (2)
< pdiv(op1,op2) = (1)
< pand(op1,op2) = (0)
< por(op1,op2) = (3)
< pxor(op1,op2) = (3)
< pshl(op1,op2) = (4)
< pshr(op1,op2) = (0)
< pmin(op3,op2) = (1)
< pmax(op3,op2) = (1)
< pavg(op3,op2) = (1)
< ================================================
< Testing float[2]
< ================================================
< op1 = (2.00,2.00)
< op2 = (1.00,2.00)
< passign(op2,op3) = (1.00,2.00)
< padd(op1,op2) = (3.00,4.00)
< psub(op1,op2) = (1.00,2.00)
< pmul(op1,op2) = (2.00,4.00)
< pdiv(op1,op2) = (1.00,2.00)
< pmin(op3,op2) = (1.00,1.00)
< pmax(op3,op2) = (2.00,2.00)
< pavg(op3,op2) = (1.50,1.50)
< ================================================
< Testing float[4]
< ================================================
< op1 = (2.00,2.00,2.00,2.00)
< op2 = (1.00,2.00,3.00,4.00)
< passign(op2,op3) = (1.00,2.00,3.00,4.00)
< padd(op1,op2) = (3.00,4.00,5.00,6.00)
< psub(op1,op2) = (1.00,2.00,3.00,4.00)
< pmul(op1,op2) = (2.00,4.00,6.00,8.00)
< pdiv(op1,op2) = (1.00,2.00,3.00,4.00)
< pmin(op3,op2) = (1.00,2.00,2.00,1.00)
< pmax(op3,op2) = (4.00,3.00,3.00,4.00)
< pavg(op3,op2) = (2.50,2.50,2.50,2.50)
< ================================================
< Testing uint32_t[7]
< ================================================
< op1 = (2,2,2,2,2,2,2)
< op2 = (1,2,3,4,5,6,7)
< passign(op2,op3) = (1,2,3,4,5,6,7)
< padd(op1,op2) = (3,4,5,6,7,8,9)
< psub(op1,op2) = (1,2,3,4,5,6,7)
< pmul(op1,op2) = (2,4,6,8,10,12,14)
< pdiv(op1,op2) = (1,2,3,4,5,6,7)
< pand(op1,op2) = (0,2,2,0,0,2,2)
< por(op1,op2) = (3,2,3,6,7,6,7)
< pxor(op1,op2) = (3,0,1,6,7,4,5)
< pshl(op1,op2) = (4,8,12,16,20,24,28)
< pshr(op1,op2) = (0,0,0,1,1,1,1)
< pmin(op3,op2) = (1,2,3,4,3,2,1)
< pmax(op3,op2) = (7,6,5,4,5,6,7)
< pavg(op3,op2) = (4,4,4,4,4,4,4)
< ================================================
< Testing fround int32_t -> float
< ================================================
< (-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
< (-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
< (-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
< ================================================
< Testing fround int32_t -> double
< ================================================
< (-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
< (-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
< (-1,0,1,2) -> (-1.00,0.00,1.00,2.00)
< ================================================
< Testing fround float -> int32_t
< ================================================
< (-1.40,-0.40,0.60,1.60) -> (-1,0,1,2)
< (-1.50,-0.50,0.50,1.50) -> (-2,0,0,2)
< (-1.70,-0.70,0.30,1.30) -> (-2,-1,0,1)
< ================================================
< Testing fround double -> int32_t
< ================================================
< (-1.40,-0.40,0.60,1.60) -> (-1,0,1,2)
< (-1.50,-0.50,0.50,1.50) -> (-2,0,0,2)
< (-1.70,-0.70,0.30,1.30) -> (-2,-1,0,1)
< ================================================
< Testing fcast float -> int32_t
< ================================================
< (-1.40,-0.40,0.60,1.60) -> (-1,0,0,1)
< (-1.50,-0.50,0.50,1.50) -> (-1,0,0,1)
< (-1.70,-0.70,0.30,1.30) -> (-1,0,0,1)
Running bvt/bvt24
93
93
92
93
92 90
92 90
86
1,180d0
< ------------------------------------------------
< 93
93
92 90
86 83
92 90
86 83 86
< ------------------------------------------------
< 93
< 92
< ------------------------------------------------
< 93
< 92 90
< ------------------------------------------------
< 93
< 92 90
< 86
< ------------------------------------------------
< 93
< 92 90
< 86 83
< ------------------------------------------------
< 93
< 92 90
< 86 83 86
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67 27
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67 27 29
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67 27 29 30
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67 27 29 30 35
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67 27 29 30 35 23
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67 27 29 30 35 23 59
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67 27 29 30 35 23 59 35
< ------------------------------------------------
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67 27 29 30 35 23 59 35 29
< ------------------------------------------------
< make_heap on the full range:
< 93
< 92 90
< 86 83 86 77
< 40 72 36 68 82 62 67 63
< 15 26 26 49 21 11 62 67 27 29 30 35 23 59 35 29
< ------------------------------------------------
< pop_heap:
< 92
< 86 90
< 72 83 86 77
< 40 49 36 68 82 62 67 63
< 15 26 26 29 21 11 62 67 27 29 30 35 23 59 35
< ------------------------------------------------
< sort_heap:
< 11 15 21 23 26 26 27 29 29 30 35 35 36 40 49 59 62 62 63 67 67 68 72 77 82 83 86 86 90 92 93
< ------------------------------------------------
< priority_queue push and pop:
< 93 92 90 86 86 83 82 77 72 68 67 67 63 62 62 59 49 40 36 35 35 30 29 29 27 26 26 23 21 15 11
93
92 90
86 83 86 77
Running bvt/bvt25
93
92 90
86 83 86 77
40
86 83 86 77
40 72
Hello world!
123 456 789
two words
and three words
and even four words
93
92 90
86 83 86 77
40 72 36
86 83 86 77
40 72 36 68
86 83 86 77
40 72 36 68 82
86 83 86 77
40 72 36 68 82 62
86 83 86 77
40 72 36 68 82 62 67
86 83 86 77
40 72 36 68 82 62 67 63
40 72 36 68 82 62 67 63
15
40 72 36 68 82 62 67 63
15 26
40 72 36 68 82 62 67 63
15 26 26
1,5d0
< Hello world!
< 123 456 789
< two words
< and three words
< and even four words
93
92 90
86 83 86 77
40 72 36 68 82 62 67 63
15 26 26 49
Running bvt/bvt26
93
92 90
86 83 86 77
40 72 36 68 82 62 67 63
15 26 26 49 21
40 72 36 68 82 62 67 63
15 26 26 49 21 11
123456789
1
12
123
1234
12345
123456
1234567
12345678
123456789
93
92 90
86 83 86 77
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67
1,10d0
< 123456789
< 1
< 12
< 123
< 1234
< 12345
< 123456
< 1234567
< 12345678
< 123456789
93
92 90
86 83 86 77
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67 27
Running bvt/bvt27
93
92 90
86 83 86 77
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67 27 29
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67 27 29 30
Testing functionality from typet.h
sizeof(NullType) = 1
Int2Type(42)::value = 42
Type2Type type value = 56
int == int is true
float == int is false
PrintInt 567
Base is SuperSubclass from Derived is true
Base is SuperSubclass from Base is true
Base is SuperSubclassStrict from Derived is true
Base is SuperSubclassStrict from Base is false
Testing functionality from typelist.h
Length of IntTypesList is 4
PrintShort 1234
PrintFloat 1235.00
PrintShort 1236
Index of double in AllTypesList is 5
Index of float in NoFloatList is -1
Index of double in NoFloatList is 4
Index of double in ReversedList is 0
93
92 90
86 83 86 77
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67 27 29 30 35
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67 27 29 30 35 23
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67 27 29 30 35 23 59
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67 27 29 30 35 23 59 35
1,25d0
93
92 90
86 83 86 77
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67 27 29 30 35 23 59 35 29
make_heap on the full range:
93
92 90
86 83 86 77
40 72 36 68 82 62 67 63
15 26 26 49 21 11 62 67 27 29 30 35 23 59 35 29
pop_heap:
92
86 90
72 83 86 77
40 49 36 68 82 62 67 63
15 26 26 29 21 11 62 67 27 29 30 35 23 59 35
sort_heap:
11 15 21 23 26 26 27 29 29 30 35 35 36 40 49 59 62 62 63 67 67 68 72 77 82 83 86 86 90 92 93
priority_queue push and pop:
93 92 90 86 86 83 82 77 72 68 67< ----------------------------------------------------------------------
67 63 62 62 59 49 40 36 35 35 30 29 29 27 26 26 23 21 15 11
< Testing functionality from typet.h
< ----------------------------------------------------------------------
< sizeof(NullType) = 1
< Int2Type(42)::value = 42
< Type2Type type value = 56
< int == int is true
< float == int is false
< PrintInt 567
< Base is SuperSubclass from Derived is true
< Base is SuperSubclass from Base is true
< Base is SuperSubclassStrict from Derived is true
< Base is SuperSubclassStrict from Base is false
<
< ----------------------------------------------------------------------
< Testing functionality from typelist.h
< ----------------------------------------------------------------------
< Length of IntTypesList is 4
< PrintShort 1234
< PrintFloat 1235.00
< PrintShort 1236
< Index of double in AllTypesList is 5
< Index of float in NoFloatList is -1
< Index of double in NoFloatList is 4
< Index of double in ReversedList is 0
Running bvt/bvt28
Testing array<float,4>
================================================1,184d0
< ================================================
< Testing array<float,4>
< ================================================
< pt1: size = 4, value = (1.00,2.00,3.00,4.00)
< pt2: (5.00,6.00,7.00,8.00)
< pt2: (10.00,11.00,12.00,13.00)
< pt1 *= 3: (3.00,6.00,9.00,12.00)
pt1: size = 4, value = (1.00,2.00,3.00,4.00)
pt2: (5.00,6.00,7.00,8.00)
pt2: < pt1 /= 3: (1.00,2.00,3.00,4.00)
< pt1 += 3: (4.00,5.00,6.00,7.00)
< pt1 -= 3: (1.00,2.00,3.00,4.00)
< pt1 *= pt2: (10.00,22.00,36.00,52.00)
< pt1 /= pt2: (1.00,2.00,3.00,4.00)
< pt1 += pt2: (11.00,13.00,15.00,17.00)
< pt1 -= pt2: (1.00,2.00,3.00,4.00)
< pt1 = pt1 * pt2: (10.00,22.00,36.00,52.00)
< pt1 = pt1 / pt2: (1.00,2.00,3.00,4.00)
< pt1 = pt1 + pt2: (11.00,13.00,15.00,17.00)
< pt1 = pt1 - pt2: (1.00,2.00,3.00,4.00)
< ================================================
< Testing array<float,2>
< ================================================
< pt1: size = 2, value = (1.00,2.00)
< pt2: (5.00,6.00)
< pt2: (10.00,11.00)
< pt1 *= 3: (3.00,6.00)
< pt1 /= 3: (1.00,2.00)
< pt1 += 3: (4.00,5.00)
< pt1 -= 3: (1.00,2.00)
< pt1 *= pt2: (10.00,22.00)
< pt1 /= pt2: (1.00,2.00)
< pt1 += pt2: (11.00,13.00)
< pt1 -= pt2: (1.00,2.00)
< pt1 = pt1 * pt2: (10.00,22.00)
< pt1 = pt1 / pt2: (1.00,2.00)
< pt1 = pt1 + pt2: (11.00,13.00)
< pt1 = pt1 - pt2: (1.00,2.00)
< ================================================
< Testing array<int32_t,4>
< ================================================
< pt1: size = 4, value = (1,2,3,4)
< pt2: (5,6,7,8)
< pt2: (10,11,12,13)
< pt1 *= 3: (3,6,9,12)
< pt1 /= 3: (1,2,3,4)
(10.00,11.00,12.00,13.00)
pt1 *= 3: (3.00,6.00,9.00,12.00)
pt1 /= 3: (1.00,2.00,3.00,4.00)
pt1 += 3: < pt1 += 3: (4,5,6,7)
< pt1 -= 3: (1,2,3,4)
< pt1 *= pt2: (10,22,36,52)
< pt1 /= pt2: (1,2,3,4)
< pt1 += pt2: (11,13,15,17)
< pt1 -= pt2: (1,2,3,4)
< pt1 = pt1 * pt2: (10,22,36,52)
< pt1 = pt1 / pt2: (1,2,3,4)
< pt1 = pt1 + pt2: (11,13,15,17)
< pt1 = pt1 - pt2: (1,2,3,4)
< ================================================
< Testing array<uint32_t,4>
< ================================================
< pt1: size = 4, value = (1,2,3,4)
< pt2: (5,6,7,8)
< pt2: (10,11,12,13)
(4.00,5.00,6.00,7.00)
pt1 -= 3: (1.00,2.00,3.00,4.00)
pt1 *= pt2: (10.00,22.00,36.00,52.00)
pt1 /= pt2: < pt1 *= 3: (3,6,9,12)
< pt1 /= 3: (1,2,3,4)
< pt1 += 3: (4,5,6,7)
< pt1 -= 3: (1,2,3,4)
< pt1 *= pt2: (10,22,36,52)
< pt1 /= pt2: (1,2,3,4)
< pt1 += pt2: (11,13,15,17)
< pt1 -= pt2: (1,2,3,4)
< pt1 = pt1 * pt2: (10,22,36,52)
< pt1 = pt1 / pt2: (1,2,3,4)
< pt1 = pt1 + pt2: (11,13,15,17)
< pt1 = pt1 - pt2: (1,2,3,4)
< ================================================
< Testing array<int32_t,2>
< ================================================
< pt1: size = 2, value = (1,2)
< pt2: (5,6)
< pt2: (10,11)
< pt1 *= 3: (3,6)
< pt1 /= 3: (1,2)
< pt1 += 3: (4,5)
< pt1 -= 3: (1,2)
(1.00,2.00,3.00,4.00)
pt1 += pt2: (11.00,13.00,15.00,17.00)
pt1 -= pt2: (1.00,2.00,3.00,4.00)
pt1 = pt1 * pt2: < pt1 *= pt2: (10,22)
< pt1 /= pt2: (1,2)
< pt1 += pt2: (11,13)
< pt1 -= pt2: (1,2)
< pt1 = pt1 * pt2: (10,22)
(10.00,22.00,36.00,52.00)
pt1 = pt1 / pt2: (1.00,2.00,3.00,4.00)
pt1 = pt1 + pt2: (11.00,13.00,15.00,17.00)
pt1 = pt1 - pt2: (1.00,2.00,3.00,4.00)
Testing array<float,2>
================================================< pt1 = pt1 / pt2: (1,2)
< pt1 = pt1 + pt2: (11,13)
< pt1 = pt1 - pt2: (1,2)
< ================================================
< Testing array<uint32_t,2>
< ================================================
< pt1: size = 2, value = (1,2)
< pt2: (5,6)
< pt2: (10,11)
< pt1 *= 3: (3,6)
< pt1 /= 3: (1,2)
< pt1 += 3: (4,5)
< pt1 -= 3: (1,2)
< pt1 *= pt2: (10,22)
< pt1 /= pt2: (1,2)
< pt1 += pt2: (11,13)
< pt1 -= pt2: (1,2)
< pt1 = pt1 * pt2: (10,22)
< pt1 = pt1 / pt2: (1,2)
< pt1 = pt1 + pt2: (11,13)
< pt1 = pt1 - pt2: (1,2)
< ================================================
< Testing array<int16_t,4>
< ================================================
< pt1: size = 4, value = (1,2,3,4)
< pt2: (5,6,7,8)
< pt2: (10,11,12,13)
< pt1 *= 3: (3,6,9,12)
< pt1 /= 3: (1,2,3,4)
< pt1 += 3: (4,5,6,7)
< pt1 -= 3: (1,2,3,4)
< pt1 *= pt2: (10,22,36,52)
< pt1 /= pt2: (1,2,3,4)
< pt1 += pt2: (11,13,15,17)
< pt1 -= pt2: (1,2,3,4)
< pt1 = pt1 * pt2: (10,22,36,52)
< pt1 = pt1 / pt2: (1,2,3,4)
< pt1 = pt1 + pt2: (11,13,15,17)
< pt1 = pt1 - pt2: (1,2,3,4)
< ================================================
< Testing array<uint16_t,4>
< ================================================
< pt1: size = 4, value = (1,2,3,4)
< pt2: (5,6,7,8)
< pt2: (10,11,12,13)
< pt1 *= 3: (3,6,9,12)
< pt1 /= 3: (1,2,3,4)
< pt1 += 3: (4,5,6,7)
< pt1 -= 3: (1,2,3,4)
< pt1 *= pt2: (10,22,36,52)
< pt1 /= pt2: (1,2,3,4)
< pt1 += pt2: (11,13,15,17)
< pt1 -= pt2: (1,2,3,4)
< pt1 = pt1 * pt2: (10,22,36,52)
< pt1 = pt1 / pt2: (1,2,3,4)
< pt1 = pt1 + pt2: (11,13,15,17)
< pt1 = pt1 - pt2: (1,2,3,4)
< ================================================
< Testing array<int8_t,8>
< ================================================
< pt1: size = 8, value = (1,2,3,4,5,6,7,8)
< pt2: (5,6,7,8,5,6,7,8)
< pt2: (10,11,12,13,14,15,16,17)
< pt1 *= 3: (3,6,9,12,15,18,21,24)
< pt1 /= 3: (1,2,3,4,5,6,7,8)
< pt1 += 3: (4,5,6,7,8,9,10,11)
< pt1 -= 3: (1,2,3,4,5,6,7,8)
< pt1 *= pt2: (10,22,'$','4','F','Z','p',-120)
< pt1 /= pt2: (1,2,3,4,5,6,7,-7)
< pt1 += pt2: (11,13,15,17,19,21,23,10)
< pt1 -= pt2: (1,2,3,4,5,6,7,-7)
< pt1 = pt1 * pt2: (10,22,'$','4','F','Z','p',-119)
< pt1 = pt1 / pt2: (1,2,3,4,5,6,7,-7)
< pt1 = pt1 + pt2: (11,13,15,17,19,21,23,10)
< pt1 = pt1 - pt2: (1,2,3,4,5,6,7,-7)
< ================================================
< Testing array<uint8_t,8>
pt1: size = 2, value = (1.00,2.00)
pt2: (5.00,6.00)
pt2: (10.00,11.00)
pt1 *= 3: (3.00,6.00)
pt1 /= 3: (1.00,2.00)
pt1 += 3: (4.00,5.00)
pt1 -= 3: (1.00,2.00)
pt1 *= pt2: (10.00,22.00)
pt1 /= pt2: (1.00,2.00)
pt1 += pt2: (11.00,13.00)
pt1 -= pt2: (1.00,2.00)
pt1 = pt1 * pt2: (10.00,22.00)
pt1 = pt1 / pt2: (1.00,2.00)
pt1 = pt1 + pt2: (11.00,13.00)
pt1 = pt1 - pt2: (1.00,2.00)
Testing array<int32_t,4>
pt1: size = 4, value = (1,2,3,4)
pt2: (5,6,7,8)
pt2: (10,11,12,13)
pt1 *= 3: (3,6,9,12)
pt1 /= 3: (1,2,3,4)
pt1 += 3: (4,5,6,7)
pt1 -= 3: (1,2,3,4)
pt1 *= pt2: (10,22,36,52)
pt1 /= pt2: (1,2,3,4)
pt1 += pt2: (11,13,15,17)
pt1 -= pt2: (1,2,3,4)
pt1 = pt1 * pt2: (10,22,36,52)
pt1 = pt1 / pt2: (1,2,3,4)
pt1 = pt1 + pt2: (11,13,15,17)
pt1 = pt1 - pt2: (1,2,3,4)
Testing array<uint32_t,4>
pt1: size = 4, value = (1,2,3,4)
pt2: (5,6,7,8)
pt2: (10,11,12,13)
pt1 *= 3: (3,6,9,12)
pt1 /= 3: (1,2,3,4)
pt1 += 3: (4,5,6,7)
pt1 -= 3: (1,2,3,4)
pt1 *= pt2: (10,22,36,52)
pt1 /= pt2: (1,2,3,4)
pt1 += pt2: (11,13,15,17)
pt1 -= pt2: (1,2,3,4)
pt1 = pt1 * pt2: (10,22,36,52)
pt1 = pt1 / pt2: (1,2,3,4)
pt1 = pt1 + pt2: (11,13,15,17)
pt1 = pt1 - pt2: (1,2,3,4)
Testing array<int32_t,2>
pt1: size = 2, value = (1,2)
pt2: (5,6)
pt2: (10,11)
pt1 *= 3: (3,6)
pt1 /= 3: (1,2)
pt1 += 3: (4,5)
pt1 -= 3: (1,2)
pt1 *= pt2: (10,22)
pt1 /= pt2: (1,2)
pt1 += pt2: (11,13)
pt1 -= pt2: (1,2)
pt1 = pt1 * pt2: (10,22)
pt1 = pt1 / pt2: (1,2)
pt1 = pt1 + pt2: (11,13)
pt1 = pt1 - pt2: (1,2)
Testing array<uint32_t,2>
pt1: size = 2, value = (1,2)
pt2: (5,6)
pt2: (10,11)
pt1 *= 3: (3,6)
pt1 /= 3: (1,2)
pt1 += 3: (4,5)
pt1 -= 3: (1,2)
pt1 *= pt2: (10,22)
pt1 /= pt2: (1,2)
pt1 += pt2: (11,13)
pt1 -= pt2: (1,2)
pt1 = pt1 * pt2: (10,22)
pt1 = pt1 / pt2: (1,2)
pt1 = pt1 + pt2: (11,13)
pt1 = pt1 - pt2: (1,2)
Testing array<int16_t,4>
pt1: size = 4, value = (1,2,3,4)
pt2: (5,6,7,8)
pt2: (10,11,12,13)
pt1 *= 3: (3,6,9,12)
pt1 /= 3: (1,2,3,4)
pt1 += 3: (4,5,6,7)
pt1 -= 3: (1,2,3,4)
pt1 *= pt2: (10,22,36,52)
pt1 /= pt2: (1,2,3,4)
pt1 += pt2: (11,13,15,17)
pt1 -= pt2: (1,2,3,4)
pt1 = pt1 * pt2: (10,22,36,52)
pt1 = pt1 / pt2: (1,2,3,4)
pt1 = pt1 + pt2: (11,13,15,17)
pt1 = pt1 - pt2: (1,2,3,4)
Testing array<uint16_t,4>
pt1: size = 4, value = (1,2,3,4)
pt2: (5,6,7,8)
pt2: (10,11,12,13)
pt1 *= 3: (3,6,9,12)
pt1 /= 3: (1,2,3,4)
pt1 += 3: (4,5,6,7)
pt1 -= 3: (1,2,3,4)
pt1 *= pt2: (10,22,36,52)
pt1 /= pt2: (1,2,3,4)
pt1 += pt2: (11,13,15,17)
pt1 -= pt2: (1,2,3,4)
pt1 = pt1 * pt2: (10,22,36,52)
pt1 = pt1 / pt2: (1,2,3,4)
pt1 = pt1 + pt2: (11,13,15,17)
pt1 = pt1 - pt2: (1,2,3,4)
Testing array<int8_t,8>
pt1: size = 8, valu< ================================================
< pt1: size = 8, value = (1,2,3,4,5,6,7,8)
< pt2: (5,6,7,8,5,6,7,8)
< pt2: (10,11,12,13,14,15,16,17)
< pt1 *= 3: (3,6,9,12,15,18,21,24)
< pt1 /= 3: (1,2,3,4,5,6,7,8)
< pt1 += 3: (4,5,6,7,8,9,10,11)
< pt1 -= 3: (1,2,3,4,5,6,7,8)
< pt1 *= pt2: (10,22,'$','4','F','Z','p',136)
< pt1 /= pt2: (1,2,3,4,5,6,7,8)
< pt1 += pt2: (11,13,15,17,19,21,23,25)
< pt1 -= pt2: (1,2,3,4,5,6,7,8)
< pt1 = pt1 * pt2: (10,22,'$','4','F','Z','p',136)
< pt1 = pt1 / pt2: (1,2,3,4,5,6,7,8)
< pt1 = pt1 + pt2: (11,13,15,17,19,21,23,25)
< pt1 = pt1 - pt2: (1,2,3,4,5,6,7,8)
< ================================================
e = (1,2,3,4,5,6,7,8)
pt2: (5,6,7,8,5,6,7,8)
pt2: (10,11,12,13,14,15,16,17)
pt1 *= 3: (3,6,9,12,15,18,21,24)
pt1 /= 3: (1,2,3,4,5,6,7,8)
pt1 += 3: (4,5,6,7,8,9,10,11)
pt1 -= 3: (1,2,3,4,5,6,7,8)
pt1 *= pt2: (10,22,'$','4','F','Z','p',-120)
pt1 /= pt2: (1,2,3,4,5,6,7,-7)
pt1 += pt2: (11,13,15,17,19,21,23,10)
pt1 -= pt2: (1,2,3,4,5,6,7,-7)
pt1 = pt1 * pt2: (10,22,'$','4','F','Z','p',-119)
pt1 = pt1 / pt2: (1,2,3,4,5,6,7,-7)
pt1 = pt1 + pt2: (11,13,15,17,19,21,23,10)
pt1 = pt1 - pt2: (1,2,3,4,5,6,7,-7)
Testing array<uint8_t,8>
pt1: size = 8, value = (1,2,3,4,5,6,7,8)
pt2: (5,6,7,8,5,6,7,8)
pt2: (10,11,12,13,14,15,16,17)
pt1 *= 3: (3,6,9,< Testing array<string,3>
< ================================================
< str: (str0,str1,str2)
12,15,18,21,24)
pt1 /= 3: (1,2,3,4,5,6,7,8)
pt1 += 3: (4,5,6,7,8,9,10,11)
pt1 -= 3: (1,2,3,4,5,6,7,8)
pt1 *= pt2: (10,22,'$','4','F','Z','p',136)
pt1 /= pt2: (1,2,3,4,5,6,7,8)
pt1 += pt2: (11,13,15,17,19,21,23,25)
pt1 -= pt2: (1,2,3,4,5,6,7,8)
pt1 = pt1 * pt2: (10,22,'$','4','F','Z','p',136)
pt1 = pt1 / pt2: (1,2,3,4,5,6,7,8)
pt1 = pt1 + pt2: (11,13,15,17,19,21,23,25)
pt1 = pt1 - pt2: (1,2,3,4,5,6,7,8)
Testing array<string,3>
str: (str0,str1,str2)
Running bvt/bvt29
Testing type traits
true1,170d0
= is_void
false = is_void
false = is_void<void*>
false = is_void
true = is_integral
true = is_integral
true = is_integral
true = is_integral
true = is_integral
true = is_integral
true = is_integral
true = is_integral
true< ----------------------------------------------------------------------
< Testing type traits
< ----------------------------------------------------------------------
< true = is_void
< false = is_void
< false = is_void<void*>
< false = is_void
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< true = is_integral
< false = is_integral
< false = is_integral<void*>
< false = is_integral
< false = is_integral<TTA*>
< true = is_floating_point
< true = is_floating_point
< false = is_floating_point
< false = is_array
< true = is_array<int[4]>
< true = is_array<int[2][4]>
= is_integral
true = is_integral
true = is_integral
true = is_integral
true = is_integral
true = is_integral< true = is_array<const char[]>
< false = is_pointer
< true = is_pointer<void*>
< true = is_pointer<TTA*>
< false = is_lvalue_reference
false = is_integral
false = is_integral<void*>
false = is_integral
false = is_integral<TTA*>
true = is_floating_point
true = is_floating_point
false = is_floating_point
false = is_array
true = is_array<int[4]>
true = is_array<int[2][4]>
true = is_array<const char[]>
false = is_pointer
true = is_pointer<void*>
true = is_pointer<TTA*>
false = is_lvalue_reference
true = is_lvalue_reference<int&>
true = is_lvalue_reference<void*&>
true = is_lvalue_reference<volatile float&>
false = is_rvalue_reference
true = is_rvalue_reference<int&&>
false = is_rvalue_reference<void*&>
true = is_rvalue_reference<volatile float&&>
false = is_reference
true = is_reference<int&>
true = is_reference<void*&>
true = is_reference<volatile float&>
false = is_member_object_pointer
false = is_member_function_pointer
true = is_member_function_pointer<void (TTA::)(void)>
true = is_enum
false = is_enum
false = is_enum
true = is_class
false = is_class
false = is_function
false = is_function<void ()(int)>
true = is_function<decltype(Print)>
false = is_function<void (TTA::)(void)>
true = is_arithmetic
true = is_arithmetic
true = is_arithmetic
false = is_arithmetic
false = is_arithmetic
false = is_floating_point
true = is_floating_point
true = is_floating_point
false = is_floating_point
true = is_object
true = is_object
true = is_object
true = is_object
true = is_scalar
true = is_scalar
false = is_scalar
true = is_scalar
false = is_compound
false = is_compound
true = is_compound
true = is_compound
true = is_member_pointer<void (TTA::)(void)>
false = is_member_pointer<void*>
false = is_const
true = is_const
true = is_const
false = is_volatile
false = is_volatile
true = is_volatile
true = is_pod
true = is_pod<int[15]>
true = is_pod
false = is_pod
false = is_empty
true = is_empty
true = is_empty
true = has_trivial_constructor
false = has_trivial_constructor
true = has_trivial_copy
false = has_trivial_copy
true = has_trivial_assign
false = has_trivial_assign
true = has_trivial_destructor
false = has_trivial_destructor
true = is_signed
false = is_signed
true = is_signed
false = is_unsigned
true = < true = is_lvalue_reference<int&>
is_unsigned
false = is_unsigned
true = sizeof(char) == alignment_of
true = sizeof(short) == alignment_of
true = sizeof(int) == alignment_of
true = sizeof(void_) == alignment_of<void_>
true = sizeof(double) == alignment_of
true = sizeof(char) == alignment_of
true = 0 == rank
true = 1 == rank<int[1]>
true = 2 == rank<int[][2]>
true = 3 == rank<int[1][2][3]>
true = 0 == extent
true = 1 == extent<int[1]>
true = 1 == extent<int[1][2]>
true = 2 == extent<int[][2],1>
true = 1 == extent<int[1][2][3]>
true = 2 == extent<int[1][2][3],1>
true = 3 == extent<int[1][2][3],2>
true = is_same<int,int>
false = is_same<int,unsigned int>
false = is_base_of<int,unsigned int>
true = is_base_of<TTA,TTB>
false = is_base_of<TTA,Polymorphic>
true = is_convertible<int,unsigned int>
true = is_convertible<TTA,TTA>
false = is_convertible<TTA*,TTB*>
true = is_convertible<TTB*,TTA*>
true = is_same<remove_const::type,int>
false = is_same<remove_const::type,int>
false = is_same<remove_volatile::type,int>
false = is_same<remove_volatile::type,int>
false = is_same<add_const::type,volatile int>
true = is_same<add_const::type,const volatile int>
true = is_same<add_volatile::type,volatile int>
true = is_same<add_volatile::type,const volatile int>
true = is_same<add_cv::type,const volatile int>
true = is_same<remove_pointer<int*>::type,int>
true = is_same<remove_reference<const int&>::type,const int>
true = is_same<remove_reference<const volatile int&>::type,const volatile int>
true = is_same<add_pointer::type,int_>
true = is_same<add_lvalue_reference::type,volatile int&>
true = is_same<add_rvalue_reference::type,int&&>
true = is_same<remove_extent::type,int>
true = is_same<remove_extent<int[2][3]>::type,int[3]>
true = is_same<remove_extent<int[][3]>::type,int[3]>
true = is_same<remove_extent<int[3]>::type,int>
true = is_same<remove_all_extents::type,int>
true = is_same<remove_all_extents<int[2][3]>::type,int>
true = is_same<remove_all_extents<int[3]>::type,int>
false = has_member_function_Function
true = has_member_function_Function
false = has_member_function_read
true = has_member_function_read<vector>
true = has_static_member_variable_s_var
false = has_static_member_variable_s_invalid
aligned_storage<1,1>::type: sizeof 1, alignof 1
aligned_storage<2,1>::type: sizeof 2, alignof 1
aligned_storage<2,2>::type: sizeof 2, alignof 2
aligned_storage<2,4>::type: sizeof 4, alignof 4
aligned_storage<5,4>::type: sizeof 8, alignof 4
aligned_storage<16,8>::type: sizeof 16, alignof 8
< true = is_lvalue_reference<void_&>
< true = is_lvalue_reference<volatile float&>
aligned_storage<17,16>::type: sizeof 32, alignof 16
< false = is_rvalue_reference
< true = is_rvalue_reference<int&&>
< false = is_rvalue_reference<void*&>
< true = is_rvalue_reference<volatile float&&>
< false = is_reference
< true = is_reference<int&>
< true = is_reference<void*&>
< true = is_reference<volatile float&>
< false = is_member_object_pointer
< false = is_member_function_pointer
< true = is_member_function_pointer<void (TTA::)(void)>
< true = is_enum
< false = is_enum
< false = is_enum
< true = is_class
< false = is_class
< false = is_function
< false = is_function<void ()(int)>
< true = is_function<decltype(Print)>
< false = is_function<void (TTA::)(void)>
< true = is_arithmetic
< true = is_arithmetic
< true = is_arithmetic
< false = is_arithmetic
< false = is_arithmetic
< false = is_floating_point
< true = is_floating_point
< true = is_floating_point
< false = is_floating_point
< true = is_object
< true = is_object
< true = is_object
< true = is_object
< true = is_scalar
< true = is_scalar
< false = is_scalar
< true = is_scalar
< false = is_compound
< false = is_compound
< true = is_compound
< true = is_compound
< true = is_member_pointer<void (TTA::)(void)>
< false = is_member_pointer<void*>
< false = is_const
< true = is_const
< true = is_const
< false = is_volatile
< false = is_volatile
< true = is_volatile
< true = is_pod
< true = is_pod<int[15]>
< true = is_pod
< false = is_pod
< false = is_empty
< true = is_empty
< true = is_empty
< true = has_trivial_constructor
< false = has_trivial_constructor
< true = has_trivial_copy
< false = has_trivial_copy
< true = has_trivial_assign
< false = has_trivial_assign
< true = has_trivial_destructor
< false = has_trivial_destructor
< true = is_signed
< false = is_signed
< true = is_signed
< false = is_unsigned
< true = is_unsigned
< false = is_unsigned
< true = sizeof(char) == alignment_of
< true = sizeof(short) == alignment_of
< true = sizeof(int) == alignment_of
< true = sizeof(void_) == alignment_of<void_>
< true = sizeof(double) == alignment_of
< true = sizeof(char) == alignment_of
< true = 0 == rank
< true = 1 == rank<int[1]>
< true = 2 == rank<int[][2]>
< true = 3 == rank<int[1][2][3]>
< true = 0 == extent
< true = 1 == extent<int[1]>
< true = 1 == extent<int[1][2]>
< true = 2 == extent<int[][2],1>
< true = 1 == extent<int[1][2][3]>
< true = 2 == extent<int[1][2][3],1>
< true = 3 == extent<int[1][2][3],2>
< true = is_same<int,int>
< false = is_same<int,unsigned int>
< false = is_base_of<int,unsigned int>
< true = is_base_of<TTA,TTB>
< false = is_base_of<TTA,Polymorphic>
< true = is_convertible<int,unsigned int>
< true = is_convertible<TTA,TTA>
< false = is_convertible<TTA*,TTB*>
< true = is_convertible<TTB*,TTA*>
< true = is_same<remove_const::type,int>
< false = is_same<remove_const::type,int>
< false = is_same<remove_volatile::type,int>
< false = is_same<remove_volatile::type,int>
< false = is_same<add_const::type,volatile int>
< true = is_same<add_const::type,const volatile int>
< true = is_same<add_volatile::type,volatile int>
< true = is_same<add_volatile::type,const volatile int>
< true = is_same<add_cv::type,const volatile int>
< true = is_same<remove_pointer<int*>::type,int>
< true = is_same<remove_reference<const int&>::type,const int>
< true = is_same<remove_reference<const volatile int&>::type,const volatile int>
< true = is_same<add_pointer::type,int_>
< true = is_same<add_lvalue_reference::type,volatile int&>
< true = is_same<add_rvalue_reference::type,int&&>
< true = is_same<remove_extent::type,int>
< true = is_same<remove_extent<int[2][3]>::type,int[3]>
< true = is_same<remove_extent<int[][3]>::type,int[3]>
< true = is_same<remove_extent<int[3]>::type,int>
< true = is_same<remove_all_extents::type,int>
< true = is_same<remove_all_extents<int[2][3]>::type,int>
< true = is_same<remove_all_extents<int[3]>::type,int>
< false = has_member_function_Function
< true = has_member_function_Function
< false = has_member_function_read
< true = has_member_function_read<vector>
< true = has_static_member_variable_s_var
< false = has_static_member_variable_s_invalid
< aligned_storage<1,1>::type: sizeof 1, alignof 1
< aligned_storage<2,1>::type: sizeof 2, alignof 1
< aligned_storage<2,2>::type: sizeof 2, alignof 2
< aligned_storage<2,4>::type: sizeof 4, alignof 4
< aligned_storage<5,4>::type: sizeof 8, alignof 4
< aligned_storage<16,8>::type: sizeof 16, alignof 8
< aligned_storage<17,16>::type: sizeof 32, alignof 16
make: *_* [bvt/run] Error 1
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent