coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Build and run tests with Clang-9 on Linux (#252)

Browse Source 
* Try to build on Ubuntu-18.04 with Clang-9

* Build with pushes on clang-9 branch too

* Using CC and CXX to set clang-9

* Adding atomic lib for test build on Linux with Clang

* Partial conversion CHECK_EQUAL to CHECK for clang-9

* Replaced CHECK_EQUAL with CHECK

* Replaced CHECK_EQUAL with CHECK

* Replaced CHECK_EQUAL with CHECK

* Replaced CHECK_EQUAL with CHECK

* Replaced CHECK_EQUAL with CHECK

* Replaced CHECK_EQUAL with CHECK

* Replaced CHECK_EQUAL with CHECK

Co-authored-by: finger42 <finger42>
This commit is contained in:
finger42 2020-08-01 15:20:14 +02:00 committed by GitHub
parent eb2902de88
commit 8f1361649e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 1378 additions and 1361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
.github/workflows/main.yml vendored
View File

@ -1,7 +1,7 @@
name: CI
on:
push:
branches: [ master ]
branches: [ master, clang-9 ]
pull_request:
branches: [ master ]
@ -29,3 +29,14 @@ jobs:
with:
name: Testfile
path: test/etl_tests
build-clang-9-Linux:
runs-on: ubuntu-18.04
steps:
- uses: actions/checkout@v2
- name: Build with Clang 9
run: |
export CC=clang-9
export CXX=clang++-9
cmake -D BUILD_TESTS=ON ./
make

10
test/CMakeLists.txt
View File

@ -158,8 +158,14 @@ endif()
add_executable(etl_tests
${TEST_SOURCE_FILES}
)
#target_link_libraries(etl_tests etl UnitTest++)
target_link_libraries(etl_tests UnitTest++)
if(UNIX AND NOT APPLE)
# atomic is need on Linux with Clang
target_link_libraries(etl_tests UnitTest++ atomic)
else()
target_link_libraries(etl_tests UnitTest++)
endif()
target_include_directories(etl_tests
PUBLIC
${CMAKE_CURRENT_LIST_DIR}

158
test/test_flat_map.cpp
View File

@ -309,10 +309,10 @@ namespace
{
DataDC data;
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size()== size_t(0));
CHECK(data.empty());
CHECK_EQUAL(data.capacity(), SIZE);
CHECK_EQUAL(data.max_size(), SIZE);
CHECK(data.capacity()== SIZE);
CHECK(data.max_size()== SIZE);
CHECK(data.begin() == data.end());
}
@ -322,11 +322,11 @@ namespace
int current_count = NDC::get_instance_count();
DataNDC* pdata = new DataNDC(initial_data.begin(), initial_data.end());
CHECK_EQUAL(int(current_count + initial_data.size()), NDC::get_instance_count());
CHECK(int(current_count + initial_data.size())== NDC::get_instance_count());
IDataNDC* pidata = pdata;
delete pidata;
CHECK_EQUAL(current_count, NDC::get_instance_count());
CHECK(current_count== NDC::get_instance_count());
}
//*************************************************************************
@ -336,7 +336,7 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
CHECK_EQUAL(compare_data.size(), data.size());
CHECK(compare_data.size()== data.size());
CHECK(!data.empty());
}
@ -348,7 +348,7 @@ namespace
DataNDC data = { ElementNDC(0, N0), ElementNDC(1, N1), ElementNDC(2, N2), ElementNDC(3, N3), ElementNDC(4, N4) };
CHECK_EQUAL(compare_data.size(), data.size());
CHECK(compare_data.size()== data.size());
CHECK(!data.empty());
bool isEqual = std::equal(data.begin(),
@ -381,15 +381,15 @@ namespace
DataM data2(std::move(data1));
CHECK_EQUAL(4U, data1.size()); // Move does not clear the source.
CHECK_EQUAL(4U, data2.size());
CHECK(4U== data1.size()); // Move does not clear the source.
CHECK(4U== data2.size());
DataM::const_iterator itr = data2.begin();
CHECK_EQUAL("1", (*itr++).second.value);
CHECK_EQUAL("2", (*itr++).second.value);
CHECK_EQUAL("3", (*itr++).second.value);
CHECK_EQUAL("4", (*itr++).second.value);
CHECK("1"== (*itr++).second.value);
CHECK("2"== (*itr++).second.value);
CHECK("3"== (*itr++).second.value);
CHECK("4"== (*itr++).second.value);
}
//*************************************************************************
@ -446,8 +446,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(data);
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -456,8 +456,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(data);
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -486,16 +486,16 @@ namespace
DataDC data(compare_data.begin(), compare_data.end());
CHECK_EQUAL(compare_data[0], data[0]);
CHECK_EQUAL(compare_data[1], data[1]);
CHECK_EQUAL(compare_data[2], data[2]);
CHECK_EQUAL(compare_data[3], data[3]);
CHECK_EQUAL(compare_data[4], data[4]);
CHECK_EQUAL(compare_data[5], data[5]);
CHECK_EQUAL(compare_data[6], data[6]);
CHECK_EQUAL(compare_data[7], data[7]);
CHECK_EQUAL(compare_data[8], data[8]);
CHECK_EQUAL(compare_data[9], data[9]);
CHECK(compare_data[0] == data[0]);
CHECK(compare_data[1] == data[1]);
CHECK(compare_data[2] == data[2]);
CHECK(compare_data[3] == data[3]);
CHECK(compare_data[4] == data[4]);
CHECK(compare_data[5] == data[5]);
CHECK(compare_data[6] == data[6]);
CHECK(compare_data[7] == data[7]);
CHECK(compare_data[8] == data[8]);
CHECK(compare_data[9] == data[9]);
}
//*************************************************************************
@ -516,16 +516,16 @@ namespace
data[initial_data_dc[7].first] = initial_data_dc[7].second;
data[initial_data_dc[9].first] = initial_data_dc[9].second;
CHECK_EQUAL(compare_data[0], data[0]);
CHECK_EQUAL(compare_data[1], data[1]);
CHECK_EQUAL(compare_data[2], data[2]);
CHECK_EQUAL(compare_data[3], data[3]);
CHECK_EQUAL(compare_data[4], data[4]);
CHECK_EQUAL(compare_data[5], data[5]);
CHECK_EQUAL(compare_data[6], data[6]);
CHECK_EQUAL(compare_data[7], data[7]);
CHECK_EQUAL(compare_data[8], data[8]);
CHECK_EQUAL(compare_data[9], data[9]);
CHECK(compare_data[0] == data[0]);
CHECK(compare_data[1] == data[1]);
CHECK(compare_data[2] == data[2]);
CHECK(compare_data[3] == data[3]);
CHECK(compare_data[4] == data[4]);
CHECK(compare_data[5] == data[5]);
CHECK(compare_data[6] == data[6]);
CHECK(compare_data[7] == data[7]);
CHECK(compare_data[8] == data[8]);
CHECK(compare_data[9] == data[9]);
}
//*************************************************************************
@ -559,16 +559,16 @@ namespace
Compare_DataNDC compare_data(initial_data.begin(), initial_data.end());
DataNDC data(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.at(0), compare_data.at(0));
CHECK_EQUAL(data.at(1), compare_data.at(1));
CHECK_EQUAL(data.at(2), compare_data.at(2));
CHECK_EQUAL(data.at(3), compare_data.at(3));
CHECK_EQUAL(data.at(4), compare_data.at(4));
CHECK_EQUAL(data.at(5), compare_data.at(5));
CHECK_EQUAL(data.at(6), compare_data.at(6));
CHECK_EQUAL(data.at(7), compare_data.at(7));
CHECK_EQUAL(data.at(8), compare_data.at(8));
CHECK_EQUAL(data.at(9), compare_data.at(9));
CHECK(data.at(0) == compare_data.at(0));
CHECK(data.at(1) == compare_data.at(1));
CHECK(data.at(2) == compare_data.at(2));
CHECK(data.at(3) == compare_data.at(3));
CHECK(data.at(4) == compare_data.at(4));
CHECK(data.at(5) == compare_data.at(5));
CHECK(data.at(6) == compare_data.at(6));
CHECK(data.at(7) == compare_data.at(7));
CHECK(data.at(8) == compare_data.at(8));
CHECK(data.at(9) == compare_data.at(9));
}
//*************************************************************************
@ -588,16 +588,16 @@ namespace
const Compare_DataNDC compare_data(initial_data.begin(), initial_data.end());
const DataNDC data(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.at(0), compare_data.at(0));
CHECK_EQUAL(data.at(1), compare_data.at(1));
CHECK_EQUAL(data.at(2), compare_data.at(2));
CHECK_EQUAL(data.at(3), compare_data.at(3));
CHECK_EQUAL(data.at(4), compare_data.at(4));
CHECK_EQUAL(data.at(5), compare_data.at(5));
CHECK_EQUAL(data.at(6), compare_data.at(6));
CHECK_EQUAL(data.at(7), compare_data.at(7));
CHECK_EQUAL(data.at(8), compare_data.at(8));
CHECK_EQUAL(data.at(9), compare_data.at(9));
CHECK(data.at(0) == compare_data.at(0));
CHECK(data.at(1) == compare_data.at(1));
CHECK(data.at(2) == compare_data.at(2));
CHECK(data.at(3) == compare_data.at(3));
CHECK(data.at(4) == compare_data.at(4));
CHECK(data.at(5) == compare_data.at(5));
CHECK(data.at(6) == compare_data.at(6));
CHECK(data.at(7) == compare_data.at(7));
CHECK(data.at(8) == compare_data.at(8));
CHECK(data.at(9) == compare_data.at(9));
}
//*************************************************************************
@ -743,7 +743,7 @@ namespace
CHECK(dr.first->first == cr.first->first);
CHECK(dr.second == cr.second);
CHECK_EQUAL(compare_data.size(), data.size());
CHECK(compare_data.size() == data.size());
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -973,7 +973,7 @@ namespace
size_t count_compare = compare_data.erase(5);
size_t count = data.erase(5);
CHECK_EQUAL(count_compare, count);
CHECK(count_compare == count);
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -1039,13 +1039,13 @@ namespace
DataNDC data(compare_data.begin(), compare_data.end());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
// Do it again to check that clear() didn't screw up the internals.
data.assign(compare_data.begin(), compare_data.end());
CHECK_EQUAL(data.size(), compare_data.size());
CHECK(data.size() == compare_data.size());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
}
//*************************************************************************
@ -1053,13 +1053,13 @@ namespace
{
DataInt data(int_data.begin(), int_data.end());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
// Do it again to check that clear() didn't screw up the internals.
data.assign(int_data.begin(), int_data.end());
CHECK_EQUAL(data.size(), int_data.size());
CHECK(data.size() == int_data.size());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
}
//*************************************************************************
@ -1124,7 +1124,7 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(3);
CHECK_EQUAL(N3, it->second);
CHECK(N3 == it->second);
}
//*************************************************************************
@ -1133,10 +1133,10 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(-1);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(10);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -1145,7 +1145,7 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(3);
CHECK_EQUAL(N3, it->second);
CHECK(N3 == it->second);
}
//*************************************************************************
@ -1154,10 +1154,10 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(-1);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(10);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -1169,7 +1169,7 @@ namespace
Compare_DataNDC::iterator i_compare = compare_data.lower_bound(5);
DataNDC::iterator i_data = data.lower_bound(5);
CHECK_EQUAL(std::distance(compare_data.begin(), i_compare), std::distance(data.begin(), i_data));
CHECK(std::distance(compare_data.begin(), i_compare) == std::distance(data.begin(), i_data));
}
//*************************************************************************
@ -1181,7 +1181,7 @@ namespace
Compare_DataNDC::iterator i_compare = compare_data.upper_bound(5);
DataNDC::iterator i_data = data.upper_bound(5);
CHECK_EQUAL(std::distance(compare_data.begin(), i_compare), std::distance(data.begin(), i_data));
CHECK(std::distance(compare_data.begin(), i_compare) == std::distance(data.begin(), i_data));
}
//*************************************************************************
@ -1193,8 +1193,8 @@ namespace
ETL_OR_STD::pair<Compare_DataNDC::iterator, Compare_DataNDC::iterator> i_compare = compare_data.equal_range(5);
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data = data.equal_range(5);
CHECK_EQUAL(std::distance(compare_data.begin(), i_compare.first), std::distance(data.begin(), i_data.first));
CHECK_EQUAL(std::distance(compare_data.begin(), i_compare.second), std::distance(data.begin(), i_data.second));
CHECK(std::distance(compare_data.begin(), i_compare.first) == std::distance(data.begin(), i_data.first));
CHECK(std::distance(compare_data.begin(), i_compare.second) == std::distance(data.begin(), i_data.second));
}
//*************************************************************************
@ -1208,12 +1208,12 @@ namespace
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data;
i_data = data.equal_range(-1);
CHECK_EQUAL(data.begin(), i_data.first);
CHECK_EQUAL(data.begin(), i_data.second);
CHECK(data.begin() == i_data.first);
CHECK(data.begin() == i_data.second);
i_data = data.equal_range(99);
CHECK_EQUAL(data.end(), i_data.first);
CHECK_EQUAL(data.end(), i_data.second);
CHECK(data.end() == i_data.first);
CHECK(data.end() == i_data.second);
}
//*************************************************************************

114
test/test_flat_multimap.cpp
View File

@ -286,10 +286,10 @@ namespace
{
DataDC data;
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
CHECK(data.empty());
CHECK_EQUAL(data.capacity(), SIZE);
CHECK_EQUAL(data.max_size(), SIZE);
CHECK(data.capacity() == SIZE);
CHECK(data.max_size() == SIZE);
CHECK(data.begin() == data.end());
}
@ -299,11 +299,11 @@ namespace
int current_count = NDC::get_instance_count();
DataNDC* pdata = new DataNDC(initial_data.begin(), initial_data.end());
CHECK_EQUAL(int(current_count + initial_data.size()), NDC::get_instance_count());
CHECK(int(current_count + initial_data.size()) == NDC::get_instance_count());
IDataNDC* pidata = pdata;
delete pidata;
CHECK_EQUAL(current_count, NDC::get_instance_count());
CHECK(current_count == NDC::get_instance_count());
}
//*************************************************************************
@ -331,7 +331,7 @@ namespace
DataNDC data = { ElementNDC(0, N0), ElementNDC(1, N1), ElementNDC(2, N2), ElementNDC(3, N3), ElementNDC(4, N4) };
CHECK_EQUAL(compare_data.size(), data.size());
CHECK(compare_data.size() == data.size());
CHECK(!data.empty());
bool isEqual = std::equal(data.begin(),
@ -367,16 +367,16 @@ namespace
DataM data2(std::move(data1));
CHECK_EQUAL(5U, data1.size()); // Move does not clear the source.
CHECK_EQUAL(5U, data2.size());
CHECK(5U == data1.size()); // Move does not clear the source.
CHECK(5U == data2.size());
DataM::const_iterator itr = data2.begin();
CHECK_EQUAL("1", (*itr++).second.value);
CHECK_EQUAL("2a", (*itr++).second.value);
CHECK_EQUAL("2b", (*itr++).second.value);
CHECK_EQUAL("3", (*itr++).second.value);
CHECK_EQUAL("4", (*itr++).second.value);
CHECK("1" == (*itr++).second.value);
CHECK("2a" == (*itr++).second.value);
CHECK("2b" == (*itr++).second.value);
CHECK("3" == (*itr++).second.value);
CHECK("4" == (*itr++).second.value);
}
//*************************************************************************
@ -433,8 +433,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(data);
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -443,8 +443,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(data);
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -545,7 +545,7 @@ namespace
data.insert(ETL_OR_STD::make_pair(2, N2));
compare_data.insert(ETL_OR_STD::make_pair(2, N2));
CHECK_EQUAL(compare_data.size(), data.size());
CHECK(compare_data.size() == data.size());
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -619,7 +619,7 @@ namespace
data.emplace(ETL_OR_STD::make_pair(2, D1("2")));
compare.emplace(ETL_OR_STD::make_pair(2, D1("2")));
CHECK_EQUAL(compare.size(), data.size());
CHECK(compare.size() == data.size());
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -653,7 +653,7 @@ namespace
data.emplace(ETL_OR_STD::make_pair(2, D2("2", "3")));
compare.emplace(ETL_OR_STD::make_pair(2, D2("2", "3")));
CHECK_EQUAL(compare.size(), data.size());
CHECK(compare.size() == data.size());
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -687,7 +687,7 @@ namespace
data.emplace(ETL_OR_STD::make_pair(2, D3("2", "3", "4")));
compare.emplace(ETL_OR_STD::make_pair(2, D3("2", "3", "4")));
CHECK_EQUAL(compare.size(), data.size());
CHECK(compare.size() == data.size());
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -721,7 +721,7 @@ namespace
data.emplace(ETL_OR_STD::make_pair(2, D4("2", "3", "4", "5")));
compare.emplace(ETL_OR_STD::make_pair(2, D4("2", "3", "4", "5")));
CHECK_EQUAL(compare.size(), data.size());
CHECK(compare.size() == data.size());
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -739,7 +739,7 @@ namespace
size_t count_compare = compare_data.erase(5);
size_t count = data.erase(5);
CHECK_EQUAL(count_compare, count);
CHECK(count_compare == count);
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -805,13 +805,13 @@ namespace
DataNDC data(compare_data.begin(), compare_data.end());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
// Do it again to check that clear() didn't screw up the internals.
data.assign(compare_data.begin(), compare_data.end());
CHECK_EQUAL(data.size(), compare_data.size());
CHECK(data.size() == compare_data.size());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
}
//*************************************************************************
@ -820,13 +820,13 @@ namespace
DataInt data(int_data.begin(), int_data.end());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
// Do it again to check that clear() didn't screw up the internals.
data.assign(int_data.begin(), int_data.end());
CHECK_EQUAL(data.size(), int_data.size());
CHECK(data.size() == int_data.size());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
}
//*************************************************************************
@ -891,10 +891,10 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(3);
CHECK_EQUAL(N3, it->second);
CHECK(N3 == it->second);
it = data.find(19);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -903,10 +903,10 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(-1);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(10);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -915,10 +915,10 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(3);
CHECK_EQUAL(N3, it->second);
CHECK(N3 == it->second);
it = data.find(19);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -927,10 +927,10 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(-1);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(10);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -942,7 +942,7 @@ namespace
Compare_DataNDC::iterator i_compare = compare_data.lower_bound(5);
DataNDC::iterator i_data = data.lower_bound(5);
CHECK_EQUAL(std::distance(compare_data.begin(), i_compare), std::distance(data.begin(), i_data));
CHECK(std::distance(compare_data.begin(), i_compare) == std::distance(data.begin(), i_data));
}
//*************************************************************************
@ -954,7 +954,7 @@ namespace
Compare_DataNDC::iterator i_compare = compare_data.upper_bound(5);
DataNDC::iterator i_data = data.upper_bound(5);
CHECK_EQUAL(std::distance(compare_data.begin(), i_compare), std::distance(data.begin(), i_data));
CHECK(std::distance(compare_data.begin(), i_compare) == std::distance(data.begin(), i_data));
}
//*************************************************************************
@ -966,8 +966,8 @@ namespace
ETL_OR_STD::pair<Compare_DataNDC::iterator, Compare_DataNDC::iterator> i_compare = compare_data.equal_range(5);
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data = data.equal_range(5);
CHECK_EQUAL(std::distance(compare_data.begin(), i_compare.first), std::distance(data.begin(), i_data.first));
CHECK_EQUAL(std::distance(compare_data.begin(), i_compare.second), std::distance(data.begin(), i_data.second));
CHECK(std::distance(compare_data.begin(), i_compare.first) == std::distance(data.begin(), i_data.first));
CHECK(std::distance(compare_data.begin(), i_compare.second) == std::distance(data.begin(), i_data.second));
}
//*************************************************************************
@ -978,12 +978,12 @@ namespace
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data;
i_data = data.equal_range(-1);
CHECK_EQUAL(data.begin(), i_data.first);
CHECK_EQUAL(data.begin(), i_data.second);
CHECK(data.begin() == i_data.first);
CHECK(data.begin() == i_data.second);
i_data = data.equal_range(99);
CHECK_EQUAL(data.end(), i_data.first);
CHECK_EQUAL(data.end(), i_data.second);
CHECK(data.end() == i_data.first);
CHECK(data.end() == i_data.second);
}
//*************************************************************************
@ -1023,27 +1023,27 @@ namespace
compare_range = compare_data.equal_range(0);
test_range = data.equal_range(0);
CHECK_EQUAL(std::distance(compare_range.first, compare_range.second), std::distance(test_range.first, test_range.second));
CHECK(std::distance(compare_range.first, compare_range.second) == std::distance(test_range.first, test_range.second));
compare_range = compare_data.equal_range(1);
test_range = data.equal_range(1);
CHECK_EQUAL(std::distance(compare_range.first, compare_range.second), std::distance(test_range.first, test_range.second));
CHECK(std::distance(compare_range.first, compare_range.second) == std::distance(test_range.first, test_range.second));
compare_range = compare_data.equal_range(2);
test_range = data.equal_range(2);
CHECK_EQUAL(std::distance(compare_range.first, compare_range.second), std::distance(test_range.first, test_range.second));
CHECK(std::distance(compare_range.first, compare_range.second) == std::distance(test_range.first, test_range.second));
compare_range = compare_data.equal_range(3);
test_range = data.equal_range(3);
CHECK_EQUAL(std::distance(compare_range.first, compare_range.second), std::distance(test_range.first, test_range.second));
CHECK(std::distance(compare_range.first, compare_range.second) == std::distance(test_range.first, test_range.second));
compare_range = compare_data.equal_range(4);
test_range = data.equal_range(4);
CHECK_EQUAL(std::distance(compare_range.first, compare_range.second), std::distance(test_range.first, test_range.second));
CHECK(std::distance(compare_range.first, compare_range.second) == std::distance(test_range.first, test_range.second));
compare_range = compare_data.equal_range(5);
test_range = data.equal_range(5);
CHECK_EQUAL(std::distance(compare_range.first, compare_range.second), std::distance(test_range.first, test_range.second));
CHECK(std::distance(compare_range.first, compare_range.second) == std::distance(test_range.first, test_range.second));
}
//*************************************************************************
@ -1052,12 +1052,12 @@ namespace
Compare_DataNDC compare_data(multi_data.begin(), multi_data.end());
DataNDC data(multi_data.begin(), multi_data.end());
CHECK_EQUAL(compare_data.count(0), data.count(0));
CHECK_EQUAL(compare_data.count(1), data.count(1));
CHECK_EQUAL(compare_data.count(2), data.count(2));
CHECK_EQUAL(compare_data.count(3), data.count(3));
CHECK_EQUAL(compare_data.count(4), data.count(4));
CHECK_EQUAL(compare_data.count(5), data.count(5));
CHECK(compare_data.count(0) == data.count(0));
CHECK(compare_data.count(1) == data.count(1));
CHECK(compare_data.count(2) == data.count(2));
CHECK(compare_data.count(3) == data.count(3));
CHECK(compare_data.count(4) == data.count(4));
CHECK(compare_data.count(5) == data.count(5));
}
};
}

28
test/test_flat_multiset.cpp
View File

