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

Merge cd81277383dde5d23a7bc3fa0af8acee1aa02a88 into 5fe4a6cbd01f2f6ffe0cff839bbad168a668329f

Browse Source
This commit is contained in:
Cristian 2026-10-20 16:58:15 +00:00 committed by GitHub
commit bf0618c43c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 261 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
include/etl/vector.h
View File

@ -611,9 +611,18 @@ namespace etl
}
else
{
// value may refer to an element that is about to be shifted.
const_pointer p_value = etl::addressof(value);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
*position_ = value;
if ((p_value >= position_) && (p_value < p_end))
{
++p_value;
}
*position_ = *p_value;
}
return position_;
@ -640,9 +649,18 @@ namespace etl
}
else
{
// value may refer to an element that is about to be shifted.
pointer p_value = etl::addressof(value);
create_back(etl::move(back()));
etl::move_backward(position_, p_end - 2, p_end - 1);
*position_ = etl::move(value);
if ((p_value >= position_) && (p_value < p_end))
{
++p_value;
}
*position_ = etl::move(*p_value);
}
return position_;
@ -661,25 +679,26 @@ namespace etl
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
#include "private/diagnostic_sign_conversion_push.h"
::new (p_end) T(etl::forward<Args>(args)...);
#include "private/diagnostic_pop.h"
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
}
#include "private/diagnostic_sign_conversion_push.h"
::new (p) T(etl::forward<Args>(args)...);
// args may refer to elements that are about to be shifted, so construct the value first.
T value(etl::forward<Args>(args)...);
#include "private/diagnostic_pop.h"
create_back(etl::move(back()));
etl::move_backward(position_, p_end - 2, p_end - 1);
*position_ = etl::move(value);
}
return position_;
}
#else
@ -691,23 +710,22 @@ namespace etl
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
::new (p_end) T(value1);
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
// The values may refer to elements that are about to be shifted, so construct the value first.
T value(value1);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
*position_ = value;
}
::new (p) T(value1);
return position_;
}
@ -719,23 +737,22 @@ namespace etl
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
::new (p_end) T(value1, value2);
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
// The values may refer to elements that are about to be shifted, so construct the value first.
T value(value1, value2);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
*position_ = value;
}
::new (p) T(value1, value2);
return position_;
}
@ -747,23 +764,22 @@ namespace etl
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
::new (p_end) T(value1, value2, value3);
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
// The values may refer to elements that are about to be shifted, so construct the value first.
T value(value1, value2, value3);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
*position_ = value;
}
::new (p) T(value1, value2, value3);
return position_;
}
@ -775,23 +791,22 @@ namespace etl
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
::new (p_end) T(value1, value2, value3, value4);
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
// The values may refer to elements that are about to be shifted, so construct the value first.
T value(value1, value2, value3, value4);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
*position_ = value;
}
::new (p) T(value1, value2, value3, value4);
return position_;
}
#endif
@ -836,6 +851,14 @@ namespace etl
size_t copy_new_n = construct_old_n;
size_t construct_new_n = insert_n - copy_new_n;
// value may refer to an element that is about to be shifted.
const_pointer p_value = etl::addressof(value);
if ((p_value >= position_) && (p_value < p_end))
{
p_value += n;
}
// Construct old.
etl::uninitialized_move(p_end - construct_old_n, p_end, p_construct_old);
ETL_ADD_DEBUG_COUNT(construct_old_n);
@ -844,11 +867,11 @@ namespace etl
etl::move_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n);
// Construct new.
etl::uninitialized_fill_n(p_end, construct_new_n, value);
etl::uninitialized_fill_n(p_end, construct_new_n, *p_value);
ETL_ADD_DEBUG_COUNT(construct_new_n);
// Copy new.
etl::fill_n(p_buffer + insert_begin, copy_new_n, value);
etl::fill_n(p_buffer + insert_begin, copy_new_n, *p_value);
p_end += n;
}

115
test/test_vector.cpp
View File

