jaulib v1.4.1
Jau Support Library (C++, Java, ..)
Loading...
Searching...
No Matches
test_to_string.cpp
Go to the documentation of this file.
1/*
2 * Author: Sven Gothel <sgothel@jausoft.com>
3 * Copyright (c) 2020 Gothel Software e.K.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24#include <cassert>
25#include <cstring>
26
27#include "test_datatype01.hpp"
28
29#include <jau/basic_types.hpp>
30#include <jau/cpp_lang_util.hpp>
31#include <jau/string_util.hpp>
32#include <jau/test/catch2_ext.hpp>
33#include <jau/type_traits_queries.hpp>
34
35typedef std::vector<int> std_vec_int;
36
37typedef std_vec_int::iterator std_vec_int_iter;
38
39typedef std_vec_int::const_iterator std_vec_int_citer;
40
41typedef std_vec_int_citer::pointer std_vec_int_citer_pointer;
42
43typedef decltype( std::declval<std_vec_int_citer>().operator->() ) std_vec_int_citer_ptrop_retval;
44
45using namespace jau::int_literals;
46
47TEST_CASE( "Test 00 - to_string", "[jau][string][to_string]" ) {
48 int i1 = 1;
49 uint64_t u64_1 = 1116791496961ull;
50 void * p_v_1 = (void *)0xAFFE;
51 float float_1 = 1.65f;
52
53 Addr48Bit addr48bit_1(u64_1);
54
55 CHECK("1" == jau::to_string<int>(i1));
56 CHECK("1116791496961" == jau::to_string(u64_1));
57 CHECK("0xaffe" == jau::to_string(p_v_1));
58 CHECK("0xaffe" == jau::toHexString(0xaffe_u32));
59 {
60 // radix, default: no-width, prefix, no-separator, '0' padding
61 CHECK("0xaffe" == jau::to_string(0xaffe_u32, 16)); // hex
62 CHECK("876543210" == jau::to_string(876543210_u64, 10)); // dec
63 CHECK("077652" == jau::to_string(077652_u32, 8)); // oct
64 CHECK("0b11010101101" == jau::to_string(0b11010101101_u32, 2)); // bin
65
66 // no-prefix, radix, default: no-width, no-separator, '0' padding
67 CHECK("affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::none)); // hex
68 CHECK("876543210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::none)); // dec
69 CHECK("77652" == jau::to_string(077652_u32, 8, jau::PrefixOpt::none)); // oct
70 CHECK("11010101101" == jau::to_string(0b11010101101_u32, 2, jau::PrefixOpt::none)); // bin
71
72 // radix, width-expansion, default: prefix, no-separator, '0' padding
73 CHECK("0x00affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::prefix, 8)); // hex
74 CHECK("000876543210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::prefix, 12)); // dec
75 CHECK("0000077652" == jau::to_string(077652_u32, 8, jau::PrefixOpt::prefix, 10)); // oct
76 CHECK("0b00011010101101" == jau::to_string(0b11010101101_u32, 2, jau::PrefixOpt::prefix, 16)); // bin
77
78 // no-prefix, radix, width-expansion, default: no-separator, '0' padding
79 CHECK("0000affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::none, 8)); // hex
80 CHECK("000876543210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::none, 12)); // dec
81 CHECK("0000077652" == jau::to_string(077652_u32, 8, jau::PrefixOpt::none, 10)); // oct
82 CHECK("0000011010101101" == jau::to_string(0b11010101101_u32, 2, jau::PrefixOpt::none, 16)); // bin
83
84 // radix, separator, default: no-width, prefix, '0' padding
85 CHECK("0xaffe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::prefix, 0, '\'')); // hex
86 CHECK("0x1'affe" == jau::to_string(0x1affe_u32, 16, jau::PrefixOpt::prefix, 0, '\'')); // hex
87 CHECK("876'543'210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::prefix, 0, '\'')); // dec
88 CHECK("1'876'543'210" == jau::to_string(1876543210_u64, 10, jau::PrefixOpt::prefix, 0, '\'')); // dec
89 CHECK("04321'7652" == jau::to_string(043217652_u32, 8, jau::PrefixOpt::prefix, 0, '\'')); // oct
90 CHECK("01'4321'7652" == jau::to_string(0143217652_u32, 8, jau::PrefixOpt::prefix, 0, '\'')); // oct
91 CHECK("0b1010'1101" == jau::to_string(0b10101101_u32, 2, jau::PrefixOpt::prefix, 0, '\'')); // bin
92 CHECK("0b1'1010'1101" == jau::to_string(0b110101101_u32, 2, jau::PrefixOpt::prefix, 0, '\'')); // bin
93
94 // no-prefix, radix, separator, default: no-width, '0' padding
95 CHECK("affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::none, 0, '\'')); // hex
96 CHECK("1'affe" == jau::to_string(0x1affe_u32, 16, jau::PrefixOpt::none, 0, '\'')); // hex
97 CHECK("876'543'210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::none, 0, '\'')); // dec
98 CHECK("1'876'543'210" == jau::to_string(1876543210_u64, 10, jau::PrefixOpt::none, 0, '\'')); // dec
99 CHECK("4321'7652" == jau::to_string(043217652_u32, 8, jau::PrefixOpt::none, 0, '\'')); // oct
100 CHECK("1'4321'7652" == jau::to_string(0143217652_u32, 8, jau::PrefixOpt::none, 0, '\'')); // oct
101 CHECK("1010'1101" == jau::to_string(0b10101101_u32, 2, jau::PrefixOpt::none, 0, '\'')); // bin
102 CHECK("1'1010'1101" == jau::to_string(0b110101101_u32, 2, jau::PrefixOpt::none, 0, '\'')); // bin
103
104 // radix, width-expansion, separator, default: prefix, '0' padding
105 CHECK("0xaffe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::prefix, 6, '\'')); // hex
106 CHECK("0x'affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::prefix, 7, '\'')); // hex
107 CHECK("0x0'affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::prefix, 8, '\'')); // hex
108
109 CHECK("876'543'210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::prefix, 11, '\'')); // dec
110 CHECK("'876'543'210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::prefix, 12, '\'')); // dec
111 CHECK("0'876'543'210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::prefix, 13, '\'')); // dec
112
113 CHECK("07652" == jau::to_string(07652_u32, 8, jau::PrefixOpt::prefix, 5, '\'')); // oct
114 CHECK("0'7652" == jau::to_string(07652_u32, 8, jau::PrefixOpt::prefix, 6, '\'')); // oct
115 CHECK("00'7652" == jau::to_string(07652_u32, 8, jau::PrefixOpt::prefix, 7, '\'')); // oct
116
117 CHECK("0b1110'1010'1101" == jau::to_string(0b111010101101_u32, 2, jau::PrefixOpt::prefix, 16, '\'')); // bin
118 CHECK("0b'1110'1010'1101" == jau::to_string(0b111010101101_u32, 2, jau::PrefixOpt::prefix, 17, '\'')); // bin
119 CHECK("0b0'1110'1010'1101" == jau::to_string(0b111010101101_u32, 2, jau::PrefixOpt::prefix, 18, '\'')); // bin
120
121 // no-prefix, radix, width-expansion, separator, default: '0' padding
122 CHECK("affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::none, 4, '\'')); // hex
123 CHECK("'affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::none, 5, '\'')); // hex
124 CHECK("0'affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::none, 6, '\'')); // hex
125
126 CHECK("876'543'210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::none, 11, '\'')); // dec
127 CHECK("'876'543'210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::none, 12, '\'')); // dec
128 CHECK("0'876'543'210" == jau::to_string(876543210_u64, 10, jau::PrefixOpt::none, 13, '\'')); // dec
129
130 CHECK("7652" == jau::to_string(07652_u32, 8, jau::PrefixOpt::none, 4, '\'')); // oct
131 CHECK("'7652" == jau::to_string(07652_u32, 8, jau::PrefixOpt::none, 5, '\'')); // oct
132 CHECK("0'7652" == jau::to_string(07652_u32, 8, jau::PrefixOpt::none, 6, '\'')); // oct
133
134 CHECK("1110'1010'1101" == jau::to_string(0b111010101101_u32, 2, jau::PrefixOpt::none, 14, '\'')); // bin
135 CHECK("'1110'1010'1101" == jau::to_string(0b111010101101_u32, 2, jau::PrefixOpt::none, 15, '\'')); // bin
136 CHECK("0'1110'1010'1101" == jau::to_string(0b111010101101_u32, 2, jau::PrefixOpt::none, 16, '\'')); // bin
137
138 // no-prefix, radix, width-expansion, padding ' '
139 CHECK(" affe" == jau::to_string(0xaffe_u32, 16, jau::PrefixOpt::none, 8, '\'', ' '));
140 CHECK(" 876'543'210" == jau::to_string(876543210_u32, 10, jau::PrefixOpt::none, 15, '\'', ' '));
141 CHECK(" 110'1010'1101" == jau::to_string(0b11010101101_u32, 2, jau::PrefixOpt::none, 17, '\'', ' '));
142 CHECK(" 7'7652" == jau::to_string(077652_u32, 8, jau::PrefixOpt::none, 10, '\'', ' '));
143 }
144 CHECK("1.650000" == jau::to_string(float_1));
145
146 CHECK("01:04:05:F5:E1:01" == jau::to_string(addr48bit_1));
147
148 //
149 // Validating 'pointer std::vector::const_iterator.operator->()'
150 // and the to_string type trait logic of it.
151 //
152
153 // jau::type_cue<std_vec_int_citer>::print("std_vec_int_citer", jau::TypeTraitGroup::ALL);
154 // jau::type_cue<std_vec_int_citer_pointer>::print("std_vec_int_citer_pointer", jau::TypeTraitGroup::ALL);
155
156 // jau::type_cue<std_vec_int_citer_ptrop_retval>::print("std_vec_int_citer_ptrop_retval", jau::TypeTraitGroup::ALL);
157 printf("jau::has_member_of_pointer<std_vec_int_citer>) %d\n", jau::has_member_of_pointer<std_vec_int_citer>::value);
158
159 std_vec_int vec_int_1;
160 vec_int_1.push_back(1); vec_int_1.push_back(2); vec_int_1.push_back(3);
161 std_vec_int_citer vec_int_citer_1B = vec_int_1.cbegin();
162 uint8_t* vec_int_citer_1B_ptr = (uint8_t*)(vec_int_citer_1B.operator->());
163 std::string vec_int_citer_1B_str = jau::toHexString(vec_int_citer_1B_ptr);
164
165 std_vec_int_citer vec_int_citer_1E = vec_int_1.cend();
166 uint8_t* vec_int_citer_1E_ptr = (uint8_t*)(vec_int_citer_1E.operator->());
167 std::string vec_int_citer_1E_str = jau::toHexString(vec_int_citer_1E_ptr);
168
169 std::ptrdiff_t vec_int_citer_1E_1B_ptrdiff = vec_int_citer_1E_ptr - vec_int_citer_1B_ptr;
170 size_t vec_int_citer_1E_1B_ptr_count = vec_int_citer_1E_1B_ptrdiff / sizeof(int);
171 size_t vec_int_citer_1E_1B_itr_count = vec_int_citer_1E - vec_int_citer_1B;
172
173 printf("vec_int_citer_1E - vec_int_citer_1B = itr_count %zu, ptr_count %zu\n",
174 vec_int_citer_1E_1B_itr_count, vec_int_citer_1E_1B_ptr_count);
175 printf("vec_int_citer_1E - vec_int_citer_1B = %zu\n", vec_int_citer_1E_1B_itr_count);
176 printf("vec_int_citer_1B_ptr %s, vec_int_citer_1E1_ptr = %s\n", vec_int_citer_1B_str.c_str(), vec_int_citer_1E_str.c_str());
177
178 CHECK(vec_int_citer_1E_1B_itr_count == 3);
179 CHECK(vec_int_citer_1E_1B_itr_count == vec_int_citer_1E_1B_ptr_count);
180
181 CHECK(vec_int_citer_1E_str == jau::to_string(vec_int_citer_1E));
182}
183
184#if 0
185TEST_CASE( "Test 01 - to_string(radix)", "[jau][string][to_string(radix)]" ) {
186 REQUIRE( true == true );
187}
188
189TEST_CASE( "Test 02 - toHexString()", "[jau][string][toHexString]" ) {
190 REQUIRE( true == true );
191}
192#endif
193
194static void testToBitString(std::string_view prefix, std::string_view exp_be_s, const uint64_t &exp_be_v, size_t max_bits, bool check_value=true) {
195 std::cout << prefix << ": max_bits " << max_bits << "\n";
196 std::string has_be_s1 = jau::toBitString(exp_be_v, jau::bit_order_t::msb, jau::PrefixOpt::none, max_bits);
197 std::cout << " exp_be_s : " << exp_be_s << "\n";
198 std::cout << " has_be_s1: " << has_be_s1 << "\n";
199 REQUIRE( exp_be_s == has_be_s1 );
200
201 if( check_value ) {
202 const auto [has_be_v, len_be, ok_be] = jau::fromBitString(exp_be_s);
203 REQUIRE(true == ok_be);
204 REQUIRE(exp_be_s.size() == len_be);
205 std::string has_be_s2 = jau::toBitString(has_be_v, jau::bit_order_t::msb, jau::PrefixOpt::none, max_bits);
206 std::cout << " has_be_s2: " << has_be_s2 << "\n";
207 REQUIRE(exp_be_v == has_be_v);
208 }
209}
210static void testToBitString(std::string_view prefix, std::string_view s_be1, const uint32_t &v_be1) {
211 testToBitString(prefix, s_be1, v_be1, s_be1.size(), true);
212}
213
214TEST_CASE( "Test 03 - toBitString()", "[jau][string][toBitString]" ) {
215 {
216 testToBitString("Test 03.01.01", "000101100101110111011001", 0b101100101110111011001_u64, 0);
217 testToBitString("Test 03.01.02", "000101100101110111011001", 0b101100101110111011001_u64);
218 testToBitString("Test 03.01.03", "101110111011001", 0b101100101110111011001_u64, 15, false);
219 testToBitString("Test 03.01.04", "00000000000101100101110111011001", 0b101100101110111011001_u64);
220 testToBitString("Test 03.01.05", "000000000000101100101110111011001", 0b101100101110111011001_u64, 33);
221
222 testToBitString("Test 03.02.01", "11011001011101110110011110001101", 0b11011001011101110110011110001101_u64, 0);
223 testToBitString("Test 03.02.02", "11011001011101110110011110001101", 0b11011001011101110110011110001101_u64, 32);
224 testToBitString("Test 03.02.03", "01011001011101110110011110001101", 0b01011001011101110110011110001101_u64, 0);
225 testToBitString("Test 03.02.04", "01011001011101110110011110001101", 0b01011001011101110110011110001101_u64, 32);
226 testToBitString("Test 03.02.05", "0101110111011001", 0b0101100101110111011001_u64, 16, false);
227
228 testToBitString("Test 03.03.01", "1101100101110111011001111000110111011001011101110110011110001101",
229 0b1101100101110111011001111000110111011001011101110110011110001101_u64, 0);
230 testToBitString("Test 03.03.02", "1101100101110111011001111000110111011001011101110110011110001101",
231 0b1101100101110111011001111000110111011001011101110110011110001101_u64, 64);
232
233 testToBitString("Test 03.03.03", "0101100101110111011001111000110111011001011101110110011110001101",
234 0b0101100101110111011001111000110111011001011101110110011110001101_u64, 0);
235 testToBitString("Test 03.03.04", "0101100101110111011001111000110111011001011101110110011110001101",
236 0b0101100101110111011001111000110111011001011101110110011110001101_u64, 64);
237
238 testToBitString("Test 03.03.05", "0001100101110111011001111000110111011001011101110110011110001101",
239 0b0001100101110111011001111000110111011001011101110110011110001101_u64, 0);
240 testToBitString("Test 03.03.06", "0001100101110111011001111000110111011001011101110110011110001101",
241 0b0001100101110111011001111000110111011001011101110110011110001101_u64, 64);
242
243 testToBitString("Test 03.03.07", "1111111111101010111101101011111000000000000000000000000000000000",
244 0b1111111111101010111101101011111000000000000000000000000000000000_u64, 0);
245 testToBitString("Test 03.03.08", "1111111111101010111101101011111000000000000000000000000000000000",
246 0b1111111111101010111101101011111000000000000000000000000000000000_u64, 64);
247
248 testToBitString("Test 03.03.09", "11111110101001111110101011110110",
249 0b0000000000000000000000000000000011111110101001111110101011110110_u64, 0);
250 testToBitString("Test 03.03.10", "0000000000000000000000000000000011111110101001111110101011110110",
251 0b0000000000000000000000000000000011111110101001111110101011110110_u64, 64);
252 testToBitString("Test 03.03.11", "011111110101001111110101011110110",
253 0b0000000000000000000000000000000011111110101001111110101011110110_u64, 33);
254
255 testToBitString("Test 03.03.12", "00000000",
256 0b0000000000000000000000000000000000000000000000000000000000000000_u64, 0);
257 testToBitString("Test 03.03.13", "0000000000000000000000000000000000000000000000000000000000000000",
258 0b0000000000000000000000000000000000000000000000000000000000000000_u64, 64);
259 }
260}
basic_types.hpp
cpp_lang_util.hpp
jau::toBitString
std::string toBitString(const void *data, const nsize_t length, const bit_order_t bitOrder=bit_order_t::msb, const PrefixOpt prefix=PrefixOpt::prefix, size_t bit_len=0) noexcept
Produce a binary string representation of the given lsb-first byte values.
Definition basic_types.cpp:821
jau::fromBitString
SizeBoolPair fromBitString(std::vector< uint8_t > &out, const uint8_t bitstr[], const size_t bitstr_len, const bit_order_t bitOrder=bit_order_t::msb, const Bool checkPrefix=Bool::True) noexcept
Converts a given binary string representation into a byte vector, lsb-first.
Definition basic_types.cpp:666
jau::toHexString
std::string toHexString(const void *data, const nsize_t length, const lb_endian_t byteOrder=lb_endian_t::big, const LoUpCase capitalization=LoUpCase::lower, const PrefixOpt prefix=PrefixOpt::prefix) noexcept
Produce a hexadecimal string representation of the given lsb-first byte values.
Definition basic_types.cpp:764
jau::PrefixOpt::none
@ none
Definition string_util.hpp:101
jau::PrefixOpt::prefix
@ prefix
Definition string_util.hpp:102
jau::int_literals
Definition int_types.hpp:171
jau::bit_order_t::msb
@ msb
Identifier for most-significant-bit (msb) first.
Definition basic_types.hpp:84
jau::to_string
std::string to_string(const bit_order_t v) noexcept
Return std::string representation of the given bit_order_t.
Definition basic_types.cpp:892
string_util.hpp
jau::has_member_of_pointer
Checker for member of pointer '->' operator with convertible pointer return, no arguments.
Definition type_traits_queries.hpp:170
test_datatype01.hpp
printf
int printf(const char *format,...)
Operating Systems predefined macros.
std_vec_int
std::vector< int > std_vec_int
Definition test_to_string.cpp:35
testToBitString
static void testToBitString(std::string_view prefix, std::string_view exp_be_s, const uint64_t &exp_be_v, size_t max_bits, bool check_value=true)
Definition test_to_string.cpp:194
std_vec_int_citer_pointer
std_vec_int_citer::pointer std_vec_int_citer_pointer
Definition test_to_string.cpp:41
std_vec_int_citer_ptrop_retval
decltype(std::declval< std_vec_int_citer >().operator->()) std_vec_int_citer_ptrop_retval
Definition test_to_string.cpp:43
std_vec_int_citer
std_vec_int::const_iterator std_vec_int_citer
Definition test_to_string.cpp:39
TEST_CASE
TEST_CASE("Test 00 - to_string", "[jau][string][to_string]")
Definition test_to_string.cpp:47
std_vec_int_iter
std_vec_int::iterator std_vec_int_iter
Definition test_to_string.cpp:37
type_traits_queries.hpp