@ -398,8 +398,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(data);
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -408,8 +408,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(data);
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -859,7 +859,7 @@ namespace
CHECK_EQUAL(N3, *it);
it = data.find(N19);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -868,10 +868,10 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(NX);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(NY);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -883,7 +883,7 @@ namespace
CHECK_EQUAL(N3, *it);
it = data.find(N19);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -892,10 +892,10 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(NX);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(NY);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -943,12 +943,12 @@ namespace
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data;
i_data = data.equal_range(NX);
CHECK_EQUAL(data.begin(), i_data.first);
CHECK_EQUAL(data.begin(), i_data.second);
CHECK(data.begin() == i_data.first);
CHECK(data.begin() == i_data.second);
i_data = data.equal_range(NY);
CHECK_EQUAL(data.end(), i_data.first);
CHECK_EQUAL(data.end(), i_data.second);
CHECK(data.end() == i_data.first);
CHECK(data.end() == i_data.second);
}
//*************************************************************************

24
test/test_flat_set.cpp
View File

@ -406,8 +406,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(data);
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -416,8 +416,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(data);
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -844,10 +844,10 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(NX);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(NY);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -865,10 +865,10 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(NX);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(NY);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -916,12 +916,12 @@ namespace
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data;
i_data = data.equal_range(NX);
CHECK_EQUAL(data.begin(), i_data.first);
CHECK_EQUAL(data.begin(), i_data.second);
CHECK(data.begin() == i_data.first);
CHECK(data.begin() == i_data.second);
i_data = data.equal_range(NY);
CHECK_EQUAL(data.end(), i_data.first);
CHECK_EQUAL(data.end(), i_data.second);
CHECK(data.end() == i_data.first);
CHECK(data.end() == i_data.second);
}
//*************************************************************************

226
test/test_map.cpp
View File

@ -218,10 +218,10 @@ namespace
{
Data data;
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
CHECK(data.empty());
CHECK_EQUAL(data.capacity(), MAX_SIZE);
CHECK_EQUAL(data.max_size(), MAX_SIZE);
CHECK(data.capacity() == MAX_SIZE);
CHECK(data.max_size() == MAX_SIZE);
CHECK(data.begin() == data.end());
}
@ -232,7 +232,7 @@ namespace
Data data1(compare_data.begin(), compare_data.end());
Data data2(data1);
CHECK_EQUAL(initial_data.size(), data1.size());
CHECK(initial_data.size() == data1.size());
CHECK(data1.size() == data2.size());
bool isEqual = false;
@ -266,10 +266,10 @@ namespace
CHECK(!data1.empty()); // Move does not clear the source.
CHECK_EQUAL(1, data2.at("1").value);
CHECK_EQUAL(2, data2.at("2").value);
CHECK_EQUAL(3, data2.at("3").value);
CHECK_EQUAL(4, data2.at("4").value);
CHECK(1 == data2.at("1").value);
CHECK(2 == data2.at("2").value);
CHECK(3 == data2.at("3").value);
CHECK(4 == data2.at("4").value);
}
//*************************************************************************
@ -305,7 +305,7 @@ namespace
Data data = { Data::value_type(std::string("0"), 0), Data::value_type(std::string("1"), 1),
Data::value_type(std::string("2"), 2), Data::value_type(std::string("3"), 3) };
CHECK_EQUAL(compare_data.size(), data.size());
CHECK(compare_data.size() == data.size());
CHECK(!data.empty());
bool isEqual = Check_Equal(data.begin(),
@ -381,10 +381,10 @@ namespace
data2 = std::move(data1);
CHECK_EQUAL(1, data2.at("1").value);
CHECK_EQUAL(2, data2.at("2").value);
CHECK_EQUAL(3, data2.at("3").value);
CHECK_EQUAL(4, data2.at("4").value);
CHECK(1 == data2.at("1").value);
CHECK(2 == data2.at("2").value);
CHECK(3 == data2.at("3").value);
CHECK(4 == data2.at("4").value);
}
//*************************************************************************
@ -393,8 +393,8 @@ namespace
Data data(initial_data.begin(), initial_data.end());
const Data constData(data);
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -403,8 +403,8 @@ namespace
Data data(initial_data.begin(), initial_data.end());
const Data constData(data);
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -433,16 +433,16 @@ namespace
Data data(compare_data.begin(), compare_data.end());
CHECK_EQUAL(data["0"], compare_data["0"]);
CHECK_EQUAL(data["1"], compare_data["1"]);
CHECK_EQUAL(data["2"], compare_data["2"]);
CHECK_EQUAL(data["3"], compare_data["3"]);
CHECK_EQUAL(data["4"], compare_data["4"]);
CHECK_EQUAL(data["5"], compare_data["5"]);
CHECK_EQUAL(data["6"], compare_data["6"]);
CHECK_EQUAL(data["7"], compare_data["7"]);
CHECK_EQUAL(data["8"], compare_data["8"]);
CHECK_EQUAL(data["9"], compare_data["9"]);
CHECK(data["0"] == compare_data["0"]);
CHECK(data["1"] == compare_data["1"]);
CHECK(data["2"] == compare_data["2"]);
CHECK(data["3"] == compare_data["3"]);
CHECK(data["4"] == compare_data["4"]);
CHECK(data["5"] == compare_data["5"]);
CHECK(data["6"] == compare_data["6"]);
CHECK(data["7"] == compare_data["7"]);
CHECK(data["8"] == compare_data["8"]);
CHECK(data["9"] == compare_data["9"]);
}
//*************************************************************************
@ -457,7 +457,7 @@ namespace
data["0"] = 1;
compare_data["0"] = 1;
CHECK_EQUAL(data["0"], compare_data["0"]);
CHECK(data["0"] == compare_data["0"]);
}
//*************************************************************************
@ -466,16 +466,16 @@ namespace
Compare_Data compare_data(initial_data.begin(), initial_data.end());
Data data(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.at("0"), compare_data.at("0"));
CHECK_EQUAL(data.at("1"), compare_data.at("1"));
CHECK_EQUAL(data.at("2"), compare_data.at("2"));
CHECK_EQUAL(data.at("3"), compare_data.at("3"));
CHECK_EQUAL(data.at("4"), compare_data.at("4"));
CHECK_EQUAL(data.at("5"), compare_data.at("5"));
CHECK_EQUAL(data.at("6"), compare_data.at("6"));
CHECK_EQUAL(data.at("7"), compare_data.at("7"));
CHECK_EQUAL(data.at("8"), compare_data.at("8"));
CHECK_EQUAL(data.at("9"), compare_data.at("9"));
CHECK(data.at("0") == compare_data.at("0"));
CHECK(data.at("1") == compare_data.at("1"));
CHECK(data.at("2") == compare_data.at("2"));
CHECK(data.at("3") == compare_data.at("3"));
CHECK(data.at("4") == compare_data.at("4"));
CHECK(data.at("5") == compare_data.at("5"));
CHECK(data.at("6") == compare_data.at("6"));
CHECK(data.at("7") == compare_data.at("7"));
CHECK(data.at("8") == compare_data.at("8"));
CHECK(data.at("9") == compare_data.at("9"));
}
//*************************************************************************
@ -495,16 +495,16 @@ namespace
const Compare_Data compare_data(initial_data.begin(), initial_data.end());
const Data data(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.at("0"), compare_data.at("0"));
CHECK_EQUAL(data.at("1"), compare_data.at("1"));
CHECK_EQUAL(data.at("2"), compare_data.at("2"));
CHECK_EQUAL(data.at("3"), compare_data.at("3"));
CHECK_EQUAL(data.at("4"), compare_data.at("4"));
CHECK_EQUAL(data.at("5"), compare_data.at("5"));
CHECK_EQUAL(data.at("6"), compare_data.at("6"));
CHECK_EQUAL(data.at("7"), compare_data.at("7"));
CHECK_EQUAL(data.at("8"), compare_data.at("8"));
CHECK_EQUAL(data.at("9"), compare_data.at("9"));
CHECK(data.at("0") == compare_data.at("0"));
CHECK(data.at("1") == compare_data.at("1"));
CHECK(data.at("2") == compare_data.at("2"));
CHECK(data.at("3") == compare_data.at("3"));
CHECK(data.at("4") == compare_data.at("4"));
CHECK(data.at("5") == compare_data.at("5"));
CHECK(data.at("6") == compare_data.at("6"));
CHECK(data.at("7") == compare_data.at("7"));
CHECK(data.at("8") == compare_data.at("8"));
CHECK(data.at("9") == compare_data.at("9"));
}
//*************************************************************************
@ -543,16 +543,16 @@ namespace
compare_data.insert(ETL_OR_STD::make_pair(std::string("0"), 0));
// Check that both return successful return results
CHECK_EQUAL(data_result.first->first, compare_result.first->first);
CHECK_EQUAL(data_result.second, compare_result.second);
CHECK(data_result.first->first == compare_result.first->first);
CHECK(data_result.second == compare_result.second);
// Try adding a duplicate (should return iterator pointing to duplicate)
data_result = data.insert(Data::value_type(std::string("0"), 0));
compare_result = compare_data.insert(ETL_OR_STD::make_pair(std::string("0"), 0));
// Check that both return successful return results
CHECK_EQUAL(data_result.first->first, compare_result.first->first);
CHECK_EQUAL(data_result.second, compare_result.second);
CHECK(data_result.first->first == compare_result.first->first);
CHECK(data_result.second == compare_result.second);
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
@ -619,10 +619,10 @@ namespace
CHECK(!bool(d2));
CHECK(!bool(d3));
CHECK_EQUAL(1, data.at("1").value);
CHECK_EQUAL(2, data.at("2").value);
CHECK_EQUAL(3, data.at("3").value);
CHECK_EQUAL(4, data.at("4").value);
CHECK(1 == data.at("1").value);
CHECK(2 == data.at("2").value);
CHECK(3 == data.at("3").value);
CHECK(4 == data.at("4").value);
}
//*************************************************************************
@ -662,8 +662,8 @@ namespace
compare_data.insert(ETL_OR_STD::make_pair(std::string("2"), 2));
// Check that both return successful return results
CHECK_EQUAL(data_result.first->first, compare_result.first->first);
CHECK_EQUAL(data_result.second, compare_result.second);
CHECK(data_result.first->first == compare_result.first->first);
CHECK(data_result.second == compare_result.second);
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
@ -693,8 +693,8 @@ namespace
compare_data.insert(ETL_OR_STD::make_pair(std::string("2"), 2));
// Check that both return successful return results
CHECK_EQUAL(data_result.first->first, compare_result.first->first);
CHECK_EQUAL(data_result.second, compare_result.second);
CHECK(data_result.first->first == compare_result.first->first);
CHECK(data_result.second == compare_result.second);
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
@ -776,12 +776,12 @@ namespace
Compare_Data::iterator compare_data_lb = compare_data.lower_bound("2");
// Check that both return the same return results
CHECK_EQUAL(data_lb->first, compare_data_lb->first);
CHECK_EQUAL(data_lb->second, compare_data_lb->second);
CHECK_EQUAL(data_result.first->first, compare_result.first->first);
CHECK_EQUAL(data_result.first->second, compare_result.first->second);
CHECK_EQUAL(data_result.second->first, compare_result.second->first);
CHECK_EQUAL(data_result.second->second, compare_result.second->second);
CHECK(data_lb->first == compare_data_lb->first);
CHECK(data_lb->second == compare_data_lb->second);
CHECK(data_result.first->first == compare_result.first->first);
CHECK(data_result.first->second == compare_result.first->second);
CHECK(data_result.second->first == compare_result.second->first);
CHECK(data_result.second->second == compare_result.second->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -802,10 +802,10 @@ namespace
compare_data.equal_range("2");
// Check that both return the same return results
CHECK_EQUAL(data_result.first->first, compare_result.first->first);
CHECK_EQUAL(data_result.first->second, compare_result.first->second);
CHECK_EQUAL(data_result.second->first, compare_result.second->first);
CHECK_EQUAL(data_result.second->second, compare_result.second->second);
CHECK(data_result.first->first == compare_result.first->first);
CHECK(data_result.first->second == compare_result.first->second);
CHECK(data_result.second->first == compare_result.second->first);
CHECK(data_result.second->second == compare_result.second->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -867,7 +867,7 @@ namespace
Compare_Data::const_iterator i_compare1 = compare_data.erase(i_compare);
Data::const_iterator i_data1 = data.erase(i_data);
CHECK_EQUAL(i_compare1->second, i_data1->second);
CHECK(i_compare1->second == i_data1->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -938,7 +938,7 @@ namespace
Data data(compare_data.begin(), compare_data.end());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
}
//*************************************************************************
@ -946,9 +946,9 @@ namespace
{
const Data data(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.count("3"), size_t(1));
CHECK(data.count("3") == size_t(1));
CHECK_EQUAL(data.count("A"), size_t(0));
CHECK(data.count("A") == size_t(0));
}
//*************************************************************************
@ -1013,13 +1013,13 @@ namespace
Data data(initial_data.begin(), initial_data.end());
Data::iterator it = data.find("3");
CHECK_EQUAL(3, it->second);
CHECK(3 == it->second);
it = data.find("A");
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find("!");
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -1028,13 +1028,13 @@ namespace
const Data data(initial_data.begin(), initial_data.end());
Data::const_iterator it = data.find("3");
CHECK_EQUAL(3, it->second);
CHECK(3 == it->second);
it = data.find("A");
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find("!");
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -1071,28 +1071,28 @@ namespace
Compare_Data::iterator i_compare = compare_data.lower_bound("8");
Data::iterator i_data = data.lower_bound("8");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(".");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(".");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound("A");
i_data = data.lower_bound("A");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#else
i_compare = compare_data.lower_bound(".");
i_data = data.lower_bound(".");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
i_compare = compare_data.lower_bound("A");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound("A");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
#endif
}
@ -1104,28 +1104,28 @@ namespace
Compare_Data::const_iterator i_compare = compare_data.lower_bound("4");
Data::const_iterator i_data = data.lower_bound("4");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(".");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(".");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound("A");
i_data = data.lower_bound("A");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#else
i_compare = compare_data.lower_bound(".");
i_data = data.lower_bound(".");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
i_compare = compare_data.lower_bound("A");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound("A");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
#endif
}
@ -1137,28 +1137,28 @@ namespace
Compare_Data::iterator i_compare = compare_data.upper_bound("2");
Data::iterator i_data = data.upper_bound("2");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(".");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(".");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound("A");
i_data = data.upper_bound("A");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#else
i_compare = compare_data.upper_bound(".");
i_data = data.upper_bound(".");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
i_compare = compare_data.upper_bound("A");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound("A");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
#endif
}
@ -1170,28 +1170,28 @@ namespace
Compare_Data::const_iterator i_compare = compare_data.upper_bound("7");
Data::const_iterator i_data = data.upper_bound("7");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(".");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(".");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound("A");
i_data = data.upper_bound("A");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#else
i_compare = compare_data.upper_bound(".");
i_data = data.upper_bound(".");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
i_compare = compare_data.upper_bound("A");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound("A");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
#endif
}
@ -1246,14 +1246,14 @@ namespace
std::vector<ETL_OR_STD::pair<std::string, int> > compare_data_elements(compare.begin(), compare.end());
CHECK(data_elements == compare_data_elements);
CHECK_EQUAL(data_elements.size(), MAX_SIZE);
CHECK(data_elements.size() == MAX_SIZE);
for(std::vector<ETL_OR_STD::pair<std::string, int> >::iterator it = tab.begin() ; it != tab.end() ; ++it)
{
std::string i = it->first;
//lower_bound
CHECK_EQUAL(compare.lower_bound(i) == compare.end(), data.lower_bound(i) == data.end());
CHECK((compare.lower_bound(i) == compare.end()) == (data.lower_bound(i) == data.end()));
//if both end, or none
if((compare.lower_bound(i) == compare.end()) == (data.lower_bound(i) == data.end()))
{
@ -1266,12 +1266,12 @@ namespace
ETL_OR_STD::pair<Compare_Data::const_iterator, Compare_Data::const_iterator> stlret = compare.equal_range(i);
ETL_OR_STD::pair<Data::const_iterator, Data::const_iterator> etlret = data.equal_range(i);
CHECK_EQUAL(stlret.first == compare.end(), etlret.first == data.end());
CHECK((stlret.first == compare.end()) == (etlret.first == data.end()));
if((stlret.first != compare.end()) && (etlret.first != data.end()))
{
CHECK((*stlret.first) == (*etlret.first));
}
CHECK_EQUAL(stlret.second == compare.end(), etlret.second == data.end());
CHECK((stlret.second == compare.end()) == (etlret.second == data.end()));
if((stlret.second != compare.end()) && (etlret.second != data.end()))
{
CHECK((*stlret.second) == (*etlret.second));
@ -1279,7 +1279,7 @@ namespace
}
//upper_bound
CHECK_EQUAL(compare.upper_bound(i) == compare.end(), data.upper_bound(i) == data.end());
CHECK((compare.upper_bound(i) == compare.end()) == (data.upper_bound(i) == data.end()));
//if both end, or none
if((compare.upper_bound(i) == compare.end()) == (data.upper_bound(i) == data.end()))
{

224
test/test_multimap.cpp
View File

@ -220,10 +220,10 @@ namespace
{
Data data;
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
CHECK(data.empty());
CHECK_EQUAL(data.capacity(), MAX_SIZE);
CHECK_EQUAL(data.max_size(), MAX_SIZE);
CHECK(data.capacity() == MAX_SIZE);
CHECK(data.max_size() == MAX_SIZE);
CHECK(data.begin() == data.end());
}
@ -234,7 +234,7 @@ namespace
Data data1(compare_data.begin(), compare_data.end());
Data data2(data1);
CHECK_EQUAL(initial_data.size(), data1.size());
CHECK(initial_data.size() == data1.size());
CHECK(data1.size() == data2.size());
bool isEqual = false;
@ -268,10 +268,10 @@ namespace
CHECK(!data1.empty()); // Move does not clear the source.
CHECK_EQUAL(1, data2.find("1")->second.value);
CHECK_EQUAL(2, data2.find("2")->second.value);
CHECK_EQUAL(3, data2.find("3")->second.value);
CHECK_EQUAL(4, data2.find("4")->second.value);
CHECK(1 == data2.find("1")->second.value);
CHECK(2 == data2.find("2")->second.value);
CHECK(3 == data2.find("3")->second.value);
CHECK(4 == data2.find("4")->second.value);
}
//*************************************************************************
@ -304,7 +304,7 @@ namespace
Data data = { Data::value_type(std::string("0"), 0), Data::value_type(std::string("1"), 1),
Data::value_type(std::string("2"), 2), Data::value_type(std::string("3"), 3) };
CHECK_EQUAL(compare_data.size(), data.size());
CHECK(compare_data.size() == data.size());
CHECK(!data.empty());
bool isEqual = Check_Equal(data.begin(),
@ -380,10 +380,10 @@ namespace
data2 = std::move(data1);
CHECK_EQUAL(1, data2.find("1")->second.value);
CHECK_EQUAL(2, data2.find("2")->second.value);
CHECK_EQUAL(3, data2.find("3")->second.value);
CHECK_EQUAL(4, data2.find("4")->second.value);
CHECK(1 == data2.find("1")->second.value);
CHECK(2 == data2.find("2")->second.value);
CHECK(3 == data2.find("3")->second.value);
CHECK(4 == data2.find("4")->second.value);
}
//*************************************************************************
@ -392,8 +392,8 @@ namespace
Data data(initial_data.begin(), initial_data.end());
const Data constData(data);
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -402,8 +402,8 @@ namespace
Data data(initial_data.begin(), initial_data.end());
const Data constData(data);
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -453,52 +453,52 @@ namespace
compare_data.insert(ETL_OR_STD::make_pair(std::string("2"), 1));
// Check that both return successful return results
CHECK_EQUAL(compare_result->first, data_result->first);
CHECK_EQUAL(compare_result->second, data_result->second);
CHECK(compare_result->first == data_result->first);
CHECK(compare_result->second == data_result->second);
data_result = data.insert(Data::value_type(std::string("1"), 1));
compare_result = compare_data.insert(ETL_OR_STD::make_pair(std::string("1"), 1));
// Check that both return successful return results
CHECK_EQUAL(compare_result->first, data_result->first);
CHECK_EQUAL(compare_result->second, data_result->second);
CHECK(compare_result->first == data_result->first);
CHECK(compare_result->second == data_result->second);
data_result = data.insert(Data::value_type(std::string("2"), 2));
compare_result = compare_data.insert(ETL_OR_STD::make_pair(std::string("2"), 2));
// Check that both return successful return results
CHECK_EQUAL(compare_result->first, data_result->first);
CHECK_EQUAL(compare_result->second, data_result->second);
CHECK(compare_result->first == data_result->first);
CHECK(compare_result->second == data_result->second);
data_result = data.insert(Data::value_type(std::string("3"), 3));
compare_result = compare_data.insert(ETL_OR_STD::make_pair(std::string("3"), 3));
// Check that both return successful return results
CHECK_EQUAL(compare_result->first, data_result->first);
CHECK_EQUAL(compare_result->second, data_result->second);
CHECK(compare_result->first == data_result->first);
CHECK(compare_result->second == data_result->second);
// Adding this next 2 will trigger a 3 node rotate RL on insert
data_result = data.insert(Data::value_type(std::string("2"), 3));
compare_result = compare_data.insert(ETL_OR_STD::make_pair(std::string("2"), 3));
// Check that both return successful return results
CHECK_EQUAL(compare_result->first, data_result->first);
CHECK_EQUAL(compare_result->second, data_result->second);
CHECK(compare_result->first == data_result->first);
CHECK(compare_result->second == data_result->second);
// Adding this next 4 will trigger a 2 node rotate left on insert
data_result = data.insert(Data::value_type(std::string("4"), 4));
compare_result = compare_data.insert(ETL_OR_STD::make_pair(std::string("4"), 4));
// Check that both return successful return results
CHECK_EQUAL(compare_result->first, data_result->first);
CHECK_EQUAL(compare_result->second, data_result->second);
CHECK(compare_result->first == data_result->first);
CHECK(compare_result->second == data_result->second);
data_result = data.insert(Data::value_type(std::string("0"), 0));
compare_result = compare_data.insert(ETL_OR_STD::make_pair(std::string("0"), 0));
// Check that both return successful return results
CHECK_EQUAL(compare_result->first, data_result->first);
CHECK_EQUAL(compare_result->second, data_result->second);
CHECK(compare_result->first == data_result->first);
CHECK(compare_result->second == data_result->second);
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
@ -519,8 +519,8 @@ namespace
compare_data.insert(ETL_OR_STD::make_pair(std::string("0"), 0));
// Check that both return successful return results
CHECK_EQUAL(compare_result->first, data_result->first);
CHECK_EQUAL(compare_result->second, data_result->second);
CHECK(compare_result->first == data_result->first);
CHECK(compare_result->second == data_result->second);
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
@ -550,8 +550,8 @@ namespace
compare_data.insert(ETL_OR_STD::make_pair(std::string("2"), 0));
// Check that both return successful return results
CHECK_EQUAL(compare_result->first, data_result->first);
CHECK_EQUAL(compare_result->second, data_result->second);
CHECK(compare_result->first == data_result->first);
CHECK(compare_result->second == data_result->second);
// Check that elements in map are the same
bool isEqual = Check_Equal(data.begin(),
@ -632,10 +632,10 @@ namespace
compare_data.equal_range("1");
// Check that both return the same return results
CHECK_EQUAL(compare_result.first->first, data_result.first->first);
CHECK_EQUAL(compare_result.first->second, data_result.first->second);
CHECK_EQUAL(compare_result.second->first, data_result.second->first);
CHECK_EQUAL(compare_result.second->second, data_result.second->second);
CHECK(compare_result.first->first == data_result.first->first);
CHECK(compare_result.first->second == data_result.first->second);
CHECK(compare_result.second->first == data_result.second->first);
CHECK(compare_result.second->second == data_result.second->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -657,10 +657,10 @@ namespace
compare_data.equal_range("2");
// Check that both return the same return results
CHECK_EQUAL(compare_result.first->first, data_result.first->first);
CHECK_EQUAL(compare_result.first->second, data_result.first->second);
CHECK_EQUAL(compare_result.second->first, data_result.second->first);
CHECK_EQUAL(compare_result.second->second, data_result.second->second);
CHECK(compare_result.first->first == data_result.first->first);
CHECK(compare_result.first->second == data_result.first->second);
CHECK(compare_result.second->first == data_result.second->first);
CHECK(compare_result.second->second == data_result.second->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -679,21 +679,21 @@ namespace
size_t data_count = data.erase("2");
// Check that both return the same return results
CHECK_EQUAL(compare_count, data_count);
CHECK(compare_count == data_count);
// Erase another value
compare_count = compare_data.erase("1");
data_count = data.erase("1");
// Check that both return the same return results
CHECK_EQUAL(compare_count, data_count);
CHECK(compare_count == data_count);
// Erase another value
compare_count = compare_data.erase("3");
data_count = data.erase("3");
// Check that both return the same return results
CHECK_EQUAL(compare_count, data_count);
CHECK(compare_count == data_count);
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -736,7 +736,7 @@ namespace
Compare_Data::const_iterator i_compare1 = compare_data.erase(i_compare);
Data::const_iterator i_data1 = data.erase(i_data);
CHECK_EQUAL(i_compare1->second, i_data1->second);
CHECK(i_compare1->second == i_data1->second);
bool isEqual = Check_Equal(data.begin(),
data.end(),
@ -795,7 +795,7 @@ namespace
Data data(compare_data.begin(), compare_data.end());
data.clear();
CHECK_EQUAL(data.size(), size_t(0));
CHECK(data.size() == size_t(0));
}
//*************************************************************************
@ -804,13 +804,13 @@ namespace
const Data data(initial_data.begin(), initial_data.end());
const Compare_Data compare_data(initial_data.begin(), initial_data.end());
CHECK_EQUAL(compare_data.count("."), data.count("."));
CHECK_EQUAL(compare_data.count("0"), data.count("0"));
CHECK_EQUAL(compare_data.count("1"), data.count("1"));
CHECK_EQUAL(compare_data.count("2"), data.count("2"));
CHECK_EQUAL(compare_data.count("3"), data.count("3"));
CHECK_EQUAL(compare_data.count("4"), data.count("4"));
CHECK_EQUAL(compare_data.count("A"), data.count("A"));
CHECK(compare_data.count(".") == data.count("."));
CHECK(compare_data.count("0") == data.count("0"));
CHECK(compare_data.count("1") == data.count("1"));
CHECK(compare_data.count("2") == data.count("2"));
CHECK(compare_data.count("3") == data.count("3"));
CHECK(compare_data.count("4") == data.count("4"));
CHECK(compare_data.count("A") == data.count("A"));
}
//*************************************************************************
@ -879,43 +879,43 @@ namespace
Compare_Data::iterator i_compare = compare_data.find("0");
// Check that both return successful return results
CHECK_EQUAL(i_compare->first, i_data->first);
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->first == i_data->first);
CHECK(i_compare->second == i_data->second);
i_data = data.find("1");
i_compare = compare_data.find("1");
// Check that both return successful return results
CHECK_EQUAL(i_compare->first, i_data->first);
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->first == i_data->first);
CHECK(i_compare->second == i_data->second);
i_data = data.find("2");
i_compare = compare_data.find("2");
// Check that both return successful return results
CHECK_EQUAL(i_compare->first, i_data->first);
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->first == i_data->first);
CHECK(i_compare->second == i_data->second);
i_data = data.find("3");
i_compare = compare_data.find("3");
// Check that both return successful return results
CHECK_EQUAL(i_compare->first, i_data->first);
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->first == i_data->first);
CHECK(i_compare->second == i_data->second);
i_data = data.find(".");
i_compare = compare_data.find(".");
// Check that both return successful return results
CHECK_EQUAL(data.end(), i_data);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.end() == i_data);
CHECK(compare_data.end() == i_compare);
i_data = data.find("A");
i_compare = compare_data.find("A");
// Check that both return successful return results
CHECK_EQUAL(data.end(), i_data);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.end() == i_data);
CHECK(compare_data.end() == i_compare);
}
//*************************************************************************
@ -928,43 +928,43 @@ namespace
Compare_Data::const_iterator i_compare = compare_data.find("0");
// Check that both return successful return results
CHECK_EQUAL(i_compare->first, i_data->first);
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->first == i_data->first);
CHECK(i_compare->second == i_data->second);
i_data = data.find("1");
i_compare = compare_data.find("1");
// Check that both return successful return results
CHECK_EQUAL(i_compare->first, i_data->first);
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->first == i_data->first);
CHECK(i_compare->second == i_data->second);
i_data = data.find("2");
i_compare = compare_data.find("2");
// Check that both return successful return results
CHECK_EQUAL(i_compare->first, i_data->first);
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->first == i_data->first);
CHECK(i_compare->second == i_data->second);
i_data = data.find("3");
i_compare = compare_data.find("3");
// Check that both return successful return results
CHECK_EQUAL(i_compare->first, i_data->first);
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->first == i_data->first);
CHECK(i_compare->second == i_data->second);
i_data = data.find(".");
i_compare = compare_data.find(".");
// Check that both return successful return results
CHECK_EQUAL(data.end(), i_data);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.end() == i_data);
CHECK(compare_data.end() == i_compare);
i_data = data.find("A");
i_compare = compare_data.find("A");
// Check that both return successful return results
CHECK_EQUAL(data.end(), i_data);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.end() == i_data);
CHECK(compare_data.end() == i_compare);
}
//*************************************************************************
@ -1001,28 +1001,28 @@ namespace
Compare_Data::iterator i_compare = compare_data.lower_bound("2");
Data::iterator i_data = data.lower_bound("2");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(".");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(".");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound("A");
i_data = data.lower_bound("A");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#else
i_compare = compare_data.lower_bound(".");
i_data = data.lower_bound(".");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
i_compare = compare_data.lower_bound("A");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound("A");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
#endif
}
@ -1034,28 +1034,28 @@ namespace
Compare_Data::const_iterator i_compare = compare_data.lower_bound("4");
Data::const_iterator i_data = data.lower_bound("4");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(".");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(".");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound("A");
i_data = data.lower_bound("A");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#else
i_compare = compare_data.lower_bound(".");
i_data = data.lower_bound(".");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
i_compare = compare_data.lower_bound("A");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound("A");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
#endif
}
@ -1067,28 +1067,28 @@ namespace
Compare_Data::iterator i_compare = compare_data.upper_bound("1");
Data::iterator i_data = data.upper_bound("1");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(".");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(".");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound("A");
i_data = data.upper_bound("A");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#else
i_compare = compare_data.upper_bound(".");
i_data = data.upper_bound(".");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
i_compare = compare_data.upper_bound("A");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound("A");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
#endif
}
@ -1100,28 +1100,28 @@ namespace
Compare_Data::const_iterator i_compare = compare_data.upper_bound("3");
Data::const_iterator i_data = data.upper_bound("3");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(".");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(".");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound("A");
i_data = data.upper_bound("A");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
#else
i_compare = compare_data.upper_bound(".");
i_data = data.upper_bound(".");
CHECK_EQUAL(i_compare->second, i_data->second);
CHECK(i_compare->second == i_data->second);
i_compare = compare_data.upper_bound("A");
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound("A");
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
#endif
}
@ -1176,14 +1176,14 @@ namespace
std::vector<ETL_OR_STD::pair<std::string, int> > compare_data_elements(compare.begin(), compare.end());
CHECK(data_elements == compare_data_elements);
CHECK_EQUAL(data_elements.size(), MAX_SIZE);
CHECK(data_elements.size() == MAX_SIZE);
for(std::vector<ETL_OR_STD::pair<std::string, int> >::iterator it = tab.begin() ; it != tab.end() ; ++it)
{
std::string i = it->first;
//lower_bound
CHECK_EQUAL(compare.lower_bound(i) == compare.end(), data.lower_bound(i) == data.end());
CHECK((compare.lower_bound(i) == compare.end()) == (data.lower_bound(i) == data.end()));
//if both end, or none
if((compare.lower_bound(i) == compare.end()) == (data.lower_bound(i) == data.end()))
{
@ -1196,12 +1196,12 @@ namespace
ETL_OR_STD::pair<Compare_Data::const_iterator, Compare_Data::const_iterator> stlret = compare.equal_range(i);
ETL_OR_STD::pair<Data::const_iterator, Data::const_iterator> etlret = data.equal_range(i);
CHECK_EQUAL(stlret.first == compare.end(), etlret.first == data.end());
CHECK((stlret.first == compare.end()) == (etlret.first == data.end()));
if((stlret.first != compare.end()) && (etlret.first != data.end()))
{
CHECK((*stlret.first) == (*etlret.first));
}
CHECK_EQUAL(stlret.second == compare.end(), etlret.second == data.end());
CHECK((stlret.second == compare.end()) == (etlret.second == data.end()));
if((stlret.second != compare.end()) && (etlret.second != data.end()))
{
CHECK((*stlret.second) == (*etlret.second));
@ -1209,7 +1209,7 @@ namespace
}
//upper_bound
CHECK_EQUAL(compare.upper_bound(i) == compare.end(), data.upper_bound(i) == data.end());
CHECK((compare.upper_bound(i) == compare.end()) == (data.upper_bound(i) == data.end()));
//if both end, or none
if((compare.upper_bound(i) == compare.end()) == (data.upper_bound(i) == data.end()))
{

48
test/test_multiset.cpp
View File

@ -397,8 +397,8 @@ namespace
Data data(initial_data.begin(), initial_data.end());
const Data constData(data);
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -407,8 +407,8 @@ namespace
Data data(initial_data.begin(), initial_data.end());
const Data constData(data);
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -911,15 +911,15 @@ namespace
i_compare = compare_data.find(-1);
// Check that both return successful return results
CHECK_EQUAL(data.end(), i_data);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.end() == i_data);
CHECK(compare_data.end() == i_compare);
i_data = data.find(99);
i_compare = compare_data.find(99);
// Check that both return successful return results
CHECK_EQUAL(data.end(), i_data);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.end() == i_data);
CHECK(compare_data.end() == i_compare);
}
//*************************************************************************
@ -956,15 +956,15 @@ namespace
i_compare = compare_data.find(-1);
// Check that both return successful return results
CHECK_EQUAL(data.end(), i_data);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.end() == i_data);
CHECK(compare_data.end() == i_compare);
i_data = data.find(99);
i_compare = compare_data.find(99);
// Check that both return successful return results
CHECK_EQUAL(data.end(), i_data);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(data.end() == i_data);
CHECK(compare_data.end() == i_compare);
}
//*************************************************************************
@ -1005,14 +1005,14 @@ namespace
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(-1);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(-1);
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound(99);
i_data = data.lower_bound(99);
CHECK_EQUAL(*i_compare, *i_data);
CHECK(*i_compare == *i_data);
#else
i_compare = compare_data.lower_bound(-1);
i_data = data.lower_bound(-1);
@ -1038,14 +1038,14 @@ namespace
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(-1);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(-1);
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound(99);
i_data = data.lower_bound(99);
CHECK_EQUAL(*i_compare, *i_data);
CHECK(*i_compare == *i_data);
#else
i_compare = compare_data.lower_bound(-1);
i_data = data.lower_bound(-1);
@ -1071,14 +1071,14 @@ namespace
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(-1);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(-1);
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound(99);
i_data = data.upper_bound(99);
CHECK_EQUAL(*i_compare, *i_data);
CHECK(*i_compare == *i_data);
#else
i_compare = compare_data.upper_bound(-1);
i_data = data.upper_bound(-1);
@ -1104,14 +1104,14 @@ namespace
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(-1);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(-1);
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound(99);
i_data = data.upper_bound(99);
CHECK_EQUAL(*i_compare, *i_data);
CHECK(*i_compare == *i_data);
#else
i_compare = compare_data.upper_bound(-1);
i_data = data.upper_bound(-1);