@ -777,6 +777,62 @@ namespace
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_insert_position_value_from_self)
{
const size_t INITIAL_SIZE = 5;
for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset)
{
for (size_t source = 0; source < INITIAL_SIZE; ++source)
{
Compare_Data compare_data;
Data data;
data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
data.insert(data.cbegin() + offset, data[source]);
compare_data.insert(compare_data.cbegin() + static_cast<ptrdiff_t>(offset), compare_data[source]);
CHECK_EQUAL(compare_data.size(), data.size());
bool is_equal = std::equal(data.cbegin(), data.cend(), compare_data.cbegin());
CHECK(is_equal);
}
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_insert_position_rvalue_from_self)
{
const size_t INITIAL_SIZE = 5;
for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset)
{
for (size_t source = 0; source < INITIAL_SIZE; ++source)
{
Compare_Data compare_data;
Data data;
data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
data.insert(data.cbegin() + offset, std::move(data[source]));
int value = compare_data[source];
compare_data.insert(compare_data.cbegin() + static_cast<ptrdiff_t>(offset), value);
CHECK_EQUAL(compare_data.size(), data.size());
bool is_equal = std::equal(data.cbegin(), data.cend(), compare_data.cbegin());
CHECK(is_equal);
}
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_insert_position_value_outofbounds)
{
@ -814,6 +870,35 @@ namespace
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_emplace_position_value_from_self)
{
const size_t INITIAL_SIZE = 5;
for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset)
{
for (size_t source = 0; source < INITIAL_SIZE; ++source)
{
Compare_Data compare_data;
Data data;
data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
data.emplace(data.cbegin() + offset, data[source]);
int value = compare_data[source];
compare_data.insert(compare_data.cbegin() + static_cast<ptrdiff_t>(offset), value);
CHECK_EQUAL(compare_data.size(), data.size());
bool is_equal = std::equal(data.cbegin(), data.cend(), compare_data.cbegin());
CHECK(is_equal);
}
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_emplace_position_value_outofbounds)
{
@ -971,6 +1056,36 @@ namespace
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_insert_position_n_value_from_self)
{
const size_t INITIAL_SIZE = 5;
for (size_t insert_size = 1; insert_size <= 4; ++insert_size)
{
for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset)
{
for (size_t source = 0; source < INITIAL_SIZE; ++source)
{
Compare_Data compare_data;
Data data;
data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
data.insert(data.cbegin() + offset, insert_size, data[source]);
compare_data.insert(compare_data.cbegin() + static_cast<ptrdiff_t>(offset), insert_size, compare_data[source]);
CHECK_EQUAL(compare_data.size(), data.size());
bool is_equal = std::equal(data.cbegin(), data.cend(), compare_data.cbegin());
CHECK(is_equal);
}
}
}
}
//*************************************************************************
#include "etl/private/diagnostic_uninitialized_push.h"
TEST_FIXTURE(SetupFixture, test_insert_position_n_value_outofbounds)

81
test/test_vector_non_trivial.cpp
View File

@ -995,6 +995,87 @@ namespace
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_emplace_position_value_from_self)
{
const size_t INITIAL_SIZE = 5;
for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset)
{
for (size_t source = 0; source < INITIAL_SIZE; ++source)
{
CompareDataNDC compare_data;
DataNDC data;
data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
data.emplace(data.begin() + offset, data[source]);
NDC value(compare_data[source]);
compare_data.insert(compare_data.begin() + static_cast<ptrdiff_t>(offset), value);
CHECK_EQUAL(compare_data.size(), data.size());
bool is_equal = std::equal(data.begin(), data.end(), compare_data.begin());
CHECK(is_equal);
}
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_emplace_position_member_from_self)
{
const size_t INITIAL_SIZE = 5;
for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset)
{
for (size_t source = 0; source < INITIAL_SIZE; ++source)
{
CompareDataNDC compare_data;
DataNDC data;
data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
compare_data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
data.emplace(data.begin() + offset, data[source].value, data[source].index);
NDC value(compare_data[source].value, compare_data[source].index);
compare_data.insert(compare_data.begin() + static_cast<ptrdiff_t>(offset), value);
CHECK_EQUAL(compare_data.size(), data.size());
bool is_equal = std::equal(data.begin(), data.end(), compare_data.begin());
CHECK(is_equal);
}
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_insert_position_rvalue_from_self)
{
const size_t INITIAL_SIZE = 5;
for (size_t offset = 0; offset <= INITIAL_SIZE; ++offset)
{
for (size_t source = 0; source < INITIAL_SIZE; ++source)
{
DataNDC data;
data.assign(initial_data.begin(), initial_data.begin() + INITIAL_SIZE);
const NDC expected(data[source]);
data.insert(data.begin() + offset, std::move(data[source]));
CHECK_EQUAL(INITIAL_SIZE + 1, data.size());
CHECK(expected == data[offset]);
}
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_emplace_position_value_outofbounds)
{