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

Make code base with tests compile under gcc-14 (#1254)

Browse Source 
* Make code base with tests compile under gcc-14

* Update buffer_descriptors.h

Following the same style as non-tests headers have. E.g., include/etl/intrusive_list.h & include/etl/intrusive_forward_list.h

---------

Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>
This commit is contained in:
Bo Rydberg 2026-01-08 22:58:27 +01:00 committed by GitHub
parent 5b99aa50b3
commit f8ee5f450b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 142 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/etl/buffer_descriptors.h
View File

@ -99,7 +99,9 @@ namespace etl
pointer data() const
{
assert(pdesc_item != ETL_NULLPTR);
#include "private/diagnostic_null_dereference_push.h"
return pdesc_item->pbuffer;
#include "private/diagnostic_pop.h"
}
//*********************************

43
test/test_base64_RFC2152_decoder.cpp
View File

@ -379,15 +379,14 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -403,7 +402,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -411,7 +410,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -427,7 +426,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -452,7 +451,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -468,7 +467,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -493,7 +492,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -509,7 +508,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -517,7 +516,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -533,7 +532,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -541,7 +540,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -557,7 +556,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -582,7 +581,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -598,7 +597,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -639,7 +638,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -657,7 +656,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -673,7 +672,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -691,7 +690,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -707,7 +706,7 @@ namespace
{
codec_full_buffer b64;
for (size_t i = 4; i < 256; ++i)
for (size_t i = 4; i < input_data.size(); ++i)
{
b64.restart();
@ -729,7 +728,7 @@ namespace
b64.flush();
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(b64.begin(), b64.end());
#include "etl/private/diagnostic_pop.h"

47
test/test_base64_RFC3501_decoder.cpp
View File

@ -376,7 +376,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -384,7 +384,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -400,7 +400,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -408,7 +408,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -424,7 +424,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -449,7 +449,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -465,7 +465,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -490,7 +490,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -506,7 +506,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -514,7 +514,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -530,15 +530,15 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -554,7 +554,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -579,7 +579,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -595,7 +595,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -618,9 +618,9 @@ namespace
CHECK_FALSE(received_final_block);
b64.flush();
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -636,7 +636,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -654,7 +654,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -670,7 +670,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -704,7 +704,7 @@ namespace
{
codec_full_buffer b64;
for (size_t i = 4; i < 256; ++i)
for (size_t i = 4; i < input_data.size(); ++i)
{
b64.restart();
@ -725,8 +725,9 @@ namespace
b64.flush();
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(b64.begin(), b64.end());
#include "etl/private/diagnostic_pop.h"

44
test/test_base64_RFC4648_URL_decoder_with_no_padding.cpp
View File

@ -376,7 +376,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -384,7 +384,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -400,7 +400,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -408,7 +408,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -424,7 +424,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -449,7 +449,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -465,7 +465,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -490,7 +490,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -506,7 +506,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -514,7 +514,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -530,7 +530,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -538,7 +538,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -554,7 +554,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -579,7 +579,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -595,7 +595,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -620,7 +620,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -636,7 +636,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -654,7 +654,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -670,7 +670,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -688,7 +688,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -704,7 +704,7 @@ namespace
{
codec_full_buffer b64;
for (size_t i = 4; i < 256; ++i)
for (size_t i = 4; i < input_data.size(); ++i)
{
b64.restart();
@ -726,7 +726,7 @@ namespace
b64.flush();
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(b64.begin(), b64.end());
#include "etl/private/diagnostic_pop.h"

43
test/test_base64_RFC4648_URL_decoder_with_padding.cpp
View File

@ -376,7 +376,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -384,7 +384,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -400,7 +400,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -408,7 +408,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -424,7 +424,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -447,9 +447,9 @@ namespace
CHECK_FALSE(received_final_block);
b64.flush();
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -465,7 +465,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -490,7 +490,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -506,7 +506,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -514,7 +514,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -530,7 +530,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -554,7 +554,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -579,7 +579,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -595,7 +595,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -620,7 +620,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -636,7 +636,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -653,6 +653,7 @@ namespace
b64.flush();
CHECK_TRUE(received_final_block);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> actual(decoded_output);
@ -670,7 +671,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -688,7 +689,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -704,7 +705,7 @@ namespace
{
codec_full_buffer b64;
for (size_t i = 4; i < 256; ++i)
for (size_t i = 4; i < input_data.size(); ++i)
{
b64.restart();
@ -726,7 +727,7 @@ namespace
b64.flush();
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(b64.begin(), b64.end());
#include "etl/private/diagnostic_pop.h"

46
test/test_base64_RFC4648_decoder_with_no_padding.cpp
View File

@ -376,15 +376,15 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -400,7 +400,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -408,7 +408,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -424,7 +424,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -449,7 +449,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -465,7 +465,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -490,7 +490,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -506,7 +506,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -514,7 +514,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -530,7 +530,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -538,7 +538,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -554,7 +554,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -579,7 +579,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -595,7 +595,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -620,7 +620,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -636,7 +636,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -654,7 +654,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -670,7 +670,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -688,7 +688,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -704,7 +704,7 @@ namespace
{
codec_full_buffer b64;
for (size_t i = 4; i < 256; ++i)
for (size_t i = 4; i < input_data.size(); ++i)
{
b64.restart();
@ -726,7 +726,7 @@ namespace
b64.flush();
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(b64.begin(), b64.end());
#include "etl/private/diagnostic_pop.h"

44
test/test_base64_RFC4648_decoder_with_padding.cpp
View File

@ -376,7 +376,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -384,7 +384,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -400,7 +400,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -408,7 +408,7 @@ namespace
b64.decode_final(encoded[i].data(), encoded[i].size());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -424,7 +424,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -447,9 +447,9 @@ namespace
CHECK_FALSE(received_final_block);
b64.flush();
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -465,7 +465,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -490,7 +490,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -506,7 +506,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -514,7 +514,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -530,7 +530,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -538,7 +538,7 @@ namespace
b64.decode_final(encoded[i].begin(), encoded[i].end());
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -554,7 +554,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -579,7 +579,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -595,7 +595,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -620,7 +620,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -636,7 +636,7 @@ namespace
{
codec b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -670,7 +670,7 @@ namespace
{
codec_larger_buffer b64(callback);
for (size_t i = 0; i < 256; ++i)
for (size_t i = 0; i != input_data.size(); ++i)
{
decoded_output.clear();
received_final_block = false;
@ -688,7 +688,7 @@ namespace
CHECK_TRUE(received_final_block);
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(decoded_output);
#include "etl/private/diagnostic_pop.h"
@ -704,7 +704,7 @@ namespace
{
codec_full_buffer b64;
for (size_t i = 4; i < 256; ++i)
for (size_t i = 4; i < input_data.size(); ++i)
{
b64.restart();
@ -726,7 +726,7 @@ namespace
b64.flush();
#include "etl/private/diagnostic_null_dereference_push.h"
std::vector<unsigned char> expected(input_data.begin(), input_data.begin() + i);
std::vector<unsigned char> expected(input_data.begin(), std::next(input_data.begin(), i));
std::vector<unsigned char> actual(b64.begin(), b64.end());
#include "etl/private/diagnostic_pop.h"

2
test/test_circular_iterator.cpp
View File

@ -28,7 +28,9 @@ SOFTWARE.
#include "unit_test_framework.h"
#include <list>
#include "etl/private/diagnostic_null_dereference_push.h"
#include <forward_list>
#include "etl/private/diagnostic_pop.h"
#include <array>
#include "etl/iterator.h"

8
test/test_map.cpp
View File

@ -1148,7 +1148,7 @@ namespace
Data data(initial_data.begin(), initial_data.end());
Data::iterator it = data.find("3");
CHECK(3 == it->second);
CHECK(data.end() != it && 3 == it->second);
it = data.find("A");
CHECK(data.end() == it);
@ -1165,7 +1165,7 @@ namespace
EMap data(initial_data.begin(), initial_data.end());
EMap::iterator it = data.find(Key("3"));
CHECK(3 == it->second);
CHECK(data.end() != it && 3 == it->second);
it = data.find(Key("A"));
CHECK(data.end() == it);
@ -1180,7 +1180,7 @@ namespace
const Data data(initial_data.begin(), initial_data.end());
Data::const_iterator it = data.find("3");
CHECK(3 == it->second);
CHECK(data.end() != it && 3 == it->second);
it = data.find("A");
CHECK(data.end() == it);
@ -1197,7 +1197,7 @@ namespace
const EMap data(initial_data.begin(), initial_data.end());
EMap::const_iterator it = data.find(Key("3"));
CHECK(3 == it->second);
CHECK(data.end() != it && 3 == it->second);
it = data.find(Key("A"));
CHECK(data.end() == it);