10
test/test_pearson.cpp
View File

@ -115,7 +115,7 @@ namespace
hash_t compare = Pearson_Compare(data);
hash_t hash = etl::pearson<HASH_SIZE>(data.begin(), data.end());
CHECK_EQUAL(compare, hash);
CHECK(compare == hash);
}
//*************************************************************************
@ -133,7 +133,7 @@ namespace
hash_t compare = Pearson_Compare(data);
hash_t hash = pearson_calculator;
CHECK_EQUAL(compare, hash);
CHECK(compare == hash);
}
//*************************************************************************
@ -148,7 +148,7 @@ namespace
hash_t compare = Pearson_Compare(data);
hash_t hash = pearson_calculator.value();
CHECK_EQUAL(compare, hash);
CHECK(compare == hash);
}
//*************************************************************************
@ -160,10 +160,10 @@ namespace
hash_t hash1 = etl::pearson<HASH_SIZE>(data1.begin(), data1.end());
hash_t hash2 = etl::pearson<HASH_SIZE>((uint8_t*)&data2[0], (uint8_t*)(&data2[0] + data2.size()));
CHECK_EQUAL(hash1, hash2);
CHECK(hash1 == hash2);
hash_t hash3 = etl::pearson<HASH_SIZE>(data3.rbegin(), data3.rend());
CHECK_EQUAL(hash1, hash3);
CHECK(hash1 == hash3);
}
};
}

24
test/test_reference_flat_map.cpp
View File

@ -230,8 +230,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -240,8 +240,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -681,10 +681,10 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(-1);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(10);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -702,10 +702,10 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(-1);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(10);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -756,12 +756,12 @@ namespace
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data;
i_data = data.equal_range(-1);
CHECK_EQUAL(data.begin(), i_data.first);
CHECK_EQUAL(data.begin(), i_data.second);
CHECK(data.begin() == i_data.first);
CHECK(data.begin() == i_data.second);
i_data = data.equal_range(99);
CHECK_EQUAL(data.end(), i_data.first);
CHECK_EQUAL(data.end(), i_data.second);
CHECK(data.end() == i_data.first);
CHECK(data.end() == i_data.second);
}
//*************************************************************************

28
test/test_reference_flat_multimap.cpp
View File

@ -188,8 +188,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -198,8 +198,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -500,7 +500,7 @@ namespace
CHECK_EQUAL(N3, it->second);
it = data.find(19);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -509,10 +509,10 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(-1);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(10);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -524,7 +524,7 @@ namespace
CHECK_EQUAL(N3, it->second);
it = data.find(19);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -533,10 +533,10 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(-1);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(10);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -584,12 +584,12 @@ namespace
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data;
i_data = data.equal_range(-1);
CHECK_EQUAL(data.begin(), i_data.first);
CHECK_EQUAL(data.begin(), i_data.second);
CHECK(data.begin() == i_data.first);
CHECK(data.begin() == i_data.second);
i_data = data.equal_range(99);
CHECK_EQUAL(data.end(), i_data.first);
CHECK_EQUAL(data.end(), i_data.second);
CHECK(data.end() == i_data.first);
CHECK(data.end() == i_data.second);
}
//*************************************************************************

28
test/test_reference_flat_multiset.cpp
View File

@ -174,8 +174,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -184,8 +184,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -479,7 +479,7 @@ namespace
CHECK_EQUAL(N3, *it);
it = data.find(N19);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -488,10 +488,10 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(NX);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(NY);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -503,7 +503,7 @@ namespace
CHECK_EQUAL(N3, *it);
it = data.find(N19);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -512,10 +512,10 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(NX);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(NY);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -563,12 +563,12 @@ namespace
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data;
i_data = data.equal_range(NX);
CHECK_EQUAL(data.begin(), i_data.first);
CHECK_EQUAL(data.begin(), i_data.second);
CHECK(data.begin() == i_data.first);
CHECK(data.begin() == i_data.second);
i_data = data.equal_range(NY);
CHECK_EQUAL(data.end(), i_data.first);
CHECK_EQUAL(data.end(), i_data.second);
CHECK(data.end() == i_data.first);
CHECK(data.end() == i_data.second);
}
//*************************************************************************

24
test/test_reference_flat_set.cpp
View File

@ -186,8 +186,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -196,8 +196,8 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
const DataNDC constData(initial_data.begin(), initial_data.end());
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -493,10 +493,10 @@ namespace
DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::iterator it = data.find(NX);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(NY);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -514,10 +514,10 @@ namespace
const DataNDC data(initial_data.begin(), initial_data.end());
DataNDC::const_iterator it = data.find(NX);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
it = data.find(NY);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -565,12 +565,12 @@ namespace
ETL_OR_STD::pair<DataNDC::iterator, DataNDC::iterator> i_data;
i_data = data.equal_range(NX);
CHECK_EQUAL(data.begin(), i_data.first);
CHECK_EQUAL(data.begin(), i_data.second);
CHECK(data.begin() == i_data.first);
CHECK(data.begin() == i_data.second);
i_data = data.equal_range(NY);
CHECK_EQUAL(data.end(), i_data.first);
CHECK_EQUAL(data.end(), i_data.second);
CHECK(data.end() == i_data.first);
CHECK(data.end() == i_data.second);
}
//*************************************************************************

30
test/test_set.cpp
View File

@ -415,8 +415,8 @@ namespace
Data data(initial_data.begin(), initial_data.end());
const Data constData(data);
CHECK_EQUAL(data.begin(), std::begin(data));
CHECK_EQUAL(constData.begin(), std::begin(constData));
CHECK(data.begin() == std::begin(data));
CHECK(constData.begin() == std::begin(constData));
}
//*************************************************************************
@ -425,8 +425,8 @@ namespace
Data data(initial_data.begin(), initial_data.end());
const Data constData(data);
CHECK_EQUAL(data.end(), std::end(data));
CHECK_EQUAL(constData.end(), std::end(constData));
CHECK(data.end() == std::end(data));
CHECK(constData.end() == std::end(constData));
}
//*************************************************************************
@ -933,7 +933,7 @@ namespace
CHECK_EQUAL(3, *it);
it = data.find(11);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -945,7 +945,7 @@ namespace
CHECK_EQUAL(3, *it);
it = data.find(11);
CHECK_EQUAL(data.end(), it);
CHECK(data.end() == it);
}
//*************************************************************************
@ -986,14 +986,14 @@ namespace
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(-1);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(-1);
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound(11);
i_data = data.lower_bound(11);
CHECK_EQUAL(*i_compare, *i_data);
CHECK(*i_compare == *i_data);
#else
i_compare = compare_data.lower_bound(-1);
i_data = data.lower_bound(-1);
@ -1019,10 +1019,10 @@ namespace
#ifdef TEST_GREATER_THAN
i_compare = compare_data.lower_bound(-1);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.lower_bound(-1);
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.lower_bound(11);
i_data = data.lower_bound(11);
@ -1052,10 +1052,10 @@ namespace
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(-1);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(-1);
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound(11);
i_data = data.upper_bound(11);
@ -1085,10 +1085,10 @@ namespace
#ifdef TEST_GREATER_THAN
i_compare = compare_data.upper_bound(-1);
CHECK_EQUAL(compare_data.end(), i_compare);
CHECK(compare_data.end() == i_compare);
i_data = data.upper_bound(-1);
CHECK_EQUAL(data.end(), i_data);
CHECK(data.end() == i_data);
i_compare = compare_data.upper_bound(11);
i_data = data.upper_bound(11);

466
test/test_string_view.cpp
View File

@ -67,8 +67,8 @@ namespace
{
View view;
CHECK_EQUAL(0U, view.size());
CHECK_EQUAL(0U, view.max_size());
CHECK(0U == view.size());
CHECK(0U == view.max_size());
CHECK(view.empty());
}
@ -77,8 +77,8 @@ namespace
{
View view(pctext, pctext + strlen(pctext));
CHECK_EQUAL(text.size(), view.size());
CHECK_EQUAL(text.size(), view.max_size());
CHECK(text.size() == view.size());
CHECK(text.size() == view.max_size());
bool isEqual = std::equal(view.begin(), view.end(), text.begin());
CHECK(isEqual);
@ -89,8 +89,8 @@ namespace
{
View view(etltext);
CHECK_EQUAL(etltext.size(), view.size());
CHECK_EQUAL(etltext.size(), view.max_size());
CHECK(etltext.size() == view.size());
CHECK(etltext.size() == view.max_size());
bool isEqual = std::equal(view.begin(), view.end(), etltext.begin());
CHECK(isEqual);
@ -101,8 +101,8 @@ namespace
{
View view(pctext, strlen(pctext));
CHECK_EQUAL(text.size(), view.size());
CHECK_EQUAL(text.size(), view.max_size());
CHECK(text.size() == view.size());
CHECK(text.size() == view.max_size());
bool isEqual = std::equal(view.begin(), view.end(), text.begin());
CHECK(isEqual);
@ -113,8 +113,8 @@ namespace
{
View view(pctext);
CHECK_EQUAL(text.size(), view.size());
CHECK_EQUAL(text.size(), view.max_size());
CHECK(text.size() == view.size());
CHECK(text.size() == view.max_size());
bool isEqual = std::equal(view.begin(), view.end(), text.begin());
CHECK(isEqual);
@ -125,8 +125,8 @@ namespace
{
View view("Hello World");
CHECK_EQUAL(text.size(), view.size());
CHECK_EQUAL(text.size(), view.max_size());
CHECK(text.size() == view.size());
CHECK(text.size() == view.max_size());
bool isEqual = std::equal(view.begin(), view.end(), text.begin());
CHECK(isEqual);
@ -140,8 +140,8 @@ namespace
view2 = view1;
CHECK_EQUAL(view1.size(), view2.size());
CHECK_EQUAL(view1.max_size(), view2.max_size());
CHECK(view1.size() == view2.size());
CHECK(view1.max_size() == view2.max_size());
bool isEqual;
@ -156,8 +156,8 @@ namespace
view.assign(text.c_str(), text.size());
CHECK_EQUAL(text.size(), view.size());
CHECK_EQUAL(text.size(), view.max_size());
CHECK(text.size() == view.size());
CHECK(text.size() == view.max_size());
bool isEqual;
@ -170,10 +170,10 @@ namespace
{
View view(text.c_str(), text.size());
CHECK_EQUAL(view.begin(), view.cbegin());
CHECK_EQUAL(view.rbegin().base(), view.crbegin().base());
CHECK_EQUAL(view.end(), view.cend());
CHECK_EQUAL(view.rend().base(), view.crend().base());
CHECK(view.begin() == view.cbegin());
CHECK(view.rbegin().base() == view.crbegin().base());
CHECK(view.end() == view.cend());
CHECK(view.rend().base() == view.crend().base());
}
//*************************************************************************
@ -181,8 +181,8 @@ namespace
{
View view(text.c_str(), text.size());
CHECK_EQUAL(text.front(), view.front());
CHECK_EQUAL(text.back(), view.back());
CHECK(text.front() == view.front());
CHECK(text.back() == view.back());
}
//*************************************************************************
@ -190,7 +190,7 @@ namespace
{
View view(text.c_str(), text.size());
CHECK_EQUAL(text.data(), view.data());
CHECK(text.data() == view.data());
}
//*************************************************************************
@ -200,7 +200,7 @@ namespace
for (size_t i = 0; i < text.size(); ++i)
{
CHECK_EQUAL(text[i], view[i]);
CHECK(text[i] == view[i]);
}
}
@ -211,7 +211,7 @@ namespace
for (size_t i = 0; i < text.size(); ++i)
{
CHECK_EQUAL(text[i], view.at(i));
CHECK(text[i] == view.at(i));
}
}
@ -296,8 +296,8 @@ namespace
std::swap(view1, view2);
CHECK_EQUAL(text.size(), view1.size());
CHECK_EQUAL(text_smaller.size(), view2.size());
CHECK(text.size() == view1.size());
CHECK(text_smaller.size() == view2.size());
bool isEqual;
@ -340,35 +340,35 @@ namespace
// Full text.
destination.fill(0);
count = view.copy(destination.data(), text.size(), 0);
CHECK_EQUAL(text.size(), count);
CHECK_EQUAL(text.size(), strlen(destination.data()));
CHECK(text.size() == count);
CHECK(text.size() == strlen(destination.data()));
CHECK_ARRAY_EQUAL(text.data(), destination.data(), text.size());
// From position 2, count OK.
destination.fill(0);
count = view.copy(destination.data(), text.size() - 2, 2);
CHECK_EQUAL(text.size() - 2, count);
CHECK_EQUAL(text.size() - 2, strlen(destination.data()));
CHECK(text.size() - 2 == count);
CHECK(text.size() - 2 == strlen(destination.data()));
CHECK_ARRAY_EQUAL(text.data() + 2, destination.data(), text.size() - 2);
// From position 2, count too large.
destination.fill(0);
count = view.copy(destination.data(), text.size(), 2);
CHECK_EQUAL(text.size() - 2, count);
CHECK_EQUAL(text.size() - 2, strlen(destination.data()));
CHECK(text.size() - 2 == count);
CHECK(text.size() - 2 == strlen(destination.data()));
CHECK_ARRAY_EQUAL(text.data() + 2, destination.data(), text.size() - 2);
// Position too large.
destination.fill(0);
count = view.copy(destination.data(), text.size(), 11);
CHECK_EQUAL(0U, count);
CHECK(0U == count);
CHECK_ARRAY_EQUAL(blank.data(), destination.data(), text.size());
// From position 2, short range.
destination.fill(0);
count = view.copy(destination.data(), text.size() - 4, 2);
CHECK_EQUAL(text.size() - 4, count);
CHECK_EQUAL(text.size() - 4, strlen(destination.data()));
CHECK(text.size() - 4 == count);
CHECK(text.size() - 4 == strlen(destination.data()));
CHECK_ARRAY_EQUAL(text.data() + 2, destination.data(), text.size() - 4);
}
@ -383,19 +383,19 @@ namespace
// Whole string.
sub = view1.substr(0, text.size());
CHECK_EQUAL(view1, sub);
CHECK(view1 == sub);
// From from +2 to -2.
sub = view1.substr(2, text.size() - 2);
CHECK_EQUAL(view2, sub);
CHECK(view2 == sub);
// Position too large.
sub = view1.substr(text.size(), 2);
CHECK_EQUAL(view3, sub);
CHECK(view3 == sub);
// Count too large.
sub = view1.substr(2, text.size());
CHECK_EQUAL(view4, sub);
CHECK(view4 == sub);
}
//*************************************************************************
@ -405,11 +405,11 @@ namespace
View view_smaller(text_smaller.c_str());
View view_shorter(text_shorter.c_str());
CHECK_EQUAL(0, view.compare(view));
CHECK_EQUAL(-1, view_smaller.compare(view));
CHECK_EQUAL(-1, view_shorter.compare(view));
CHECK_EQUAL(1, view.compare(view_smaller));
CHECK_EQUAL(1, view.compare(view_shorter));
CHECK(0 == view.compare(view));
CHECK(-1 == view_smaller.compare(view));
CHECK(-1 == view_shorter.compare(view));
CHECK(1 == view.compare(view_smaller));
CHECK(1 == view.compare(view_shorter));
}
//*************************************************************************
@ -428,10 +428,10 @@ namespace
std::string text_shorter_long = std::string("xx") + text_shorter + std::string("xx");
View view_shorter_long(text_shorter_long.c_str());
CHECK_EQUAL(0, view_long.compare(2, view.size(), view));
CHECK_EQUAL(-1, view_smaller_long.compare(2, view.size(), view));
CHECK_EQUAL(1, view_long.compare(2, view.size(), view_smaller));
CHECK_EQUAL(1, view_long.compare(2, view.size(), view_shorter));
CHECK(0 == view_long.compare(2, view.size(), view));
CHECK(-1 == view_smaller_long.compare(2, view.size(), view));
CHECK(1 == view_long.compare(2, view.size(), view_smaller));
CHECK(1 == view_long.compare(2, view.size(), view_shorter));
}
//*************************************************************************
@ -448,11 +448,11 @@ namespace
std::string text_shorter_long = std::string("xx") + text_shorter + std::string("xx");
View view_shorter_long(text_shorter_long.c_str());
CHECK_EQUAL(0, view_long.compare(2, view.size(), view_long, 2, view.size()));
CHECK_EQUAL(-1, view_smaller_long.compare(2, view.size(), view_long, 2, view.size()));
CHECK_EQUAL(-1, view_shorter_long.compare(2, text_shorter.size(), view_long, 2, view.size()));
CHECK_EQUAL(1, view_long.compare(2, view.size(), view_smaller_long, 2, view.size()));
CHECK_EQUAL(1, view_long.compare(2, view.size(), view_shorter_long, 2, text_shorter.size()));
CHECK(0 == view_long.compare(2, view.size(), view_long, 2, view.size()));
CHECK(-1 == view_smaller_long.compare(2, view.size(), view_long, 2, view.size()));
CHECK(-1 == view_shorter_long.compare(2, text_shorter.size(), view_long, 2, view.size()));
CHECK(1 == view_long.compare(2, view.size(), view_smaller_long, 2, view.size()));
CHECK(1 == view_long.compare(2, view.size(), view_shorter_long, 2, text_shorter.size()));
}
//*************************************************************************
@ -462,11 +462,11 @@ namespace
View view_smaller(text_smaller.c_str());
View view_shorter(text_shorter.c_str());
CHECK_EQUAL(0, view.compare(view.data()));
CHECK_EQUAL(-1, view_smaller.compare(view.data()));
CHECK_EQUAL(1, view.compare(view_smaller.data()));
CHECK_EQUAL(-1, view_shorter.compare(view.data()));
CHECK_EQUAL(1, view.compare(view_shorter.data()));
CHECK(0 == view.compare(view.data()));
CHECK(-1 == view_smaller.compare(view.data()));
CHECK(1 == view.compare(view_smaller.data()));
CHECK(-1 == view_shorter.compare(view.data()));
CHECK(1 == view.compare(view_shorter.data()));
}
//*************************************************************************
@ -485,11 +485,11 @@ namespace
std::string text_shorter_long = std::string("xx") + text_shorter + std::string("xx");
View view_shorter_long(text_shorter_long.c_str());
CHECK_EQUAL(0, view_long.compare(2, view.size(), view.data()));
CHECK_EQUAL(-1, view_smaller_long.compare(2, view.size(), view_long.data()));
CHECK_EQUAL(-1, view_shorter_long.compare(2, text_shorter.size(), view_long.data()));
CHECK_EQUAL(1, view_long.compare(2, view.size(), view_smaller.data()));
CHECK_EQUAL(1, view_long.compare(2, view.size(), view_shorter.data()));
CHECK(0 == view_long.compare(2, view.size(), view.data()));
CHECK(-1 == view_smaller_long.compare(2, view.size(), view_long.data()));
CHECK(-1 == view_shorter_long.compare(2, text_shorter.size(), view_long.data()));
CHECK(1 == view_long.compare(2, view.size(), view_smaller.data()));
CHECK(1 == view_long.compare(2, view.size(), view_shorter.data()));
}
//*************************************************************************
@ -508,11 +508,11 @@ namespace
std::string text_shorter_long = std::string("xx") + text_shorter + std::string("xx");
View view_shorter_long(text_shorter_long.c_str());
CHECK_EQUAL(0, view_long.compare(2, view.size(), view.data(), view.size()));
CHECK_EQUAL(-1, view_smaller_long.compare(2, view.size(), view_long.data(), view_long.size()));
CHECK_EQUAL(-1, view_shorter_long.compare(2, text_shorter.size(), view_long.data(), view_long.size()));
CHECK_EQUAL(1, view_long.compare(2, view.size(), view_smaller.data(), view_smaller.size()));
CHECK_EQUAL(1, view_long.compare(2, view.size(), view_shorter.data(), view_shorter.size()));
CHECK(0 == view_long.compare(2, view.size(), view.data(), view.size()));
CHECK(-1 == view_smaller_long.compare(2, view.size(), view_long.data(), view_long.size()));
CHECK(-1 == view_shorter_long.compare(2, text_shorter.size(), view_long.data(), view_long.size()));
CHECK(1 == view_long.compare(2, view.size(), view_smaller.data(), view_smaller.size()));
CHECK(1 == view_long.compare(2, view.size(), view_shorter.data(), view_shorter.size()));
}
//*************************************************************************
@ -571,34 +571,34 @@ namespace
View v4(s4);
View v5(s5);
CHECK_EQUAL(0U, view.find(v1));
CHECK_EQUAL(2U, view.find(v2));
CHECK_EQUAL(2U, view.find(v2, 2));
CHECK_EQUAL(6U, view.find(v3));
CHECK_EQUAL(View::npos, view.find(v3, 7));
CHECK_EQUAL(View::npos, view.find(v4));
CHECK_EQUAL(View::npos, view.find(v5));
CHECK(0U == view.find(v1));
CHECK(2U == view.find(v2));
CHECK(2U == view.find(v2, 2));
CHECK(6U == view.find(v3));
CHECK(View::npos == view.find(v3, 7));
CHECK(View::npos == view.find(v4));
CHECK(View::npos == view.find(v5));
CHECK_EQUAL(0U, view.find('H'));
CHECK_EQUAL(2U, view.find('l'));
CHECK_EQUAL(2U, view.find('l', 2));
CHECK_EQUAL(View::npos, view.find('X'));
CHECK(0U == view.find('H'));
CHECK(2U == view.find('l'));
CHECK(2U == view.find('l', 2));
CHECK(View::npos == view.find('X'));
CHECK_EQUAL(0U, view.find(s1));
CHECK_EQUAL(2U, view.find(s2));
CHECK_EQUAL(2U, view.find(s2, 2));
CHECK_EQUAL(6U, view.find(s3));
CHECK_EQUAL(View::npos, view.find(s3, 7));
CHECK_EQUAL(View::npos, view.find(s4));
CHECK_EQUAL(View::npos, view.find(s5));
CHECK(0U == view.find(s1));
CHECK(2U == view.find(s2));
CHECK(2U == view.find(s2, 2));
CHECK(6U == view.find(s3));
CHECK(View::npos == view.find(s3, 7));
CHECK(View::npos == view.find(s4));
CHECK(View::npos == view.find(s5));
CHECK_EQUAL(0U, view.find(s1, 0, 3));
CHECK_EQUAL(2U, view.find(s2, 0, 3));
CHECK_EQUAL(2U, view.find(s2, 2, 3));
CHECK_EQUAL(6U, view.find(s3, 0, 3));
CHECK_EQUAL(View::npos, view.find(s3, 7, 3));
CHECK_EQUAL(View::npos, view.find(s4, 0, 3));
CHECK_EQUAL(View::npos, view.find(s5, 0, 15));
CHECK(0U == view.find(s1, 0, 3));
CHECK(2U == view.find(s2, 0, 3));
CHECK(2U == view.find(s2, 2, 3));
CHECK(6U == view.find(s3, 0, 3));
CHECK(View::npos == view.find(s3, 7, 3));
CHECK(View::npos == view.find(s4, 0, 3));
CHECK(View::npos == view.find(s5, 0, 15));
}
//*************************************************************************
@ -615,22 +615,22 @@ namespace
View v3(s3);
View v4(s4);
CHECK_EQUAL(8U, view.rfind(v1));
CHECK_EQUAL(6U, view.rfind(v2));
CHECK_EQUAL(2U, view.rfind(v2, 5));
CHECK_EQUAL(View::npos, view.rfind(v4));
CHECK(8U == view.rfind(v1));
CHECK(6U == view.rfind(v2));
CHECK(2U == view.rfind(v2, 5));
CHECK(View::npos == view.rfind(v4));
CHECK_EQUAL(8U, view.rfind('a'));
CHECK_EQUAL(6U, view.rfind('c'));
CHECK_EQUAL(2U, view.rfind('c', 5));
CHECK(8U == view.rfind('a'));
CHECK(6U == view.rfind('c'));
CHECK(2U == view.rfind('c', 5));
CHECK_EQUAL(8U, view.rfind(s1));
CHECK_EQUAL(6U, view.rfind(s2));
CHECK_EQUAL(2U, view.rfind(s2, 5));
CHECK_EQUAL(View::npos, view.rfind(s4));
CHECK(8U == view.rfind(s1));
CHECK(6U == view.rfind(s2));
CHECK(2U == view.rfind(s2, 5));
CHECK(View::npos == view.rfind(s4));
CHECK_EQUAL(1U, view.rfind(s3, 5, 2));
CHECK_EQUAL(View::npos, view.rfind(s4, 0, 11));
CHECK(1U == view.rfind(s3, 5, 2));
CHECK(View::npos == view.rfind(s4, 0, 11));
}
//*************************************************************************
@ -649,40 +649,40 @@ namespace
View v4(s4);
View v5(s5);
CHECK_EQUAL(2U, view.find_first_of(v1));
CHECK_EQUAL(4U, view.find_first_of(v2));
CHECK_EQUAL(6U, view.find_first_of(v3));
CHECK_EQUAL(2U, view.find_first_of(v4));
CHECK_EQUAL(View::npos, view.find_first_of(v5));
CHECK(2U == view.find_first_of(v1));
CHECK(4U == view.find_first_of(v2));
CHECK(6U == view.find_first_of(v3));
CHECK(2U == view.find_first_of(v4));
CHECK(View::npos == view.find_first_of(v5));
CHECK_EQUAL(3U, view.find_first_of(v1, 3));
CHECK_EQUAL(4U, view.find_first_of(v2, 2));
CHECK_EQUAL(View::npos, view.find_first_of(v3, 7));
CHECK_EQUAL(6U, view.find_first_of(v4, 5));
CHECK_EQUAL(View::npos, view.find_first_of(v5, 2));
CHECK(3U == view.find_first_of(v1, 3));
CHECK(4U == view.find_first_of(v2, 2));
CHECK(View::npos == view.find_first_of(v3, 7));
CHECK(6U == view.find_first_of(v4, 5));
CHECK(View::npos == view.find_first_of(v5, 2));
CHECK_EQUAL(2U, view.find_first_of('l'));
CHECK_EQUAL(4U, view.find_first_of('o'));
CHECK_EQUAL(6U, view.find_first_of('W'));
CHECK_EQUAL(View::npos, view.find_first_of('w'));
CHECK(2U == view.find_first_of('l'));
CHECK(4U == view.find_first_of('o'));
CHECK(6U == view.find_first_of('W'));
CHECK(View::npos == view.find_first_of('w'));
CHECK_EQUAL(2U, view.find_first_of(s1));
CHECK_EQUAL(4U, view.find_first_of(s2));
CHECK_EQUAL(6U, view.find_first_of(s3));
CHECK_EQUAL(2U, view.find_first_of(s4));
CHECK_EQUAL(View::npos, view.find_first_of(s5));
CHECK(2U == view.find_first_of(s1));
CHECK(4U == view.find_first_of(s2));
CHECK(6U == view.find_first_of(s3));
CHECK(2U == view.find_first_of(s4));
CHECK(View::npos == view.find_first_of(s5));
CHECK_EQUAL(3U, view.find_first_of(s1, 3));
CHECK_EQUAL(4U, view.find_first_of(s2, 2));
CHECK_EQUAL(View::npos, view.find_first_of(s3, 7));
CHECK_EQUAL(6U, view.find_first_of(s4, 5));
CHECK_EQUAL(View::npos, view.find_first_of(s5, 2));
CHECK(3U == view.find_first_of(s1, 3));
CHECK(4U == view.find_first_of(s2, 2));
CHECK(View::npos == view.find_first_of(s3, 7));
CHECK(6U == view.find_first_of(s4, 5));
CHECK(View::npos == view.find_first_of(s5, 2));
CHECK_EQUAL(3U, view.find_first_of(s1, 3, 1));
CHECK_EQUAL(4U, view.find_first_of(s2, 2, 1));
CHECK_EQUAL(View::npos, view.find_first_of(s3, 7, 1));
CHECK_EQUAL(4U, view.find_first_of(s4, 0, 2));
CHECK_EQUAL(View::npos, view.find_first_of(s5, 2, 3));
CHECK(3U == view.find_first_of(s1, 3, 1));
CHECK(4U == view.find_first_of(s2, 2, 1));
CHECK(View::npos == view.find_first_of(s3, 7, 1));
CHECK(4U == view.find_first_of(s4, 0, 2));
CHECK(View::npos == view.find_first_of(s5, 2, 3));
}
//*************************************************************************
@ -701,40 +701,40 @@ namespace
View v4(s4);
View v5(s5);
CHECK_EQUAL(9U, view.find_last_of(v1));
CHECK_EQUAL(7U, view.find_last_of(v2));
CHECK_EQUAL(6U, view.find_last_of(v3));
CHECK_EQUAL(9U, view.find_last_of(v4));
CHECK_EQUAL(View::npos, view.find_last_of(v5));
CHECK(9U == view.find_last_of(v1));
CHECK(7U == view.find_last_of(v2));
CHECK(6U == view.find_last_of(v3));
CHECK(9U == view.find_last_of(v4));
CHECK(View::npos == view.find_last_of(v5));
CHECK_EQUAL(3U, view.find_last_of(v1, 3));
CHECK_EQUAL(View::npos, view.find_last_of(v2, 2));
CHECK_EQUAL(6U, view.find_last_of(v3, 7));
CHECK_EQUAL(4U, view.find_last_of(v4, 5));
CHECK_EQUAL(View::npos, view.find_last_of(v5, 2));
CHECK(3U == view.find_last_of(v1, 3));
CHECK(View::npos == view.find_last_of(v2, 2));
CHECK(6U == view.find_last_of(v3, 7));
CHECK(4U == view.find_last_of(v4, 5));
CHECK(View::npos == view.find_last_of(v5, 2));
CHECK_EQUAL(9U, view.find_last_of('l'));
CHECK_EQUAL(7U, view.find_last_of('o'));
CHECK_EQUAL(6U, view.find_last_of('W'));
CHECK_EQUAL(View::npos, view.find_last_of('w'));
CHECK(9U == view.find_last_of('l'));
CHECK(7U == view.find_last_of('o'));
CHECK(6U == view.find_last_of('W'));
CHECK(View::npos == view.find_last_of('w'));
CHECK_EQUAL(9U, view.find_last_of(s1));
CHECK_EQUAL(7U, view.find_last_of(s2));
CHECK_EQUAL(6U, view.find_last_of(s3));
CHECK_EQUAL(9U, view.find_last_of(s4));
CHECK_EQUAL(View::npos, view.find_last_of(s5));
CHECK(9U == view.find_last_of(s1));
CHECK(7U == view.find_last_of(s2));
CHECK(6U == view.find_last_of(s3));
CHECK(9U == view.find_last_of(s4));
CHECK(View::npos == view.find_last_of(s5));
CHECK_EQUAL(3U, view.find_last_of(s1, 3));
CHECK_EQUAL(View::npos, view.find_last_of(s2, 2));
CHECK_EQUAL(6U, view.find_last_of(s3, 7));
CHECK_EQUAL(4U, view.find_last_of(s4, 5));
CHECK_EQUAL(View::npos, view.find_last_of(s5, 2));
CHECK(3U == view.find_last_of(s1, 3));
CHECK(View::npos == view.find_last_of(s2, 2));
CHECK(6U == view.find_last_of(s3, 7));
CHECK(4U == view.find_last_of(s4, 5));
CHECK(View::npos == view.find_last_of(s5, 2));
CHECK_EQUAL(3U, view.find_last_of(s1, 3, 1));
CHECK_EQUAL(View::npos, view.find_last_of(s2, 2, 1));
CHECK_EQUAL(6U, view.find_last_of(s3, 7, 1));
CHECK_EQUAL(4U, view.find_last_of(s4, 5, 2));
CHECK_EQUAL(View::npos, view.find_last_of(s5, 2, 3));
CHECK(3U == view.find_last_of(s1, 3, 1));
CHECK(View::npos == view.find_last_of(s2, 2, 1));
CHECK(6U == view.find_last_of(s3, 7, 1));
CHECK(4U == view.find_last_of(s4, 5, 2));
CHECK(View::npos == view.find_last_of(s5, 2, 3));
}
//*************************************************************************
@ -755,43 +755,43 @@ namespace
View v5(s5);
View v6(s6);
CHECK_EQUAL(1U, view.find_first_not_of(v1));
CHECK_EQUAL(2U, view.find_first_not_of(v2));
CHECK_EQUAL(4U, view.find_first_not_of(v3));
CHECK_EQUAL(6U, view.find_first_not_of(v4));
CHECK_EQUAL(0U, view.find_first_not_of(v5));
CHECK_EQUAL(View::npos, view.find_first_not_of(v6));
CHECK(1U == view.find_first_not_of(v1));
CHECK(2U == view.find_first_not_of(v2));
CHECK(4U == view.find_first_not_of(v3));
CHECK(6U == view.find_first_not_of(v4));
CHECK(0U == view.find_first_not_of(v5));
CHECK(View::npos == view.find_first_not_of(v6));
CHECK_EQUAL(3U, view.find_first_not_of(v1, 3));
CHECK_EQUAL(2U, view.find_first_not_of(v2, 2));
CHECK_EQUAL(7U, view.find_first_not_of(v3, 7));
CHECK_EQUAL(6U, view.find_first_not_of(v4, 5));
CHECK_EQUAL(2U, view.find_first_not_of(v5, 2));
CHECK_EQUAL(View::npos, view.find_first_not_of(v6, 0));
CHECK(3U == view.find_first_not_of(v1, 3));
CHECK(2U == view.find_first_not_of(v2, 2));
CHECK(7U == view.find_first_not_of(v3, 7));
CHECK(6U == view.find_first_not_of(v4, 5));
CHECK(2U == view.find_first_not_of(v5, 2));
CHECK(View::npos == view.find_first_not_of(v6, 0));
CHECK_EQUAL(1U, view.find_first_not_of('H'));
CHECK_EQUAL(0U, view.find_first_not_of('e'));
CHECK(1U == view.find_first_not_of('H'));
CHECK(0U == view.find_first_not_of('e'));
CHECK_EQUAL(1U, view.find_first_not_of(s1));
CHECK_EQUAL(2U, view.find_first_not_of(s2));
CHECK_EQUAL(4U, view.find_first_not_of(s3));
CHECK_EQUAL(6U, view.find_first_not_of(s4));
CHECK_EQUAL(0U, view.find_first_not_of(s5));
CHECK_EQUAL(View::npos, view.find_first_not_of(s6));
CHECK(1U == view.find_first_not_of(s1));
CHECK(2U == view.find_first_not_of(s2));
CHECK(4U == view.find_first_not_of(s3));
CHECK(6U == view.find_first_not_of(s4));
CHECK(0U == view.find_first_not_of(s5));
CHECK(View::npos == view.find_first_not_of(s6));
CHECK_EQUAL(3U, view.find_first_not_of(s1, 3));
CHECK_EQUAL(2U, view.find_first_not_of(s2, 2));
CHECK_EQUAL(7U, view.find_first_not_of(s3, 7));
CHECK_EQUAL(6U, view.find_first_not_of(s4, 5));
CHECK_EQUAL(2U, view.find_first_not_of(s5, 2));
CHECK_EQUAL(View::npos, view.find_first_not_of(s6, 0));
CHECK(3U == view.find_first_not_of(s1, 3));
CHECK(2U == view.find_first_not_of(s2, 2));
CHECK(7U == view.find_first_not_of(s3, 7));
CHECK(6U == view.find_first_not_of(s4, 5));
CHECK(2U == view.find_first_not_of(s5, 2));
CHECK(View::npos == view.find_first_not_of(s6, 0));
CHECK_EQUAL(3U, view.find_first_not_of(s1, 3, 1));
CHECK_EQUAL(2U, view.find_first_not_of(s2, 2, 1));
CHECK_EQUAL(7U, view.find_first_not_of(s3, 7, 1));
CHECK_EQUAL(6U, view.find_first_not_of(s4, 5, 2));
CHECK_EQUAL(2U, view.find_first_not_of(s5, 2, 3));
CHECK_EQUAL(View::npos, view.find_first_not_of(s6, 0, 8));
CHECK(3U == view.find_first_not_of(s1, 3, 1));
CHECK(2U == view.find_first_not_of(s2, 2, 1));
CHECK(7U == view.find_first_not_of(s3, 7, 1));
CHECK(6U == view.find_first_not_of(s4, 5, 2));
CHECK(2U == view.find_first_not_of(s5, 2, 3));
CHECK(View::npos == view.find_first_not_of(s6, 0, 8));
}
//*************************************************************************
@ -812,43 +812,43 @@ namespace
View v5(s5);
View v6(s6);
CHECK_EQUAL(9U, view.find_last_not_of(v1));
CHECK_EQUAL(8U, view.find_last_not_of(v2));
CHECK_EQUAL(7U, view.find_last_not_of(v3));
CHECK_EQUAL(5U, view.find_last_not_of(v4));
CHECK_EQUAL(10U, view.find_last_not_of(v5));
CHECK_EQUAL(View::npos, view.find_last_not_of(v6));
CHECK(9U == view.find_last_not_of(v1));
CHECK(8U == view.find_last_not_of(v2));
CHECK(7U == view.find_last_not_of(v3));
CHECK(5U == view.find_last_not_of(v4));
CHECK(10U == view.find_last_not_of(v5));
CHECK(View::npos == view.find_last_not_of(v6));
CHECK_EQUAL(9U, view.find_last_not_of(v1, 10));
CHECK_EQUAL(8U, view.find_last_not_of(v2, 9));
CHECK_EQUAL(7U, view.find_last_not_of(v3, 8));
CHECK_EQUAL(5U, view.find_last_not_of(v4, 8));
CHECK_EQUAL(8U, view.find_last_not_of(v5, 8));
CHECK_EQUAL(View::npos, view.find_last_not_of(v6, 10));
CHECK(9U == view.find_last_not_of(v1, 10));
CHECK(8U == view.find_last_not_of(v2, 9));
CHECK(7U == view.find_last_not_of(v3, 8));
CHECK(5U == view.find_last_not_of(v4, 8));
CHECK(8U == view.find_last_not_of(v5, 8));
CHECK(View::npos == view.find_last_not_of(v6, 10));
CHECK_EQUAL(9U, view.find_last_not_of('d'));
CHECK_EQUAL(10U, view.find_last_not_of('l'));
CHECK(9U == view.find_last_not_of('d'));
CHECK(10U == view.find_last_not_of('l'));
CHECK_EQUAL(9U, view.find_last_not_of(s1));
CHECK_EQUAL(8U, view.find_last_not_of(s2));
CHECK_EQUAL(7U, view.find_last_not_of(s3));
CHECK_EQUAL(5U, view.find_last_not_of(s4));
CHECK_EQUAL(10U, view.find_last_not_of(s5));
CHECK_EQUAL(View::npos, view.find_last_not_of(s6));
CHECK(9U == view.find_last_not_of(s1));
CHECK(8U == view.find_last_not_of(s2));
CHECK(7U == view.find_last_not_of(s3));
CHECK(5U == view.find_last_not_of(s4));
CHECK(10U == view.find_last_not_of(s5));
CHECK(View::npos == view.find_last_not_of(s6));
CHECK_EQUAL(9U, view.find_last_not_of(s1, 10));
CHECK_EQUAL(8U, view.find_last_not_of(s2, 9));
CHECK_EQUAL(7U, view.find_last_not_of(s3, 8));
CHECK_EQUAL(5U, view.find_last_not_of(s4, 8));
CHECK_EQUAL(8U, view.find_last_not_of(s5, 8));
CHECK_EQUAL(View::npos, view.find_last_not_of(s6, 10));
CHECK(9U == view.find_last_not_of(s1, 10));
CHECK(8U == view.find_last_not_of(s2, 9));
CHECK(7U == view.find_last_not_of(s3, 8));
CHECK(5U == view.find_last_not_of(s4, 8));
CHECK(8U == view.find_last_not_of(s5, 8));
CHECK(View::npos == view.find_last_not_of(s6, 10));
CHECK_EQUAL(9U, view.find_last_not_of(s1, 10, 1));
CHECK_EQUAL(9U, view.find_last_not_of(s2, 9, 1));
CHECK_EQUAL(8U, view.find_last_not_of(s3, 9, 2));
CHECK_EQUAL(7U, view.find_last_not_of(s4, 8, 3));
CHECK_EQUAL(8U, view.find_last_not_of(s5, 8, 5));
CHECK_EQUAL(View::npos, view.find_last_not_of(s6, 10, 8));
CHECK(9U == view.find_last_not_of(s1, 10, 1));
CHECK(9U == view.find_last_not_of(s2, 9, 1));
CHECK(8U == view.find_last_not_of(s3, 9, 2));
CHECK(7U == view.find_last_not_of(s4, 8, 3));
CHECK(8U == view.find_last_not_of(s5, 8, 5));
CHECK(View::npos == view.find_last_not_of(s6, 10, 8));
}
//*************************************************************************
@ -874,10 +874,10 @@ namespace
U16View u16view(u16text.data());
U32View u32view(u32text.data());
CHECK_EQUAL(etl::hash<Text>()(text), etl::hash<View>()(view));
CHECK_EQUAL(etl::hash<WText>()(wtext), etl::hash<WView>()(wview));
CHECK_EQUAL(etl::hash<U16Text>()(u16text), etl::hash<U16View>()(u16view));
CHECK_EQUAL(etl::hash<U32Text>()(u32text), etl::hash<U32View>()(u32view));
CHECK(etl::hash<Text>()(text) == etl::hash<View>()(view));
CHECK(etl::hash<WText>()(wtext) == etl::hash<WView>()(wview));
CHECK(etl::hash<U16Text>()(u16text) == etl::hash<U16View>()(u16view));
CHECK(etl::hash<U32Text>()(u32text) == etl::hash<U32View>()(u32view));
}
};
}

324
test/test_to_string.cpp
View File

@ -60,25 +60,25 @@ namespace
{
etl::string<20> str;
CHECK_EQUAL(etl::string<20>(STR("0")), etl::to_string(uint8_t(0), str));
CHECK_EQUAL(etl::string<20>(STR("0")), etl::to_string(uint16_t(0), str));
CHECK_EQUAL(etl::string<20>(STR("0")), etl::to_string(uint32_t(0), str));
CHECK_EQUAL(etl::string<20>(STR("0")), etl::to_string(uint64_t(0), str));
CHECK(etl::string<20>(STR("0")) == etl::to_string(uint8_t(0), str));
CHECK(etl::string<20>(STR("0")) == etl::to_string(uint16_t(0), str));
CHECK(etl::string<20>(STR("0")) == etl::to_string(uint32_t(0), str));
CHECK(etl::string<20>(STR("0")) == etl::to_string(uint64_t(0), str));
CHECK_EQUAL(etl::string<20>(STR("128")), etl::to_string(uint8_t(128), str));
CHECK_EQUAL(etl::string<20>(STR("32768")), etl::to_string(uint16_t(32768), str));
CHECK_EQUAL(etl::string<20>(STR("2147483648")), etl::to_string(uint32_t(2147483648ul), str));
CHECK_EQUAL(etl::string<20>(STR("9223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK(etl::string<20>(STR("128")) == etl::to_string(uint8_t(128), str));
CHECK(etl::string<20>(STR("32768")) == etl::to_string(uint16_t(32768), str));
CHECK(etl::string<20>(STR("2147483648")) == etl::to_string(uint32_t(2147483648ul), str));
CHECK(etl::string<20>(STR("9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK_EQUAL(etl::string<20>(STR("127")), etl::to_string(int8_t(127), str));
CHECK_EQUAL(etl::string<20>(STR("32767")), etl::to_string(int16_t(32767), str));
CHECK_EQUAL(etl::string<20>(STR("2147483647")), etl::to_string(int32_t(2147483647ll), str));
CHECK_EQUAL(etl::string<20>(STR("9223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str));
CHECK(etl::string<20>(STR("127")) == etl::to_string(int8_t(127), str));
CHECK(etl::string<20>(STR("32767")) == etl::to_string(int16_t(32767), str));
CHECK(etl::string<20>(STR("2147483647")) == etl::to_string(int32_t(2147483647ll), str));
CHECK(etl::string<20>(STR("9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str));
CHECK_EQUAL(etl::string<20>(STR("-128")), etl::to_string(int8_t(-128), str));
CHECK_EQUAL(etl::string<20>(STR("-32768")), etl::to_string(int16_t(-32768), str));
CHECK_EQUAL(etl::string<20>(STR("-2147483648")), etl::to_string(int32_t(-2147483648ll), str));
CHECK_EQUAL(etl::string<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str));
CHECK(etl::string<20>(STR("-128")) == etl::to_string(int8_t(-128), str));
CHECK(etl::string<20>(STR("-32768")) == etl::to_string(int16_t(-32768), str));
CHECK(etl::string<20>(STR("-2147483648")) == etl::to_string(int32_t(-2147483648ll), str));
CHECK(etl::string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str));
}
//*************************************************************************
@ -86,25 +86,25 @@ namespace
{
etl::string<120> str;
CHECK_EQUAL(etl::string<120>(STR("0")), etl::to_string(uint8_t(0), str, true));
CHECK_EQUAL(etl::string<120>(STR("00")), etl::to_string(uint16_t(0), str, true));
CHECK_EQUAL(etl::string<120>(STR("000")), etl::to_string(uint32_t(0), str, true));
CHECK_EQUAL(etl::string<120>(STR("0000")), etl::to_string(uint64_t(0), str, true));
CHECK(etl::string<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::string<120>(STR("00")) == etl::to_string(uint16_t(0), str, true));
CHECK(etl::string<120>(STR("000")) == etl::to_string(uint32_t(0), str, true));
CHECK(etl::string<120>(STR("0000")) == etl::to_string(uint64_t(0), str, true));
CHECK_EQUAL(etl::string<120>(STR("0000128")), etl::to_string(uint8_t(128), str, true));
CHECK_EQUAL(etl::string<120>(STR("000012832768")), etl::to_string(uint16_t(32768), str, true));
CHECK_EQUAL(etl::string<120>(STR("0000128327682147483648")), etl::to_string(uint32_t(2147483648ul), str, true));
CHECK_EQUAL(etl::string<120>(STR("00001283276821474836489223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK(etl::string<120>(STR("0000128")) == etl::to_string(uint8_t(128), str, true));
CHECK(etl::string<120>(STR("000012832768")) == etl::to_string(uint16_t(32768), str, true));
CHECK(etl::string<120>(STR("0000128327682147483648")) == etl::to_string(uint32_t(2147483648ul), str, true));
CHECK(etl::string<120>(STR("00001283276821474836489223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK_EQUAL(etl::string<120>(STR("00001283276821474836489223372036854775808127")), etl::to_string(int8_t(127), str, true));
CHECK_EQUAL(etl::string<120>(STR("0000128327682147483648922337203685477580812732767")), etl::to_string(int16_t(32767), str, true));
CHECK_EQUAL(etl::string<120>(STR("00001283276821474836489223372036854775808127327672147483647")), etl::to_string(int32_t(2147483647ll), str, true));
CHECK_EQUAL(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK(etl::string<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(127), str, true));
CHECK(etl::string<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(32767), str, true));
CHECK(etl::string<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(2147483647ll), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK_EQUAL(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")), etl::to_string(int8_t(-128), str, true));
CHECK_EQUAL(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")), etl::to_string(int16_t(-32768), str, true));
CHECK_EQUAL(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")), etl::to_string(int32_t(-2147483648ll), str, true));
CHECK_EQUAL(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(-128), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(-32768), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
}
//*************************************************************************
@ -116,25 +116,25 @@ namespace
etl::to_string(uint8_t(0), str, format);
CHECK_EQUAL(etl::string<20>(STR("###################0")), etl::to_string(uint8_t(0), str, format));
CHECK_EQUAL(etl::string<20>(STR("###################0")), etl::to_string(uint16_t(0), str, format));
CHECK_EQUAL(etl::string<20>(STR("###################0")), etl::to_string(uint32_t(0), str, format));
CHECK_EQUAL(etl::string<20>(STR("###################0")), etl::to_string(uint64_t(0), str, format));
CHECK(etl::string<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::string<20>(STR("###################0")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::string<20>(STR("###################0")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::string<20>(STR("###################0")) == etl::to_string(uint64_t(0), str, format));
CHECK_EQUAL(etl::string<20>(STR("#################128")), etl::to_string(uint8_t(128), str, format));
CHECK_EQUAL(etl::string<20>(STR("###############32768")), etl::to_string(uint16_t(32768), str, format));
CHECK_EQUAL(etl::string<20>(STR("##########2147483648")), etl::to_string(uint32_t(2147483648ul), str, format));
CHECK_EQUAL(etl::string<20>(STR("#9223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::string<20>(STR("#################128")) == etl::to_string(uint8_t(128), str, format));
CHECK(etl::string<20>(STR("###############32768")) == etl::to_string(uint16_t(32768), str, format));
CHECK(etl::string<20>(STR("##########2147483648")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::string<20>(STR("#9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK_EQUAL(etl::string<20>(STR("#################127")), etl::to_string(int8_t(127), str, format));
CHECK_EQUAL(etl::string<20>(STR("###############32767")), etl::to_string(int16_t(32767), str, format));
CHECK_EQUAL(etl::string<20>(STR("##########2147483647")), etl::to_string(int32_t(2147483647ll), str, format));
CHECK_EQUAL(etl::string<20>(STR("#9223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::string<20>(STR("#################127")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::string<20>(STR("###############32767")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::string<20>(STR("##########2147483647")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::string<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK_EQUAL(etl::string<20>(STR("################-128")), etl::to_string(int8_t(-128), str, format));
CHECK_EQUAL(etl::string<20>(STR("##############-32768")), etl::to_string(int16_t(-32768), str, format));
CHECK_EQUAL(etl::string<20>(STR("#########-2147483648")), etl::to_string(int32_t(-2147483648ll), str, format));
CHECK_EQUAL(etl::string<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::string<20>(STR("################-128")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::string<20>(STR("##############-32768")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::string<20>(STR("#########-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
}
//*************************************************************************
@ -144,25 +144,25 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#')).left();
CHECK_EQUAL(etl::string<20>(STR("0###################")), etl::to_string(uint8_t(0), str, format));
CHECK_EQUAL(etl::string<20>(STR("0###################")), etl::to_string(uint16_t(0), str, format));
CHECK_EQUAL(etl::string<20>(STR("0###################")), etl::to_string(uint32_t(0), str, format));
CHECK_EQUAL(etl::string<20>(STR("0###################")), etl::to_string(uint64_t(0), str, format));
CHECK(etl::string<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::string<20>(STR("0###################")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::string<20>(STR("0###################")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::string<20>(STR("0###################")) == etl::to_string(uint64_t(0), str, format));
CHECK_EQUAL(etl::string<20>(STR("128#################")), etl::to_string(uint8_t(128), str, format));
CHECK_EQUAL(etl::string<20>(STR("32768###############")), etl::to_string(uint16_t(32768), str, format));
CHECK_EQUAL(etl::string<20>(STR("2147483648##########")), etl::to_string(uint32_t(2147483648ul), str, format));
CHECK_EQUAL(etl::string<20>(STR("9223372036854775808#")), etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::string<20>(STR("128#################")) == etl::to_string(uint8_t(128), str, format));
CHECK(etl::string<20>(STR("32768###############")) == etl::to_string(uint16_t(32768), str, format));
CHECK(etl::string<20>(STR("2147483648##########")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::string<20>(STR("9223372036854775808#")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK_EQUAL(etl::string<20>(STR("127#################")), etl::to_string(int8_t(127), str, format));
CHECK_EQUAL(etl::string<20>(STR("32767###############")), etl::to_string(int16_t(32767), str, format));
CHECK_EQUAL(etl::string<20>(STR("2147483647##########")), etl::to_string(int32_t(2147483647ll), str, format));
CHECK_EQUAL(etl::string<20>(STR("9223372036854775807#")), etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::string<20>(STR("127#################")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::string<20>(STR("32767###############")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::string<20>(STR("2147483647##########")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::string<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK_EQUAL(etl::string<20>(STR("-128################")), etl::to_string(int8_t(-128), str, format));
CHECK_EQUAL(etl::string<20>(STR("-32768##############")), etl::to_string(int16_t(-32768), str, format));
CHECK_EQUAL(etl::string<20>(STR("-2147483648#########")), etl::to_string(int32_t(-2147483648ll), str, format));
CHECK_EQUAL(etl::string<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::string<20>(STR("-128################")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::string<20>(STR("-32768##############")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::string<20>(STR("-2147483648#########")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
}
//*************************************************************************
@ -170,25 +170,25 @@ namespace
{
etl::string<64> str;
CHECK_EQUAL(etl::string<64>(STR("00000000")), etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("0000000000000000")), etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("00000000000000000000000000000000")), etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::string<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("0000000000000000")) == etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::string<64>(STR("00000000000000000000000000000000")) == etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("10000000")), etl::to_string(uint8_t(128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("1000000000000000")), etl::to_string(uint16_t(32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("10000000000000000000000000000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::string<64>(STR("10000000")) == etl::to_string(uint8_t(128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("1000000000000000")) == etl::to_string(uint16_t(32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::string<64>(STR("10000000000000000000000000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("01111111")), etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("0111111111111111")), etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("01111111111111111111111111111111")), etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::string<64>(STR("01111111")) == etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("0111111111111111")) == etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::string<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("10000000")), etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("1000000000000000")), etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("10000000000000000000000000000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::string<64>(STR("10000000")) == etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("1000000000000000")) == etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::string<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
}
//*************************************************************************
@ -196,25 +196,25 @@ namespace
{
etl::string<22> str;
CHECK_EQUAL(etl::string<22>(STR("000")), etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("000000")), etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("00000000000")), etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("0000000000000000000000")), etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::string<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("000000")) == etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::string<22>(STR("00000000000")) == etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("0000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("200")), etl::to_string(uint8_t(128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("100000")), etl::to_string(uint16_t(32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("20000000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("1000000000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::string<22>(STR("200")) == etl::to_string(uint8_t(128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("100000")) == etl::to_string(uint16_t(32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::string<22>(STR("20000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("1000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("177")), etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("077777")), etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("17777777777")), etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("0777777777777777777777")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::string<22>(STR("177")) == etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("077777")) == etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::string<22>(STR("17777777777")) == etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("200")), etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("100000")), etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("20000000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::string<22>(STR("1000000000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::string<22>(STR("200")) == etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("100000")) == etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::string<22>(STR("20000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
}
//*************************************************************************
@ -222,25 +222,25 @@ namespace
{
etl::string<16> str;
CHECK_EQUAL(etl::string<16>(STR("00")), etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("0000")), etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("00000000")), etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("0000000000000000")), etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::string<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("0000")) == etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::string<16>(STR("00000000")) == etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("0000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("80")), etl::to_string(uint8_t(128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("8000")), etl::to_string(uint16_t(32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("80000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("8000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::string<16>(STR("80")) == etl::to_string(uint8_t(128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("8000")) == etl::to_string(uint16_t(32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::string<16>(STR("80000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("8000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("7f")), etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("7fff")), etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("7fffffff")), etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("7fffffffffffffff")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::string<16>(STR("7f")) == etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("7fff")) == etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::string<16>(STR("7fffffff")) == etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("80")), etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("8000")), etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("80000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::string<16>(STR("8000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::string<16>(STR("80")) == etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("8000")) == etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::string<16>(STR("80000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("8000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
}
//*************************************************************************
@ -248,10 +248,10 @@ namespace
{
etl::string<17> str;
CHECK_EQUAL(etl::string<17>(STR("11110001001000000")), etl::to_string(123456, str, Format().binary()));
CHECK_EQUAL(etl::string<17>(STR("361100")), etl::to_string(123456, str, Format().octal()));
CHECK_EQUAL(etl::string<17>(STR("123456")), etl::to_string(123456, str, Format().decimal()));
CHECK_EQUAL(etl::string<17>(STR("1e240")), etl::to_string(123456, str, Format().hex()));
CHECK(etl::string<17>(STR("11110001001000000")) == etl::to_string(123456, str, Format().binary()));
CHECK(etl::string<17>(STR("361100")) == etl::to_string(123456, str, Format().octal()));
CHECK(etl::string<17>(STR("123456")) == etl::to_string(123456, str, Format().decimal()));
CHECK(etl::string<17>(STR("1e240")) == etl::to_string(123456, str, Format().hex()));
}
//*************************************************************************
@ -259,23 +259,23 @@ namespace
{
etl::string<20> str;
CHECK_EQUAL(etl::string<20>(STR(" 0.000000")), etl::to_string(0.0, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::string<20>(STR("0.000000 ")), etl::to_string(0.0, str, Format().precision(6).width(10).left()));
CHECK(etl::string<20>(STR(" 0.000000")) == etl::to_string(0.0, str, Format().precision(6).width(10).right()));
CHECK(etl::string<20>(STR("0.000000 ")) == etl::to_string(0.0, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::string<20>(STR(" 0.000001")), etl::to_string(0.000001, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::string<20>(STR("0.000001 ")), etl::to_string(0.000001, str, Format().precision(6).width(10).left()));
CHECK(etl::string<20>(STR(" 0.000001")) == etl::to_string(0.000001, str, Format().precision(6).width(10).right()));
CHECK(etl::string<20>(STR("0.000001 ")) == etl::to_string(0.000001, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::string<20>(STR(" 1.000000")), etl::to_string(1.0, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::string<20>(STR("1.000000 ")), etl::to_string(1.0, str, Format().precision(6).width(10).left()));
CHECK(etl::string<20>(STR(" 1.000000")) == etl::to_string(1.0, str, Format().precision(6).width(10).right()));
CHECK(etl::string<20>(STR("1.000000 ")) == etl::to_string(1.0, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::string<20>(STR(" 1.000001")), etl::to_string(1.000001, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::string<20>(STR("1.000001 ")), etl::to_string(1.000001, str, Format().precision(6).width(10).left()));
CHECK(etl::string<20>(STR(" 1.000001")) == etl::to_string(1.000001, str, Format().precision(6).width(10).right()));
CHECK(etl::string<20>(STR("1.000001 ")) == etl::to_string(1.000001, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::string<20>(STR(" 12.345678")), etl::to_string(12.345678, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::string<20>(STR("12.345678 ")), etl::to_string(12.345678, str, Format().precision(6).width(10).left()));
CHECK(etl::string<20>(STR(" 12.345678")) == etl::to_string(12.345678, str, Format().precision(6).width(10).right()));
CHECK(etl::string<20>(STR("12.345678 ")) == etl::to_string(12.345678, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::string<20>(STR(" -12.345678")), etl::to_string(-12.345678, str, Format().precision(6).width(11).right()));
CHECK_EQUAL(etl::string<20>(STR("-12.345678 ")), etl::to_string(-12.345678, str, Format().precision(6).width(11).left()));
CHECK(etl::string<20>(STR(" -12.345678")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).right()));
CHECK(etl::string<20>(STR("-12.345678 ")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).left()));
}
//*************************************************************************
@ -284,16 +284,16 @@ namespace
etl::string<20> str;
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result 12.345678")), etl::to_string(12.345678, str, Format().precision(6).width(10).right(), true));
CHECK(etl::string<20>(STR("Result 12.345678")) == etl::to_string(12.345678, str, Format().precision(6).width(10).right(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result 12.345678 ")), etl::to_string(12.345678, str, Format().precision(6).width(10).left(), true));
CHECK(etl::string<20>(STR("Result 12.345678 ")) == etl::to_string(12.345678, str, Format().precision(6).width(10).left(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result -12.345678")), etl::to_string(-12.345678, str, Format().precision(6).width(11).right(), true));
CHECK(etl::string<20>(STR("Result -12.345678")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).right(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result -12.345678 ")), etl::to_string(-12.345678, str, Format().precision(6).width(11).left(), true));
CHECK(etl::string<20>(STR("Result -12.345678 ")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).left(), true));
}
//*************************************************************************
@ -301,16 +301,16 @@ namespace
{
etl::string<20> str;
CHECK_EQUAL(etl::string<20>(STR("0.00001")), etl::to_string(0.000009, str, Format().precision(5).width(7).right()));
CHECK_EQUAL(etl::string<20>(STR("0.0001")), etl::to_string(0.000099, str, Format().precision(4).width(6).right()));
CHECK_EQUAL(etl::string<20>(STR("0.001")), etl::to_string(0.000999, str, Format().precision(3).width(5).right()));
CHECK_EQUAL(etl::string<20>(STR("0.01")), etl::to_string(0.009999, str, Format().precision(2).width(4).right()));
CHECK_EQUAL(etl::string<20>(STR("0.1")), etl::to_string(0.099999, str, Format().precision(1).width(3).right()));
CHECK_EQUAL(etl::string<20>(STR("1.0")), etl::to_string(0.999999, str, Format().precision(1).width(3).right()));
CHECK_EQUAL(etl::string<20>(STR("1")), etl::to_string(0.999999, str, Format().precision(0).width(1).right()));
CHECK_EQUAL(etl::string<20>(STR("2")), etl::to_string(1.999999, str, Format().precision(0).width(1).right()));
CHECK_EQUAL(etl::string<20>(STR("10.0")), etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK_EQUAL(etl::string<20>(STR("20.0")), etl::to_string(19.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::string<20>(STR("0.00001")) == etl::to_string(0.000009, str, Format().precision(5).width(7).right()));
CHECK(etl::string<20>(STR("0.0001")) == etl::to_string(0.000099, str, Format().precision(4).width(6).right()));
CHECK(etl::string<20>(STR("0.001")) == etl::to_string(0.000999, str, Format().precision(3).width(5).right()));
CHECK(etl::string<20>(STR("0.01")) == etl::to_string(0.009999, str, Format().precision(2).width(4).right()));
CHECK(etl::string<20>(STR("0.1")) == etl::to_string(0.099999, str, Format().precision(1).width(3).right()));
CHECK(etl::string<20>(STR("1.0")) == etl::to_string(0.999999, str, Format().precision(1).width(3).right()));
CHECK(etl::string<20>(STR("1")) == etl::to_string(0.999999, str, Format().precision(0).width(1).right()));
CHECK(etl::string<20>(STR("2")) == etl::to_string(1.999999, str, Format().precision(0).width(1).right()));
CHECK(etl::string<20>(STR("10.0")) == etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::string<20>(STR("20.0")) == etl::to_string(19.999999, str, Format().precision(1).width(4).right()));
}
//*************************************************************************
@ -318,15 +318,15 @@ namespace
{
etl::string<20> str;
CHECK_EQUAL(etl::string<20>(STR(" 0")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK_EQUAL(etl::string<20>(STR(" 1")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK_EQUAL(etl::string<20>(STR("0 ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK_EQUAL(etl::string<20>(STR("1 ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK(etl::string<20>(STR(" 0")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK(etl::string<20>(STR(" 1")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK(etl::string<20>(STR("0 ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK(etl::string<20>(STR("1 ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK_EQUAL(etl::string<20>(STR(" false")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK_EQUAL(etl::string<20>(STR(" true")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK_EQUAL(etl::string<20>(STR("false ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK_EQUAL(etl::string<20>(STR("true ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK(etl::string<20>(STR(" false")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK(etl::string<20>(STR(" true")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK(etl::string<20>(STR("false ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK(etl::string<20>(STR("true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true)));
}
//*************************************************************************
@ -335,28 +335,28 @@ namespace
etl::string<20> str;
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result 0")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(false), true));
CHECK(etl::string<20>(STR("Result 0")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result 1")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(false), true));
CHECK(etl::string<20>(STR("Result 1")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result 0 ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(false), true));
CHECK(etl::string<20>(STR("Result 0 ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result 1 ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(false), true));
CHECK(etl::string<20>(STR("Result 1 ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result false")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(true), true));
CHECK(etl::string<20>(STR("Result false")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result true")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(true), true));
CHECK(etl::string<20>(STR("Result true")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result false ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(true), true));
CHECK(etl::string<20>(STR("Result false ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::string<20>(STR("Result true ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
CHECK(etl::string<20>(STR("Result true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
}
//*************************************************************************
@ -374,7 +374,7 @@ namespace
etl::string<20> compare(temp.begin(), temp.end());
to_string(&cvi, str, Format().hex().width(10).right().fill(STR('0')));
CHECK_EQUAL(compare, str);
CHECK(compare == str);
oss.clear();
oss.str(STR(""));
@ -385,7 +385,7 @@ namespace
compare.assign(temp.begin(), temp.end());
to_string(&cvi, str, Format().hex().width(10).left().fill(STR('0')));
CHECK_EQUAL(compare, str);
CHECK(compare == str);
}
//*************************************************************************
@ -405,7 +405,7 @@ namespace
str.assign(STR("Result "));
to_string(&cvi, str, Format().hex().width(10).right().fill(STR('0')), true);
CHECK_EQUAL(compare, str);
CHECK(compare == str);
oss.clear();
oss.str(STR(""));
@ -418,7 +418,7 @@ namespace
str.assign(STR("Result "));
to_string(&cvi, str, Format().hex().width(10).left().fill(STR('0')), true);
CHECK_EQUAL(compare, str);
CHECK(compare == str);
}
};
}

316
test/test_to_u16string.cpp
View File

@ -56,25 +56,25 @@ namespace
{
etl::u16string<20> str;
CHECK_EQUAL(etl::u16string<20>(STR("0")), etl::to_string(uint8_t(0), str));
CHECK_EQUAL(etl::u16string<20>(STR("0")), etl::to_string(uint16_t(0), str));
CHECK_EQUAL(etl::u16string<20>(STR("0")), etl::to_string(uint32_t(0), str));
CHECK_EQUAL(etl::u16string<20>(STR("0")), etl::to_string(uint64_t(0), str));
CHECK(etl::u16string<20>(STR("0")) == etl::to_string(uint8_t(0), str));
CHECK(etl::u16string<20>(STR("0")) == etl::to_string(uint16_t(0), str));
CHECK(etl::u16string<20>(STR("0")) == etl::to_string(uint32_t(0), str));
CHECK(etl::u16string<20>(STR("0")) == etl::to_string(uint64_t(0), str));
CHECK_EQUAL(etl::u16string<20>(STR("128")), etl::to_string(uint8_t(128), str));
CHECK_EQUAL(etl::u16string<20>(STR("32768")), etl::to_string(uint16_t(32768), str));
CHECK_EQUAL(etl::u16string<20>(STR("2147483648")), etl::to_string(uint32_t(2147483648ul), str));
CHECK_EQUAL(etl::u16string<20>(STR("9223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK(etl::u16string<20>(STR("128")) == etl::to_string(uint8_t(128), str));
CHECK(etl::u16string<20>(STR("32768")) == etl::to_string(uint16_t(32768), str));
CHECK(etl::u16string<20>(STR("2147483648")) == etl::to_string(uint32_t(2147483648ul), str));
CHECK(etl::u16string<20>(STR("9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK_EQUAL(etl::u16string<20>(STR("127")), etl::to_string(int8_t(127), str));
CHECK_EQUAL(etl::u16string<20>(STR("32767")), etl::to_string(int16_t(32767), str));
CHECK_EQUAL(etl::u16string<20>(STR("2147483647")), etl::to_string(int32_t(2147483647ll), str));
CHECK_EQUAL(etl::u16string<20>(STR("9223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str));
CHECK(etl::u16string<20>(STR("127")) == etl::to_string(int8_t(127), str));
CHECK(etl::u16string<20>(STR("32767")) == etl::to_string(int16_t(32767), str));
CHECK(etl::u16string<20>(STR("2147483647")) == etl::to_string(int32_t(2147483647ll), str));
CHECK(etl::u16string<20>(STR("9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str));
CHECK_EQUAL(etl::u16string<20>(STR("-128")), etl::to_string(int8_t(-128), str));
CHECK_EQUAL(etl::u16string<20>(STR("-32768")), etl::to_string(int16_t(-32768), str));
CHECK_EQUAL(etl::u16string<20>(STR("-2147483648")), etl::to_string(int32_t(-2147483648ll), str));
CHECK_EQUAL(etl::u16string<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str));
CHECK(etl::u16string<20>(STR("-128")) == etl::to_string(int8_t(-128), str));
CHECK(etl::u16string<20>(STR("-32768")) == etl::to_string(int16_t(-32768), str));
CHECK(etl::u16string<20>(STR("-2147483648")) == etl::to_string(int32_t(-2147483648ll), str));
CHECK(etl::u16string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str));
}
//*************************************************************************
@ -82,25 +82,25 @@ namespace
{
etl::u16string<120> str;
CHECK_EQUAL(etl::u16string<120>(STR("0")), etl::to_string(uint8_t(0), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("00")), etl::to_string(uint16_t(0), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("000")), etl::to_string(uint32_t(0), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("0000")), etl::to_string(uint64_t(0), str, true));
CHECK(etl::u16string<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::u16string<120>(STR("00")) == etl::to_string(uint16_t(0), str, true));
CHECK(etl::u16string<120>(STR("000")) == etl::to_string(uint32_t(0), str, true));
CHECK(etl::u16string<120>(STR("0000")) == etl::to_string(uint64_t(0), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("0000128")), etl::to_string(uint8_t(128), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("000012832768")), etl::to_string(uint16_t(32768), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("0000128327682147483648")), etl::to_string(uint32_t(2147483648ul), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("00001283276821474836489223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK(etl::u16string<120>(STR("0000128")) == etl::to_string(uint8_t(128), str, true));
CHECK(etl::u16string<120>(STR("000012832768")) == etl::to_string(uint16_t(32768), str, true));
CHECK(etl::u16string<120>(STR("0000128327682147483648")) == etl::to_string(uint32_t(2147483648ul), str, true));
CHECK(etl::u16string<120>(STR("00001283276821474836489223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("00001283276821474836489223372036854775808127")), etl::to_string(int8_t(127), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("0000128327682147483648922337203685477580812732767")), etl::to_string(int16_t(32767), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("00001283276821474836489223372036854775808127327672147483647")), etl::to_string(int32_t(2147483647ll), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK(etl::u16string<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(127), str, true));
CHECK(etl::u16string<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(32767), str, true));
CHECK(etl::u16string<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(2147483647ll), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")), etl::to_string(int8_t(-128), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")), etl::to_string(int16_t(-32768), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")), etl::to_string(int32_t(-2147483648ll), str, true));
CHECK_EQUAL(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(-128), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(-32768), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
}
//*************************************************************************
@ -110,25 +110,25 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#'));
CHECK_EQUAL(etl::u16string<20>(STR("###################0")), etl::to_string(uint8_t(0), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("###################0")), etl::to_string(uint16_t(0), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("###################0")), etl::to_string(uint32_t(0), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("###################0")), etl::to_string(uint64_t(0), str, format));
CHECK(etl::u16string<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u16string<20>(STR("###################0")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::u16string<20>(STR("###################0")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::u16string<20>(STR("###################0")) == etl::to_string(uint64_t(0), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("#################128")), etl::to_string(uint8_t(128), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("###############32768")), etl::to_string(uint16_t(32768), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("##########2147483648")), etl::to_string(uint32_t(2147483648ul), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("#9223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::u16string<20>(STR("#################128")) == etl::to_string(uint8_t(128), str, format));
CHECK(etl::u16string<20>(STR("###############32768")) == etl::to_string(uint16_t(32768), str, format));
CHECK(etl::u16string<20>(STR("##########2147483648")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::u16string<20>(STR("#9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("#################127")), etl::to_string(int8_t(127), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("###############32767")), etl::to_string(int16_t(32767), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("##########2147483647")), etl::to_string(int32_t(2147483647ll), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("#9223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::u16string<20>(STR("#################127")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::u16string<20>(STR("###############32767")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::u16string<20>(STR("##########2147483647")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::u16string<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("################-128")), etl::to_string(int8_t(-128), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("##############-32768")), etl::to_string(int16_t(-32768), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("#########-2147483648")), etl::to_string(int32_t(-2147483648ll), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::u16string<20>(STR("################-128")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::u16string<20>(STR("##############-32768")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::u16string<20>(STR("#########-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::u16string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
}
//*************************************************************************
@ -138,25 +138,25 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#')).left();
CHECK_EQUAL(etl::u16string<20>(STR("0###################")), etl::to_string(uint8_t(0), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("0###################")), etl::to_string(uint16_t(0), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("0###################")), etl::to_string(uint32_t(0), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("0###################")), etl::to_string(uint64_t(0), str, format));
CHECK(etl::u16string<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u16string<20>(STR("0###################")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::u16string<20>(STR("0###################")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::u16string<20>(STR("0###################")) == etl::to_string(uint64_t(0), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("128#################")), etl::to_string(uint8_t(128), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("32768###############")), etl::to_string(uint16_t(32768), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("2147483648##########")), etl::to_string(uint32_t(2147483648ul), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("9223372036854775808#")), etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::u16string<20>(STR("128#################")) == etl::to_string(uint8_t(128), str, format));
CHECK(etl::u16string<20>(STR("32768###############")) == etl::to_string(uint16_t(32768), str, format));
CHECK(etl::u16string<20>(STR("2147483648##########")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::u16string<20>(STR("9223372036854775808#")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("127#################")), etl::to_string(int8_t(127), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("32767###############")), etl::to_string(int16_t(32767), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("2147483647##########")), etl::to_string(int32_t(2147483647ll), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("9223372036854775807#")), etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::u16string<20>(STR("127#################")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::u16string<20>(STR("32767###############")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::u16string<20>(STR("2147483647##########")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::u16string<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("-128################")), etl::to_string(int8_t(-128), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("-32768##############")), etl::to_string(int16_t(-32768), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("-2147483648#########")), etl::to_string(int32_t(-2147483648ll), str, format));
CHECK_EQUAL(etl::u16string<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::u16string<20>(STR("-128################")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::u16string<20>(STR("-32768##############")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::u16string<20>(STR("-2147483648#########")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::u16string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
}
//*************************************************************************
@ -164,25 +164,25 @@ namespace
{
etl::u16string<64> str;
CHECK_EQUAL(etl::u16string<64>(STR("00000000")), etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("0000000000000000")), etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("00000000000000000000000000000000")), etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0000000000000000")) == etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("00000000000000000000000000000000")) == etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("10000000")), etl::to_string(uint8_t(128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("1000000000000000")), etl::to_string(uint16_t(32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("10000000000000000000000000000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("10000000")) == etl::to_string(uint8_t(128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("1000000000000000")) == etl::to_string(uint16_t(32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("10000000000000000000000000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("01111111")), etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("0111111111111111")), etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("01111111111111111111111111111111")), etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("01111111")) == etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0111111111111111")) == etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("10000000")), etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("1000000000000000")), etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("10000000000000000000000000000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("10000000")) == etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("1000000000000000")) == etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
}
//*************************************************************************
@ -190,25 +190,25 @@ namespace
{
etl::u16string<22> str;
CHECK_EQUAL(etl::u16string<22>(STR("000")), etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("000000")), etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("00000000000")), etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("0000000000000000000000")), etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("000000")) == etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("00000000000")) == etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("0000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("200")), etl::to_string(uint8_t(128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("100000")), etl::to_string(uint16_t(32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("20000000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("1000000000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("200")) == etl::to_string(uint8_t(128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("100000")) == etl::to_string(uint16_t(32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("20000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("1000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("177")), etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("077777")), etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("17777777777")), etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("0777777777777777777777")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("177")) == etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("077777")) == etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("17777777777")) == etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("200")), etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("100000")), etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("20000000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<22>(STR("1000000000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("200")) == etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("100000")) == etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("20000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
}
//*************************************************************************
@ -216,25 +216,25 @@ namespace
{
etl::u16string<16> str;
CHECK_EQUAL(etl::u16string<16>(STR("00")), etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("0000")), etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("00000000")), etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("0000000000000000")), etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("0000")) == etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("00000000")) == etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("0000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("80")), etl::to_string(uint8_t(128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("8000")), etl::to_string(uint16_t(32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("80000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("8000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("80")) == etl::to_string(uint8_t(128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("8000")) == etl::to_string(uint16_t(32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("80000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("8000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("7f")), etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("7fff")), etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("7fffffff")), etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("7fffffffffffffff")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7f")) == etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7fff")) == etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7fffffff")) == etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("80")), etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("8000")), etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("80000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u16string<16>(STR("8000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("80")) == etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("8000")) == etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("80000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("8000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
}
//*************************************************************************
@ -242,10 +242,10 @@ namespace
{
etl::u16string<17> str;
CHECK_EQUAL(etl::u16string<17>(STR("11110001001000000")), etl::to_string(123456, str, Format().binary()));
CHECK_EQUAL(etl::u16string<17>(STR("361100")), etl::to_string(123456, str, Format().octal()));
CHECK_EQUAL(etl::u16string<17>(STR("123456")), etl::to_string(123456, str, Format().decimal()));
CHECK_EQUAL(etl::u16string<17>(STR("1e240")), etl::to_string(123456, str, Format().hex()));
CHECK(etl::u16string<17>(STR("11110001001000000")) == etl::to_string(123456, str, Format().binary()));
CHECK(etl::u16string<17>(STR("361100")) == etl::to_string(123456, str, Format().octal()));
CHECK(etl::u16string<17>(STR("123456")) == etl::to_string(123456, str, Format().decimal()));
CHECK(etl::u16string<17>(STR("1e240")) == etl::to_string(123456, str, Format().hex()));
}
//*************************************************************************
@ -253,23 +253,23 @@ namespace
{
etl::u16string<20> str;
CHECK_EQUAL(etl::u16string<20>(STR(" 0.000000")), etl::to_string(0.0, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u16string<20>(STR("0.000000 ")), etl::to_string(0.0, str, Format().precision(6).width(10).left()));
CHECK(etl::u16string<20>(STR(" 0.000000")) == etl::to_string(0.0, str, Format().precision(6).width(10).right()));
CHECK(etl::u16string<20>(STR("0.000000 ")) == etl::to_string(0.0, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u16string<20>(STR(" 0.000001")), etl::to_string(0.000001, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u16string<20>(STR("0.000001 ")), etl::to_string(0.000001, str, Format().precision(6).width(10).left()));
CHECK(etl::u16string<20>(STR(" 0.000001")) == etl::to_string(0.000001, str, Format().precision(6).width(10).right()));
CHECK(etl::u16string<20>(STR("0.000001 ")) == etl::to_string(0.000001, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u16string<20>(STR(" 1.000000")), etl::to_string(1.0, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u16string<20>(STR("1.000000 ")), etl::to_string(1.0, str, Format().precision(6).width(10).left()));
CHECK(etl::u16string<20>(STR(" 1.000000")) == etl::to_string(1.0, str, Format().precision(6).width(10).right()));
CHECK(etl::u16string<20>(STR("1.000000 ")) == etl::to_string(1.0, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u16string<20>(STR(" 1.000001")), etl::to_string(1.000001, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u16string<20>(STR("1.000001 ")), etl::to_string(1.000001, str, Format().precision(6).width(10).left()));
CHECK(etl::u16string<20>(STR(" 1.000001")) == etl::to_string(1.000001, str, Format().precision(6).width(10).right()));
CHECK(etl::u16string<20>(STR("1.000001 ")) == etl::to_string(1.000001, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u16string<20>(STR(" 12.345678")), etl::to_string(12.345678, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u16string<20>(STR("12.345678 ")), etl::to_string(12.345678, str, Format().precision(6).width(10).left()));
CHECK(etl::u16string<20>(STR(" 12.345678")) == etl::to_string(12.345678, str, Format().precision(6).width(10).right()));
CHECK(etl::u16string<20>(STR("12.345678 ")) == etl::to_string(12.345678, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u16string<20>(STR(" -12.345678")), etl::to_string(-12.345678, str, Format().precision(6).width(11).right()));
CHECK_EQUAL(etl::u16string<20>(STR("-12.345678 ")), etl::to_string(-12.345678, str, Format().precision(6).width(11).left()));
CHECK(etl::u16string<20>(STR(" -12.345678")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).right()));
CHECK(etl::u16string<20>(STR("-12.345678 ")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).left()));
}
//*************************************************************************
@ -278,16 +278,16 @@ namespace
etl::u16string<20> str;
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result 12.345678")), etl::to_string(12.345678, str, Format().precision(6).width(10).right(), true));
CHECK(etl::u16string<20>(STR("Result 12.345678")) == etl::to_string(12.345678, str, Format().precision(6).width(10).right(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result 12.345678 ")), etl::to_string(12.345678, str, Format().precision(6).width(10).left(), true));
CHECK(etl::u16string<20>(STR("Result 12.345678 ")) == etl::to_string(12.345678, str, Format().precision(6).width(10).left(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result -12.345678")), etl::to_string(-12.345678, str, Format().precision(6).width(11).right(), true));
CHECK(etl::u16string<20>(STR("Result -12.345678")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).right(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result -12.345678 ")), etl::to_string(-12.345678, str, Format().precision(6).width(11).left(), true));
CHECK(etl::u16string<20>(STR("Result -12.345678 ")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).left(), true));
}
//*************************************************************************
@ -295,16 +295,16 @@ namespace
{
etl::u16string<20> str;
CHECK_EQUAL(etl::u16string<20>(STR("0.00001")), etl::to_string(0.000009, str, Format().precision(5).width(7).right()));
CHECK_EQUAL(etl::u16string<20>(STR("0.0001")), etl::to_string(0.000099, str, Format().precision(4).width(6).right()));
CHECK_EQUAL(etl::u16string<20>(STR("0.001")), etl::to_string(0.000999, str, Format().precision(3).width(5).right()));
CHECK_EQUAL(etl::u16string<20>(STR("0.01")), etl::to_string(0.009999, str, Format().precision(2).width(4).right()));
CHECK_EQUAL(etl::u16string<20>(STR("0.1")), etl::to_string(0.099999, str, Format().precision(1).width(3).right()));
CHECK_EQUAL(etl::u16string<20>(STR("1.0")), etl::to_string(0.999999, str, Format().precision(1).width(3).right()));
CHECK_EQUAL(etl::u16string<20>(STR("1")), etl::to_string(0.999999, str, Format().precision(0).width(1).right()));
CHECK_EQUAL(etl::u16string<20>(STR("2")), etl::to_string(1.999999, str, Format().precision(0).width(1).right()));
CHECK_EQUAL(etl::u16string<20>(STR("10.0")), etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK_EQUAL(etl::u16string<20>(STR("20.0")), etl::to_string(19.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::u16string<20>(STR("0.00001")) == etl::to_string(0.000009, str, Format().precision(5).width(7).right()));
CHECK(etl::u16string<20>(STR("0.0001")) == etl::to_string(0.000099, str, Format().precision(4).width(6).right()));
CHECK(etl::u16string<20>(STR("0.001")) == etl::to_string(0.000999, str, Format().precision(3).width(5).right()));
CHECK(etl::u16string<20>(STR("0.01")) == etl::to_string(0.009999, str, Format().precision(2).width(4).right()));
CHECK(etl::u16string<20>(STR("0.1")) == etl::to_string(0.099999, str, Format().precision(1).width(3).right()));
CHECK(etl::u16string<20>(STR("1.0")) == etl::to_string(0.999999, str, Format().precision(1).width(3).right()));
CHECK(etl::u16string<20>(STR("1")) == etl::to_string(0.999999, str, Format().precision(0).width(1).right()));
CHECK(etl::u16string<20>(STR("2")) == etl::to_string(1.999999, str, Format().precision(0).width(1).right()));
CHECK(etl::u16string<20>(STR("10.0")) == etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::u16string<20>(STR("20.0")) == etl::to_string(19.999999, str, Format().precision(1).width(4).right()));
}
//*************************************************************************
@ -312,15 +312,15 @@ namespace
{
etl::u16string<20> str;
CHECK_EQUAL(etl::u16string<20>(STR(" 0")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK_EQUAL(etl::u16string<20>(STR(" 1")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK_EQUAL(etl::u16string<20>(STR("0 ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK_EQUAL(etl::u16string<20>(STR("1 ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK(etl::u16string<20>(STR(" 0")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK(etl::u16string<20>(STR(" 1")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK(etl::u16string<20>(STR("0 ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK(etl::u16string<20>(STR("1 ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK_EQUAL(etl::u16string<20>(STR(" false")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK_EQUAL(etl::u16string<20>(STR(" true")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK_EQUAL(etl::u16string<20>(STR("false ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK_EQUAL(etl::u16string<20>(STR("true ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK(etl::u16string<20>(STR(" false")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK(etl::u16string<20>(STR(" true")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK(etl::u16string<20>(STR("false ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK(etl::u16string<20>(STR("true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true)));
}
//*************************************************************************
@ -329,28 +329,28 @@ namespace
etl::u16string<20> str;
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result 0")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(false), true));
CHECK(etl::u16string<20>(STR("Result 0")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result 1")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(false), true));
CHECK(etl::u16string<20>(STR("Result 1")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result 0 ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(false), true));
CHECK(etl::u16string<20>(STR("Result 0 ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result 1 ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(false), true));
CHECK(etl::u16string<20>(STR("Result 1 ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result false")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(true), true));
CHECK(etl::u16string<20>(STR("Result false")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result true")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(true), true));
CHECK(etl::u16string<20>(STR("Result true")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result false ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(true), true));
CHECK(etl::u16string<20>(STR("Result false ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u16string<20>(STR("Result true ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
CHECK(etl::u16string<20>(STR("Result true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
}
};
}

318
test/test_to_u32string.cpp
View File

@ -58,25 +58,25 @@ namespace
{
etl::u32string<20> str;
CHECK_EQUAL(etl::u32string<20>(STR("0")), etl::to_string(uint8_t(0), str));
CHECK_EQUAL(etl::u32string<20>(STR("0")), etl::to_string(uint16_t(0), str));
CHECK_EQUAL(etl::u32string<20>(STR("0")), etl::to_string(uint32_t(0), str));
CHECK_EQUAL(etl::u32string<20>(STR("0")), etl::to_string(uint64_t(0), str));
CHECK(etl::u32string<20>(STR("0")) == etl::to_string(uint8_t(0), str));
CHECK(etl::u32string<20>(STR("0")) == etl::to_string(uint16_t(0), str));
CHECK(etl::u32string<20>(STR("0")) == etl::to_string(uint32_t(0), str));
CHECK(etl::u32string<20>(STR("0")) == etl::to_string(uint64_t(0), str));
CHECK_EQUAL(etl::u32string<20>(STR("128")), etl::to_string(uint8_t(128), str));
CHECK_EQUAL(etl::u32string<20>(STR("32768")), etl::to_string(uint16_t(32768), str));
CHECK_EQUAL(etl::u32string<20>(STR("2147483648")), etl::to_string(uint32_t(2147483648ul), str));
CHECK_EQUAL(etl::u32string<20>(STR("9223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK(etl::u32string<20>(STR("128")) == etl::to_string(uint8_t(128), str));
CHECK(etl::u32string<20>(STR("32768")) == etl::to_string(uint16_t(32768), str));
CHECK(etl::u32string<20>(STR("2147483648")) == etl::to_string(uint32_t(2147483648ul), str));
CHECK(etl::u32string<20>(STR("9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK_EQUAL(etl::u32string<20>(STR("127")), etl::to_string(int8_t(127), str));
CHECK_EQUAL(etl::u32string<20>(STR("32767")), etl::to_string(int16_t(32767), str));
CHECK_EQUAL(etl::u32string<20>(STR("2147483647")), etl::to_string(int32_t(2147483647ll), str));
CHECK_EQUAL(etl::u32string<20>(STR("9223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str));
CHECK(etl::u32string<20>(STR("127")) == etl::to_string(int8_t(127), str));
CHECK(etl::u32string<20>(STR("32767")) == etl::to_string(int16_t(32767), str));
CHECK(etl::u32string<20>(STR("2147483647")) == etl::to_string(int32_t(2147483647ll), str));
CHECK(etl::u32string<20>(STR("9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str));
CHECK_EQUAL(etl::u32string<20>(STR("-128")), etl::to_string(int8_t(-128), str));
CHECK_EQUAL(etl::u32string<20>(STR("-32768")), etl::to_string(int16_t(-32768), str));
CHECK_EQUAL(etl::u32string<20>(STR("-2147483648")), etl::to_string(int32_t(-2147483648ll), str));
CHECK_EQUAL(etl::u32string<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str));
CHECK(etl::u32string<20>(STR("-128")) == etl::to_string(int8_t(-128), str));
CHECK(etl::u32string<20>(STR("-32768")) == etl::to_string(int16_t(-32768), str));
CHECK(etl::u32string<20>(STR("-2147483648")) == etl::to_string(int32_t(-2147483648ll), str));
CHECK(etl::u32string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str));
}
//*************************************************************************
@ -84,25 +84,25 @@ namespace
{
etl::u32string<120> str;
CHECK_EQUAL(etl::u32string<120>(STR("0")), etl::to_string(uint8_t(0), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("00")), etl::to_string(uint16_t(0), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("000")), etl::to_string(uint32_t(0), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("0000")), etl::to_string(uint64_t(0), str, true));
CHECK(etl::u32string<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::u32string<120>(STR("00")) == etl::to_string(uint16_t(0), str, true));
CHECK(etl::u32string<120>(STR("000")) == etl::to_string(uint32_t(0), str, true));
CHECK(etl::u32string<120>(STR("0000")) == etl::to_string(uint64_t(0), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("0000128")), etl::to_string(uint8_t(128), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("000012832768")), etl::to_string(uint16_t(32768), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("0000128327682147483648")), etl::to_string(uint32_t(2147483648ul), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("00001283276821474836489223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK(etl::u32string<120>(STR("0000128")) == etl::to_string(uint8_t(128), str, true));
CHECK(etl::u32string<120>(STR("000012832768")) == etl::to_string(uint16_t(32768), str, true));
CHECK(etl::u32string<120>(STR("0000128327682147483648")) == etl::to_string(uint32_t(2147483648ul), str, true));
CHECK(etl::u32string<120>(STR("00001283276821474836489223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("00001283276821474836489223372036854775808127")), etl::to_string(int8_t(127), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("0000128327682147483648922337203685477580812732767")), etl::to_string(int16_t(32767), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("00001283276821474836489223372036854775808127327672147483647")), etl::to_string(int32_t(2147483647ll), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK(etl::u32string<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(127), str, true));
CHECK(etl::u32string<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(32767), str, true));
CHECK(etl::u32string<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(2147483647ll), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")), etl::to_string(int8_t(-128), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")), etl::to_string(int16_t(-32768), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")), etl::to_string(int32_t(-2147483648ll), str, true));
CHECK_EQUAL(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(-128), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(-32768), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
}
//*************************************************************************
@ -112,25 +112,25 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#'));
CHECK_EQUAL(etl::u32string<20>(STR("###################0")), etl::to_string(uint8_t(0), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("###################0")), etl::to_string(uint16_t(0), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("###################0")), etl::to_string(uint32_t(0), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("###################0")), etl::to_string(uint64_t(0), str, format));
CHECK(etl::u32string<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u32string<20>(STR("###################0")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::u32string<20>(STR("###################0")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::u32string<20>(STR("###################0")) == etl::to_string(uint64_t(0), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("#################128")), etl::to_string(uint8_t(128), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("###############32768")), etl::to_string(uint16_t(32768), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("##########2147483648")), etl::to_string(uint32_t(2147483648ul), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("#9223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::u32string<20>(STR("#################128")) == etl::to_string(uint8_t(128), str, format));
CHECK(etl::u32string<20>(STR("###############32768")) == etl::to_string(uint16_t(32768), str, format));
CHECK(etl::u32string<20>(STR("##########2147483648")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::u32string<20>(STR("#9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("#################127")), etl::to_string(int8_t(127), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("###############32767")), etl::to_string(int16_t(32767), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("##########2147483647")), etl::to_string(int32_t(2147483647ll), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("#9223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::u32string<20>(STR("#################127")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::u32string<20>(STR("###############32767")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::u32string<20>(STR("##########2147483647")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::u32string<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("################-128")), etl::to_string(int8_t(-128), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("##############-32768")), etl::to_string(int16_t(-32768), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("#########-2147483648")), etl::to_string(int32_t(-2147483648ll), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::u32string<20>(STR("################-128")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::u32string<20>(STR("##############-32768")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::u32string<20>(STR("#########-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::u32string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
}
//*************************************************************************
@ -140,25 +140,25 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#')).left();
CHECK_EQUAL(etl::u32string<20>(STR("0###################")), etl::to_string(uint8_t(0), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("0###################")), etl::to_string(uint16_t(0), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("0###################")), etl::to_string(uint32_t(0), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("0###################")), etl::to_string(uint64_t(0), str, format));
CHECK(etl::u32string<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u32string<20>(STR("0###################")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::u32string<20>(STR("0###################")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::u32string<20>(STR("0###################")) == etl::to_string(uint64_t(0), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("128#################")), etl::to_string(uint8_t(128), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("32768###############")), etl::to_string(uint16_t(32768), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("2147483648##########")), etl::to_string(uint32_t(2147483648ul), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("9223372036854775808#")), etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::u32string<20>(STR("128#################")) == etl::to_string(uint8_t(128), str, format));
CHECK(etl::u32string<20>(STR("32768###############")) == etl::to_string(uint16_t(32768), str, format));
CHECK(etl::u32string<20>(STR("2147483648##########")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::u32string<20>(STR("9223372036854775808#")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("127#################")), etl::to_string(int8_t(127), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("32767###############")), etl::to_string(int16_t(32767), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("2147483647##########")), etl::to_string(int32_t(2147483647ll), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("9223372036854775807#")), etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::u32string<20>(STR("127#################")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::u32string<20>(STR("32767###############")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::u32string<20>(STR("2147483647##########")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::u32string<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("-128################")), etl::to_string(int8_t(-128), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("-32768##############")), etl::to_string(int16_t(-32768), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("-2147483648#########")), etl::to_string(int32_t(-2147483648ll), str, format));
CHECK_EQUAL(etl::u32string<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::u32string<20>(STR("-128################")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::u32string<20>(STR("-32768##############")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::u32string<20>(STR("-2147483648#########")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::u32string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
}
//*************************************************************************
@ -166,25 +166,25 @@ namespace
{
etl::u32string<64> str;
CHECK_EQUAL(etl::u32string<64>(STR("00000000")), etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("0000000000000000")), etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("00000000000000000000000000000000")), etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0000000000000000")) == etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("00000000000000000000000000000000")) == etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("10000000")), etl::to_string(uint8_t(128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("1000000000000000")), etl::to_string(uint16_t(32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("10000000000000000000000000000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("10000000")) == etl::to_string(uint8_t(128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("1000000000000000")) == etl::to_string(uint16_t(32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("10000000000000000000000000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("01111111")), etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("0111111111111111")), etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("01111111111111111111111111111111")), etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("01111111")) == etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0111111111111111")) == etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("10000000")), etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("1000000000000000")), etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("10000000000000000000000000000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("10000000")) == etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("1000000000000000")) == etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
}
//*************************************************************************
@ -192,25 +192,25 @@ namespace
{
etl::u32string<22> str;
CHECK_EQUAL(etl::u32string<22>(STR("000")), etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("000000")), etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("00000000000")), etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("0000000000000000000000")), etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("000000")) == etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("00000000000")) == etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("0000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("200")), etl::to_string(uint8_t(128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("100000")), etl::to_string(uint16_t(32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("20000000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("1000000000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("200")) == etl::to_string(uint8_t(128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("100000")) == etl::to_string(uint16_t(32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("20000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("1000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("177")), etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("077777")), etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("17777777777")), etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("0777777777777777777777")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("177")) == etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("077777")) == etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("17777777777")) == etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("200")), etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("100000")), etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("20000000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<22>(STR("1000000000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("200")) == etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("100000")) == etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("20000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
}
//*************************************************************************
@ -218,25 +218,25 @@ namespace
{
etl::u32string<16> str;
CHECK_EQUAL(etl::u32string<16>(STR("00")), etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("0000")), etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("00000000")), etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("0000000000000000")), etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("0000")) == etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("00000000")) == etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("0000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("80")), etl::to_string(uint8_t(128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("8000")), etl::to_string(uint16_t(32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("80000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("8000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("80")) == etl::to_string(uint8_t(128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("8000")) == etl::to_string(uint16_t(32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("80000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("8000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("7f")), etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("7fff")), etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("7fffffff")), etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("7fffffffffffffff")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7f")) == etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7fff")) == etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7fffffff")) == etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("80")), etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("8000")), etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("80000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::u32string<16>(STR("8000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("80")) == etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("8000")) == etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("80000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("8000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
}
@ -245,10 +245,10 @@ namespace
{
etl::u32string<17> str;
CHECK_EQUAL(etl::u32string<17>(STR("11110001001000000")), etl::to_string(123456, str, Format().binary()));
CHECK_EQUAL(etl::u32string<17>(STR("361100")), etl::to_string(123456, str, Format().octal()));
CHECK_EQUAL(etl::u32string<17>(STR("123456")), etl::to_string(123456, str, Format().decimal()));
CHECK_EQUAL(etl::u32string<17>(STR("1e240")), etl::to_string(123456, str, Format().hex()));
CHECK(etl::u32string<17>(STR("11110001001000000")) == etl::to_string(123456, str, Format().binary()));
CHECK(etl::u32string<17>(STR("361100")) == etl::to_string(123456, str, Format().octal()));
CHECK(etl::u32string<17>(STR("123456")) == etl::to_string(123456, str, Format().decimal()));
CHECK(etl::u32string<17>(STR("1e240")) == etl::to_string(123456, str, Format().hex()));
}
//*************************************************************************
@ -256,23 +256,23 @@ namespace
{
etl::u32string<20> str;
CHECK_EQUAL(etl::u32string<20>(STR(" 0.000000")), etl::to_string(0.0, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u32string<20>(STR("0.000000 ")), etl::to_string(0.0, str, Format().precision(6).width(10).left()));
CHECK(etl::u32string<20>(STR(" 0.000000")) == etl::to_string(0.0, str, Format().precision(6).width(10).right()));
CHECK(etl::u32string<20>(STR("0.000000 ")) == etl::to_string(0.0, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u32string<20>(STR(" 0.000001")), etl::to_string(0.000001, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u32string<20>(STR("0.000001 ")), etl::to_string(0.000001, str, Format().precision(6).width(10).left()));
CHECK(etl::u32string<20>(STR(" 0.000001")) == etl::to_string(0.000001, str, Format().precision(6).width(10).right()));
CHECK(etl::u32string<20>(STR("0.000001 ")) == etl::to_string(0.000001, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u32string<20>(STR(" 1.000000")), etl::to_string(1.0, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u32string<20>(STR("1.000000 ")), etl::to_string(1.0, str, Format().precision(6).width(10).left()));
CHECK(etl::u32string<20>(STR(" 1.000000")) == etl::to_string(1.0, str, Format().precision(6).width(10).right()));
CHECK(etl::u32string<20>(STR("1.000000 ")) == etl::to_string(1.0, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u32string<20>(STR(" 1.000001")), etl::to_string(1.000001, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u32string<20>(STR("1.000001 ")), etl::to_string(1.000001, str, Format().precision(6).width(10).left()));
CHECK(etl::u32string<20>(STR(" 1.000001")) == etl::to_string(1.000001, str, Format().precision(6).width(10).right()));
CHECK(etl::u32string<20>(STR("1.000001 ")) == etl::to_string(1.000001, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u32string<20>(STR(" 12.345678")), etl::to_string(12.345678, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::u32string<20>(STR("12.345678 ")), etl::to_string(12.345678, str, Format().precision(6).width(10).left()));
CHECK(etl::u32string<20>(STR(" 12.345678")) == etl::to_string(12.345678, str, Format().precision(6).width(10).right()));
CHECK(etl::u32string<20>(STR("12.345678 ")) == etl::to_string(12.345678, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::u32string<20>(STR(" -12.345678")), etl::to_string(-12.345678, str, Format().precision(6).width(11).right()));
CHECK_EQUAL(etl::u32string<20>(STR("-12.345678 ")), etl::to_string(-12.345678, str, Format().precision(6).width(11).left()));
CHECK(etl::u32string<20>(STR(" -12.345678")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).right()));
CHECK(etl::u32string<20>(STR("-12.345678 ")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).left()));
}
//*************************************************************************
@ -281,16 +281,16 @@ namespace
etl::u32string<20> str;
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result 12.345678")), etl::to_string(12.345678, str, Format().precision(6).width(10).right(), true));
CHECK(etl::u32string<20>(STR("Result 12.345678")) == etl::to_string(12.345678, str, Format().precision(6).width(10).right(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result 12.345678 ")), etl::to_string(12.345678, str, Format().precision(6).width(10).left(), true));
CHECK(etl::u32string<20>(STR("Result 12.345678 ")) == etl::to_string(12.345678, str, Format().precision(6).width(10).left(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result -12.345678")), etl::to_string(-12.345678, str, Format().precision(6).width(11).right(), true));
CHECK(etl::u32string<20>(STR("Result -12.345678")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).right(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result -12.345678 ")), etl::to_string(-12.345678, str, Format().precision(6).width(11).left(), true));
CHECK(etl::u32string<20>(STR("Result -12.345678 ")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).left(), true));
}
//*************************************************************************
@ -298,17 +298,17 @@ namespace
{
etl::u32string<20> str;
CHECK_EQUAL(etl::u32string<20>(STR("0.00001")), etl::to_string(0.000009, str, Format().precision(5).width(7).right()));
CHECK_EQUAL(etl::u32string<20>(STR("0.0001")), etl::to_string(0.000099, str, Format().precision(4).width(6).right()));
CHECK_EQUAL(etl::u32string<20>(STR("0.001")), etl::to_string(0.000999, str, Format().precision(3).width(5).right()));
CHECK_EQUAL(etl::u32string<20>(STR("0.01")), etl::to_string(0.009999, str, Format().precision(2).width(4).right()));
CHECK_EQUAL(etl::u32string<20>(STR("0.1")), etl::to_string(0.099999, str, Format().precision(1).width(3).right()));
CHECK_EQUAL(etl::u32string<20>(STR("1.0")), etl::to_string(0.999999, str, Format().precision(1).width(3).right()));
CHECK_EQUAL(etl::u32string<20>(STR("1")), etl::to_string(0.999999, str, Format().precision(0).width(1).right()));
CHECK_EQUAL(etl::u32string<20>(STR("10.0")), etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK_EQUAL(etl::u32string<20>(STR("2")), etl::to_string(1.999999, str, Format().precision(0).width(1).right()));
CHECK_EQUAL(etl::u32string<20>(STR("10.0")), etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK_EQUAL(etl::u32string<20>(STR("20.0")), etl::to_string(19.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::u32string<20>(STR("0.00001")) == etl::to_string(0.000009, str, Format().precision(5).width(7).right()));
CHECK(etl::u32string<20>(STR("0.0001")) == etl::to_string(0.000099, str, Format().precision(4).width(6).right()));
CHECK(etl::u32string<20>(STR("0.001")) == etl::to_string(0.000999, str, Format().precision(3).width(5).right()));
CHECK(etl::u32string<20>(STR("0.01")) == etl::to_string(0.009999, str, Format().precision(2).width(4).right()));
CHECK(etl::u32string<20>(STR("0.1")) == etl::to_string(0.099999, str, Format().precision(1).width(3).right()));
CHECK(etl::u32string<20>(STR("1.0")) == etl::to_string(0.999999, str, Format().precision(1).width(3).right()));
CHECK(etl::u32string<20>(STR("1")) == etl::to_string(0.999999, str, Format().precision(0).width(1).right()));
CHECK(etl::u32string<20>(STR("10.0")) == etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::u32string<20>(STR("2")) == etl::to_string(1.999999, str, Format().precision(0).width(1).right()));
CHECK(etl::u32string<20>(STR("10.0")) == etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::u32string<20>(STR("20.0")) == etl::to_string(19.999999, str, Format().precision(1).width(4).right()));
}
@ -317,15 +317,15 @@ namespace
{
etl::u32string<20> str;
CHECK_EQUAL(etl::u32string<20>(STR(" 0")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK_EQUAL(etl::u32string<20>(STR(" 1")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK_EQUAL(etl::u32string<20>(STR("0 ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK_EQUAL(etl::u32string<20>(STR("1 ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK(etl::u32string<20>(STR(" 0")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK(etl::u32string<20>(STR(" 1")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK(etl::u32string<20>(STR("0 ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK(etl::u32string<20>(STR("1 ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK_EQUAL(etl::u32string<20>(STR(" false")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK_EQUAL(etl::u32string<20>(STR(" true")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK_EQUAL(etl::u32string<20>(STR("false ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK_EQUAL(etl::u32string<20>(STR("true ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK(etl::u32string<20>(STR(" false")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK(etl::u32string<20>(STR(" true")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK(etl::u32string<20>(STR("false ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK(etl::u32string<20>(STR("true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true)));
}
//*************************************************************************
@ -334,28 +334,28 @@ namespace
etl::u32string<20> str;
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result 0")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(false), true));
CHECK(etl::u32string<20>(STR("Result 0")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result 1")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(false), true));
CHECK(etl::u32string<20>(STR("Result 1")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result 0 ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(false), true));
CHECK(etl::u32string<20>(STR("Result 0 ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result 1 ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(false), true));
CHECK(etl::u32string<20>(STR("Result 1 ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result false")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(true), true));
CHECK(etl::u32string<20>(STR("Result false")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result true")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(true), true));
CHECK(etl::u32string<20>(STR("Result true")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result false ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(true), true));
CHECK(etl::u32string<20>(STR("Result false ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::u32string<20>(STR("Result true ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
CHECK(etl::u32string<20>(STR("Result true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
}
};
}

326
test/test_to_wstring.cpp
View File

@ -60,25 +60,25 @@ namespace
{
etl::wstring<20> str;
CHECK_EQUAL(etl::wstring<20>(STR("0")), etl::to_string(uint8_t(0), str));
CHECK_EQUAL(etl::wstring<20>(STR("0")), etl::to_string(uint16_t(0), str));
CHECK_EQUAL(etl::wstring<20>(STR("0")), etl::to_string(uint32_t(0), str));
CHECK_EQUAL(etl::wstring<20>(STR("0")), etl::to_string(uint64_t(0), str));
CHECK(etl::wstring<20>(STR("0")) == etl::to_string(uint8_t(0), str));
CHECK(etl::wstring<20>(STR("0")) == etl::to_string(uint16_t(0), str));
CHECK(etl::wstring<20>(STR("0")) == etl::to_string(uint32_t(0), str));
CHECK(etl::wstring<20>(STR("0")) == etl::to_string(uint64_t(0), str));
CHECK_EQUAL(etl::wstring<20>(STR("128")), etl::to_string(uint8_t(128), str));
CHECK_EQUAL(etl::wstring<20>(STR("32768")), etl::to_string(uint16_t(32768), str));
CHECK_EQUAL(etl::wstring<20>(STR("2147483648")), etl::to_string(uint32_t(2147483648ul), str));
CHECK_EQUAL(etl::wstring<20>(STR("9223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK(etl::wstring<20>(STR("128")) == etl::to_string(uint8_t(128), str));
CHECK(etl::wstring<20>(STR("32768")) == etl::to_string(uint16_t(32768), str));
CHECK(etl::wstring<20>(STR("2147483648")) == etl::to_string(uint32_t(2147483648ul), str));
CHECK(etl::wstring<20>(STR("9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK_EQUAL(etl::wstring<20>(STR("127")), etl::to_string(int8_t(127), str));
CHECK_EQUAL(etl::wstring<20>(STR("32767")), etl::to_string(int16_t(32767), str));
CHECK_EQUAL(etl::wstring<20>(STR("2147483647")), etl::to_string(int32_t(2147483647ll), str));
CHECK_EQUAL(etl::wstring<20>(STR("9223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str));
CHECK(etl::wstring<20>(STR("127")) == etl::to_string(int8_t(127), str));
CHECK(etl::wstring<20>(STR("32767")) == etl::to_string(int16_t(32767), str));
CHECK(etl::wstring<20>(STR("2147483647")) == etl::to_string(int32_t(2147483647ll), str));
CHECK(etl::wstring<20>(STR("9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str));
CHECK_EQUAL(etl::wstring<20>(STR("-128")), etl::to_string(int8_t(-128), str));
CHECK_EQUAL(etl::wstring<20>(STR("-32768")), etl::to_string(int16_t(-32768), str));
CHECK_EQUAL(etl::wstring<20>(STR("-2147483648")), etl::to_string(int32_t(-2147483648ll), str));
CHECK_EQUAL(etl::wstring<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str));
CHECK(etl::wstring<20>(STR("-128")) == etl::to_string(int8_t(-128), str));
CHECK(etl::wstring<20>(STR("-32768")) == etl::to_string(int16_t(-32768), str));
CHECK(etl::wstring<20>(STR("-2147483648")) == etl::to_string(int32_t(-2147483648ll), str));
CHECK(etl::wstring<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str));
}
//*************************************************************************
@ -86,25 +86,25 @@ namespace
{
etl::wstring<120> str;
CHECK_EQUAL(etl::wstring<120>(STR("0")), etl::to_string(uint8_t(0), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("00")), etl::to_string(uint16_t(0), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("000")), etl::to_string(uint32_t(0), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("0000")), etl::to_string(uint64_t(0), str, true));
CHECK(etl::wstring<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::wstring<120>(STR("00")) == etl::to_string(uint16_t(0), str, true));
CHECK(etl::wstring<120>(STR("000")) == etl::to_string(uint32_t(0), str, true));
CHECK(etl::wstring<120>(STR("0000")) == etl::to_string(uint64_t(0), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("0000128")), etl::to_string(uint8_t(128), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("000012832768")), etl::to_string(uint16_t(32768), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("0000128327682147483648")), etl::to_string(uint32_t(2147483648ul), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("00001283276821474836489223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK(etl::wstring<120>(STR("0000128")) == etl::to_string(uint8_t(128), str, true));
CHECK(etl::wstring<120>(STR("000012832768")) == etl::to_string(uint16_t(32768), str, true));
CHECK(etl::wstring<120>(STR("0000128327682147483648")) == etl::to_string(uint32_t(2147483648ul), str, true));
CHECK(etl::wstring<120>(STR("00001283276821474836489223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("00001283276821474836489223372036854775808127")), etl::to_string(int8_t(127), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("0000128327682147483648922337203685477580812732767")), etl::to_string(int16_t(32767), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("00001283276821474836489223372036854775808127327672147483647")), etl::to_string(int32_t(2147483647ll), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK(etl::wstring<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(127), str, true));
CHECK(etl::wstring<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(32767), str, true));
CHECK(etl::wstring<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(2147483647ll), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")), etl::to_string(int8_t(-128), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")), etl::to_string(int16_t(-32768), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")), etl::to_string(int32_t(-2147483648ll), str, true));
CHECK_EQUAL(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(-128), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(-32768), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
}
//*************************************************************************
@ -114,25 +114,25 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#'));
CHECK_EQUAL(etl::wstring<20>(STR("###################0")), etl::to_string(uint8_t(0), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("###################0")), etl::to_string(uint16_t(0), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("###################0")), etl::to_string(uint32_t(0), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("###################0")), etl::to_string(uint64_t(0), str, format));
CHECK(etl::wstring<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::wstring<20>(STR("###################0")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::wstring<20>(STR("###################0")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::wstring<20>(STR("###################0")) == etl::to_string(uint64_t(0), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("#################128")), etl::to_string(uint8_t(128), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("###############32768")), etl::to_string(uint16_t(32768), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("##########2147483648")), etl::to_string(uint32_t(2147483648ul), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("#9223372036854775808")), etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::wstring<20>(STR("#################128")) == etl::to_string(uint8_t(128), str, format));
CHECK(etl::wstring<20>(STR("###############32768")) == etl::to_string(uint16_t(32768), str, format));
CHECK(etl::wstring<20>(STR("##########2147483648")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::wstring<20>(STR("#9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("#################127")), etl::to_string(int8_t(127), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("###############32767")), etl::to_string(int16_t(32767), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("##########2147483647")), etl::to_string(int32_t(2147483647ll), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("#9223372036854775807")), etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::wstring<20>(STR("#################127")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::wstring<20>(STR("###############32767")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::wstring<20>(STR("##########2147483647")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::wstring<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("################-128")), etl::to_string(int8_t(-128), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("##############-32768")), etl::to_string(int16_t(-32768), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("#########-2147483648")), etl::to_string(int32_t(-2147483648ll), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::wstring<20>(STR("################-128")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::wstring<20>(STR("##############-32768")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::wstring<20>(STR("#########-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::wstring<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
}
//*************************************************************************
@ -142,25 +142,25 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#')).left();
CHECK_EQUAL(etl::wstring<20>(STR("0###################")), etl::to_string(uint8_t(0), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("0###################")), etl::to_string(uint16_t(0), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("0###################")), etl::to_string(uint32_t(0), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("0###################")), etl::to_string(uint64_t(0), str, format));
CHECK(etl::wstring<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::wstring<20>(STR("0###################")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::wstring<20>(STR("0###################")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::wstring<20>(STR("0###################")) == etl::to_string(uint64_t(0), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("128#################")), etl::to_string(uint8_t(128), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("32768###############")), etl::to_string(uint16_t(32768), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("2147483648##########")), etl::to_string(uint32_t(2147483648ul), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("9223372036854775808#")), etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::wstring<20>(STR("128#################")) == etl::to_string(uint8_t(128), str, format));
CHECK(etl::wstring<20>(STR("32768###############")) == etl::to_string(uint16_t(32768), str, format));
CHECK(etl::wstring<20>(STR("2147483648##########")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::wstring<20>(STR("9223372036854775808#")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("127#################")), etl::to_string(int8_t(127), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("32767###############")), etl::to_string(int16_t(32767), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("2147483647##########")), etl::to_string(int32_t(2147483647ll), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("9223372036854775807#")), etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::wstring<20>(STR("127#################")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::wstring<20>(STR("32767###############")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::wstring<20>(STR("2147483647##########")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::wstring<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("-128################")), etl::to_string(int8_t(-128), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("-32768##############")), etl::to_string(int16_t(-32768), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("-2147483648#########")), etl::to_string(int32_t(-2147483648ll), str, format));
CHECK_EQUAL(etl::wstring<20>(STR("-9223372036854775808")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::wstring<20>(STR("-128################")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::wstring<20>(STR("-32768##############")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::wstring<20>(STR("-2147483648#########")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::wstring<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
}
//*************************************************************************
@ -168,25 +168,25 @@ namespace
{
etl::wstring<64> str;
CHECK_EQUAL(etl::wstring<64>(STR("00000000")), etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("0000000000000000")), etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("00000000000000000000000000000000")), etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0000000000000000")) == etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("00000000000000000000000000000000")) == etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("10000000")), etl::to_string(uint8_t(128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("1000000000000000")), etl::to_string(uint16_t(32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("10000000000000000000000000000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("10000000")) == etl::to_string(uint8_t(128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("1000000000000000")) == etl::to_string(uint16_t(32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("10000000000000000000000000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("01111111")), etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("0111111111111111")), etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("01111111111111111111111111111111")), etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("01111111")) == etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0111111111111111")) == etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("10000000")), etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("1000000000000000")), etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("10000000000000000000000000000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("10000000")) == etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("1000000000000000")) == etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
}
//*************************************************************************
@ -194,25 +194,25 @@ namespace
{
etl::wstring<22> str;
CHECK_EQUAL(etl::wstring<22>(STR("000")), etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("000000")), etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("00000000000")), etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("0000000000000000000000")), etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("000000")) == etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("00000000000")) == etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("0000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("200")), etl::to_string(uint8_t(128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("100000")), etl::to_string(uint16_t(32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("20000000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("1000000000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("200")) == etl::to_string(uint8_t(128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("100000")) == etl::to_string(uint16_t(32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("20000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("1000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("177")), etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("077777")), etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("17777777777")), etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("0777777777777777777777")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("177")) == etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("077777")) == etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("17777777777")) == etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("200")), etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("100000")), etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("20000000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<22>(STR("1000000000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("200")) == etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("100000")) == etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("20000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
}
//*************************************************************************
@ -220,25 +220,25 @@ namespace
{
etl::wstring<16> str;
CHECK_EQUAL(etl::wstring<16>(STR("00")), etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("0000")), etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("00000000")), etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("0000000000000000")), etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("0000")) == etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("00000000")) == etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("0000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("80")), etl::to_string(uint8_t(128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("8000")), etl::to_string(uint16_t(32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("80000000")), etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("8000000000000000")), etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("80")) == etl::to_string(uint8_t(128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("8000")) == etl::to_string(uint16_t(32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("80000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("8000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("7f")), etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("7fff")), etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("7fffffff")), etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("7fffffffffffffff")), etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7f")) == etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7fff")) == etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7fffffff")) == etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("80")), etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("8000")), etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("80000000")), etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK_EQUAL(etl::wstring<16>(STR("8000000000000000")), etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("80")) == etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("8000")) == etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("80000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("8000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
}
//*************************************************************************
@ -246,10 +246,10 @@ namespace
{
etl::wstring<17> str;
CHECK_EQUAL(etl::wstring<17>(STR("11110001001000000")), etl::to_string(123456, str, Format().binary()));
CHECK_EQUAL(etl::wstring<17>(STR("361100")), etl::to_string(123456, str, Format().octal()));
CHECK_EQUAL(etl::wstring<17>(STR("123456")), etl::to_string(123456, str, Format().decimal()));
CHECK_EQUAL(etl::wstring<17>(STR("1e240")), etl::to_string(123456, str, Format().hex()));
CHECK(etl::wstring<17>(STR("11110001001000000")) == etl::to_string(123456, str, Format().binary()));
CHECK(etl::wstring<17>(STR("361100")) == etl::to_string(123456, str, Format().octal()));
CHECK(etl::wstring<17>(STR("123456")) == etl::to_string(123456, str, Format().decimal()));
CHECK(etl::wstring<17>(STR("1e240")) == etl::to_string(123456, str, Format().hex()));
}
//*************************************************************************
@ -257,23 +257,23 @@ namespace
{
etl::wstring<20> str;
CHECK_EQUAL(etl::wstring<20>(STR(" 0.000000")), etl::to_string(0.0, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::wstring<20>(STR("0.000000 ")), etl::to_string(0.0, str, Format().precision(6).width(10).left()));
CHECK(etl::wstring<20>(STR(" 0.000000")) == etl::to_string(0.0, str, Format().precision(6).width(10).right()));
CHECK(etl::wstring<20>(STR("0.000000 ")) == etl::to_string(0.0, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::wstring<20>(STR(" 0.000001")), etl::to_string(0.000001, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::wstring<20>(STR("0.000001 ")), etl::to_string(0.000001, str, Format().precision(6).width(10).left()));
CHECK(etl::wstring<20>(STR(" 0.000001")) == etl::to_string(0.000001, str, Format().precision(6).width(10).right()));
CHECK(etl::wstring<20>(STR("0.000001 ")) == etl::to_string(0.000001, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::wstring<20>(STR(" 1.000000")), etl::to_string(1.0, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::wstring<20>(STR("1.000000 ")), etl::to_string(1.0, str, Format().precision(6).width(10).left()));
CHECK(etl::wstring<20>(STR(" 1.000000")) == etl::to_string(1.0, str, Format().precision(6).width(10).right()));
CHECK(etl::wstring<20>(STR("1.000000 ")) == etl::to_string(1.0, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::wstring<20>(STR(" 1.000001")), etl::to_string(1.000001, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::wstring<20>(STR("1.000001 ")), etl::to_string(1.000001, str, Format().precision(6).width(10).left()));
CHECK(etl::wstring<20>(STR(" 1.000001")) == etl::to_string(1.000001, str, Format().precision(6).width(10).right()));
CHECK(etl::wstring<20>(STR("1.000001 ")) == etl::to_string(1.000001, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::wstring<20>(STR(" 12.345678")), etl::to_string(12.345678, str, Format().precision(6).width(10).right()));
CHECK_EQUAL(etl::wstring<20>(STR("12.345678 ")), etl::to_string(12.345678, str, Format().precision(6).width(10).left()));
CHECK(etl::wstring<20>(STR(" 12.345678")) == etl::to_string(12.345678, str, Format().precision(6).width(10).right()));
CHECK(etl::wstring<20>(STR("12.345678 ")) == etl::to_string(12.345678, str, Format().precision(6).width(10).left()));
CHECK_EQUAL(etl::wstring<20>(STR(" -12.345678")), etl::to_string(-12.345678, str, Format().precision(6).width(11).right()));
CHECK_EQUAL(etl::wstring<20>(STR("-12.345678 ")), etl::to_string(-12.345678, str, Format().precision(6).width(11).left()));
CHECK(etl::wstring<20>(STR(" -12.345678")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).right()));
CHECK(etl::wstring<20>(STR("-12.345678 ")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).left()));
}
//*************************************************************************
@ -282,16 +282,16 @@ namespace
etl::wstring<20> str;
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result 12.345678")), etl::to_string(12.345678, str, Format().precision(6).width(10).right(), true));
CHECK(etl::wstring<20>(STR("Result 12.345678")) == etl::to_string(12.345678, str, Format().precision(6).width(10).right(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result 12.345678 ")), etl::to_string(12.345678, str, Format().precision(6).width(10).left(), true));
CHECK(etl::wstring<20>(STR("Result 12.345678 ")) == etl::to_string(12.345678, str, Format().precision(6).width(10).left(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result -12.345678")), etl::to_string(-12.345678, str, Format().precision(6).width(11).right(), true));
CHECK(etl::wstring<20>(STR("Result -12.345678")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).right(), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result -12.345678 ")), etl::to_string(-12.345678, str, Format().precision(6).width(11).left(), true));
CHECK(etl::wstring<20>(STR("Result -12.345678 ")) == etl::to_string(-12.345678, str, Format().precision(6).width(11).left(), true));
}
//*************************************************************************
@ -299,17 +299,17 @@ namespace
{
etl::wstring<20> str;
CHECK_EQUAL(etl::wstring<20>(STR("0.00001")), etl::to_string(0.000009, str, Format().precision(5).width(7).right()));
CHECK_EQUAL(etl::wstring<20>(STR("0.0001")), etl::to_string(0.000099, str, Format().precision(4).width(6).right()));
CHECK_EQUAL(etl::wstring<20>(STR("0.001")), etl::to_string(0.000999, str, Format().precision(3).width(5).right()));
CHECK_EQUAL(etl::wstring<20>(STR("0.01")), etl::to_string(0.009999, str, Format().precision(2).width(4).right()));
CHECK_EQUAL(etl::wstring<20>(STR("0.1")), etl::to_string(0.099999, str, Format().precision(1).width(3).right()));
CHECK_EQUAL(etl::wstring<20>(STR("1.0")), etl::to_string(0.999999, str, Format().precision(1).width(3).right()));
CHECK_EQUAL(etl::wstring<20>(STR("1")), etl::to_string(0.999999, str, Format().precision(0).width(1).right()));
CHECK_EQUAL(etl::wstring<20>(STR("10.0")), etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK_EQUAL(etl::wstring<20>(STR("2")), etl::to_string(1.999999, str, Format().precision(0).width(1).right()));
CHECK_EQUAL(etl::wstring<20>(STR("10.0")), etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK_EQUAL(etl::wstring<20>(STR("20.0")), etl::to_string(19.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::wstring<20>(STR("0.00001")) == etl::to_string(0.000009, str, Format().precision(5).width(7).right()));
CHECK(etl::wstring<20>(STR("0.0001")) == etl::to_string(0.000099, str, Format().precision(4).width(6).right()));
CHECK(etl::wstring<20>(STR("0.001")) == etl::to_string(0.000999, str, Format().precision(3).width(5).right()));
CHECK(etl::wstring<20>(STR("0.01")) == etl::to_string(0.009999, str, Format().precision(2).width(4).right()));
CHECK(etl::wstring<20>(STR("0.1")) == etl::to_string(0.099999, str, Format().precision(1).width(3).right()));
CHECK(etl::wstring<20>(STR("1.0")) == etl::to_string(0.999999, str, Format().precision(1).width(3).right()));
CHECK(etl::wstring<20>(STR("1")) == etl::to_string(0.999999, str, Format().precision(0).width(1).right()));
CHECK(etl::wstring<20>(STR("10.0")) == etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::wstring<20>(STR("2")) == etl::to_string(1.999999, str, Format().precision(0).width(1).right()));
CHECK(etl::wstring<20>(STR("10.0")) == etl::to_string(9.999999, str, Format().precision(1).width(4).right()));
CHECK(etl::wstring<20>(STR("20.0")) == etl::to_string(19.999999, str, Format().precision(1).width(4).right()));
}
//*************************************************************************
@ -317,15 +317,15 @@ namespace
{
etl::wstring<20> str;
CHECK_EQUAL(etl::wstring<20>(STR(" 0")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK_EQUAL(etl::wstring<20>(STR(" 1")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK_EQUAL(etl::wstring<20>(STR("0 ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK_EQUAL(etl::wstring<20>(STR("1 ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK(etl::wstring<20>(STR(" 0")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK(etl::wstring<20>(STR(" 1")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(false)));
CHECK(etl::wstring<20>(STR("0 ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK(etl::wstring<20>(STR("1 ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(false)));
CHECK_EQUAL(etl::wstring<20>(STR(" false")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK_EQUAL(etl::wstring<20>(STR(" true")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK_EQUAL(etl::wstring<20>(STR("false ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK_EQUAL(etl::wstring<20>(STR("true ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK(etl::wstring<20>(STR(" false")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK(etl::wstring<20>(STR(" true")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(true)));
CHECK(etl::wstring<20>(STR("false ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(true)));
CHECK(etl::wstring<20>(STR("true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true)));
}
//*************************************************************************
@ -334,28 +334,28 @@ namespace
etl::wstring<20> str;
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result 0")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(false), true));
CHECK(etl::wstring<20>(STR("Result 0")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result 1")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(false), true));
CHECK(etl::wstring<20>(STR("Result 1")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result 0 ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(false), true));
CHECK(etl::wstring<20>(STR("Result 0 ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result 1 ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(false), true));
CHECK(etl::wstring<20>(STR("Result 1 ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(false), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result false")), to_string(false, str, Format().precision(6).width(10).right().boolalpha(true), true));
CHECK(etl::wstring<20>(STR("Result false")) == to_string(false, str, Format().precision(6).width(10).right().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result true")), to_string(true, str, Format().precision(6).width(10).right().boolalpha(true), true));
CHECK(etl::wstring<20>(STR("Result true")) == to_string(true, str, Format().precision(6).width(10).right().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result false ")), to_string(false, str, Format().precision(6).width(10).left().boolalpha(true), true));
CHECK(etl::wstring<20>(STR("Result false ")) == to_string(false, str, Format().precision(6).width(10).left().boolalpha(true), true));
str.assign(STR("Result "));
CHECK_EQUAL(etl::wstring<20>(STR("Result true ")), to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
CHECK(etl::wstring<20>(STR("Result true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
}
//*************************************************************************
@ -373,7 +373,7 @@ namespace
etl::wstring<20> compare(temp.begin(), temp.end());
to_string(&cvi, str, Format().hex().width(10).right().fill(STR('0')));
CHECK_EQUAL(compare, str);
CHECK(compare == str);
oss.clear();
oss.str(STR(""));
@ -384,7 +384,7 @@ namespace
compare.assign(temp.begin(), temp.end());
to_string(&cvi, str, Format().hex().width(10).left().fill(STR('0')));
CHECK_EQUAL(compare, str);
CHECK(compare == str);
}
//*************************************************************************
@ -404,7 +404,7 @@ namespace
str.assign(STR("Result "));
to_string(&cvi, str, Format().hex().width(10).right().fill(STR('0')), true);
CHECK_EQUAL(compare, str);
CHECK(compare == str);
oss.clear();
oss.str(STR(""));
@ -417,7 +417,7 @@ namespace
str.assign(STR("Result "));
to_string(&cvi, str, Format().hex().width(10).left().fill(STR('0')), true);
CHECK_EQUAL(compare, str);
CHECK(compare == str);
}
};
}