coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-11-09 14:49:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fixed final sanitizer issues

Browse Source
This commit is contained in:
John Wellbelove 2022-05-19 11:10:00 +01:00
parent 92996109c7
commit 752d9adb5c
6 changed files with 117 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/etl/memory.h
View File

@ -1550,6 +1550,24 @@ namespace etl
return (p != ETL_NULLPTR);
}
#if ETL_USING_CPP11 && ETL_USING_STL
//*********************************
unique_ptr& operator =(std::nullptr_t) ETL_NOEXCEPT
{
reset(nullptr);
return *this;
}
#else
//*********************************
unique_ptr& operator =(void*) ETL_NOEXCEPT
{
reset(NULL);
return *this;
}
#endif
#if ETL_USING_CPP11
//*********************************
unique_ptr& operator =(unique_ptr&& p_) ETL_NOEXCEPT

2
test/runtests.sh
View File

@ -6,8 +6,6 @@ cd build-make || exit 1
echo "ETL Tests" > log.txt
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
#******************************************************************************
# GCC
#******************************************************************************

30
test/test_memory.cpp
View File

@ -39,9 +39,9 @@ SOFTWARE.
#include <iterator>
#include <numeric>
#include <stdint.h>
#include <vector>
namespace
{
typedef std::string non_trivial_t;
@ -879,10 +879,13 @@ namespace
//*************************************************************************
TEST(test_unique_ptr_release)
{
etl::unique_ptr<int> up(new int);
auto buffer = new int;
etl::unique_ptr<int> up(buffer);
CHECK(up.release() != nullptr);
CHECK(!bool(up));
delete buffer;
}
//*************************************************************************
@ -958,7 +961,7 @@ namespace
//*************************************************************************
TEST(test_unique_ptr_from_array_pointer_construction)
{
etl::unique_ptr<int> up(new int[4]);
etl::unique_ptr<int[]> up(new int[4]);
std::iota(&up[0], &up[4], 0);
CHECK(up.get() != nullptr);
@ -972,9 +975,9 @@ namespace
//*************************************************************************
TEST(test_unique_ptr_move_array_construction)
{
etl::unique_ptr<int> up1(new int[4]);
etl::unique_ptr<int[]> up1(new int[4]);
std::iota(&up1[0], &up1[4], 0);
etl::unique_ptr<int> up2(std::move(up1));
etl::unique_ptr<int[]> up2(std::move(up1));
CHECK(up1.get() == nullptr);
CHECK(!bool(up1));
@ -989,17 +992,20 @@ namespace
//*************************************************************************
TEST(test_unique_ptr_array_release)
{
etl::unique_ptr<int> up(new int[4]);
auto buffer = new int[4];
etl::unique_ptr<int[]> up(buffer);
std::iota(&up[0], &up[4], 0);
CHECK(up.release() != nullptr);
CHECK(!bool(up));
delete[] buffer;
}
//*************************************************************************
TEST(test_unique_ptr_array_reset)
{
etl::unique_ptr<int> up(new int[4]);
etl::unique_ptr<int[]> up(new int[4]);
std::iota(&up[0], &up[4], 0);
int* p = new int[4];
@ -1019,10 +1025,10 @@ namespace
//*************************************************************************
TEST(test_unique_ptr_array_swap)
{
etl::unique_ptr<int> up1(new int[4]);
etl::unique_ptr<int[]> up1(new int[4]);
std::iota(&up1[0], &up1[4], 0);
etl::unique_ptr<int> up2(new int[4]);
etl::unique_ptr<int[]> up2(new int[4]);
std::iota(&up2[0], &up2[4], 4);
up1.swap(up2);
@ -1041,7 +1047,7 @@ namespace
//*************************************************************************
TEST(test_unique_ptr_array_from_nullptr_assignment)
{
etl::unique_ptr<int> up(new int[4]);
etl::unique_ptr<int[]> up(new int[4]);
up = nullptr;
@ -1052,10 +1058,10 @@ namespace
//*************************************************************************
TEST(test_unique_ptr_array_move_assignment)
{
etl::unique_ptr<int> up1(new int[4]);
etl::unique_ptr<int[]> up1(new int[4]);
std::iota(&up1[0], &up1[4], 0);
etl::unique_ptr<int> up2(new int[4]);
etl::unique_ptr<int[]> up2(new int[4]);
std::iota(&up2[0], &up2[4], 4);
up1 = std::move(up2);

60
test/test_pool_external_buffer.cpp
View File

@ -166,7 +166,7 @@ namespace
TEST(test_allocate)
{
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<Test_Data>::element[SIZE];
auto buffer = new etl::pool_ext<Test_Data>::element[SIZE];
etl::pool_ext<Test_Data> pool(buffer, SIZE);
Test_Data* p1 = nullptr;
@ -187,13 +187,15 @@ namespace
CHECK(p3 != p4);
CHECK_THROW(pool.allocate(), etl::pool_no_allocation);
delete[] buffer;
}
//*************************************************************************
TEST(test_release)
{
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<Test_Data>::element[SIZE];
auto buffer = new etl::pool_ext<Test_Data>::element[SIZE];
etl::pool_ext<Test_Data> pool(buffer, SIZE);
Test_Data* p1 = pool.allocate();
@ -211,13 +213,15 @@ namespace
Test_Data not_in_pool;
CHECK_THROW(pool.release(&not_in_pool), etl::pool_object_not_in_pool);
delete[] buffer;
}
//*************************************************************************
TEST(test_allocate_release)
{
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<Test_Data>::element[SIZE];
auto buffer = new etl::pool_ext<Test_Data>::element[SIZE];
etl::pool_ext<Test_Data> pool(buffer, SIZE);
Test_Data* p1 = pool.allocate();
@ -264,13 +268,15 @@ namespace
CHECK(p7 != p6);
CHECK(pool.full());
delete[] buffer;
}
//*************************************************************************
TEST(test_available)
{
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<Test_Data>::element[SIZE];
auto buffer = new etl::pool_ext<Test_Data>::element[SIZE];
etl::pool_ext<Test_Data> pool(buffer, SIZE);
CHECK_EQUAL(4U, pool.available());
@ -288,23 +294,27 @@ namespace
p = pool.allocate();
CHECK_EQUAL(0U, pool.available());
delete[] buffer;
}
//*************************************************************************
TEST(test_max_size)
{
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<Test_Data>::element[SIZE];
auto buffer = new etl::pool_ext<Test_Data>::element[SIZE];
etl::pool_ext<Test_Data> pool(buffer, SIZE);
CHECK(pool.max_size() == 4U);
delete[] buffer;
}
//*************************************************************************
TEST(test_size)
{
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<Test_Data>::element[SIZE];
auto buffer = new etl::pool_ext<Test_Data>::element[SIZE];
etl::pool_ext<Test_Data> pool(buffer, SIZE);
CHECK_EQUAL(0U, pool.size());
@ -322,13 +332,15 @@ namespace
p = pool.allocate();
CHECK_EQUAL(4U, pool.size());
delete[] buffer;
}
//*************************************************************************
TEST(test_empty_full)
{
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<Test_Data>::element[SIZE];
auto buffer = new etl::pool_ext<Test_Data>::element[SIZE];
etl::pool_ext<Test_Data> pool(buffer, SIZE);
CHECK(pool.empty());
@ -351,13 +363,15 @@ namespace
p = pool.allocate();
CHECK(!pool.empty());
CHECK(pool.full());
delete[] buffer;
}
//*************************************************************************
TEST(test_is_in_pool)
{
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<Test_Data>::element[SIZE];
auto buffer = new etl::pool_ext<Test_Data>::element[SIZE];
etl::pool_ext<Test_Data> pool(buffer, SIZE);
Test_Data not_in_pool;
@ -366,6 +380,8 @@ namespace
CHECK(pool.is_in_pool(p1));
CHECK(!pool.is_in_pool(&not_in_pool));
delete[] buffer;
}
//*************************************************************************
@ -378,12 +394,14 @@ namespace
};
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<uint32_t>::element[SIZE];
auto buffer = new etl::pool_ext<uint32_t>::element[SIZE];
etl::pool_ext<uint32_t> pool(buffer, SIZE);
etl::ipool& ip = pool;
CHECK_THROW(ip.allocate<Test>(), etl::pool_element_size);
delete[] buffer;
}
//*************************************************************************
@ -391,19 +409,19 @@ namespace
{
const size_t SIZE = 4;
auto* buffer0 = new etl::pool_ext<D0>::element[SIZE];
auto buffer0 = new etl::pool_ext<D0>::element[SIZE];
etl::pool_ext<D0> pool0(buffer0, SIZE);
auto* buffer1 = new etl::pool_ext<D1>::element[SIZE];
auto buffer1 = new etl::pool_ext<D1>::element[SIZE];
etl::pool_ext<D1> pool1(buffer1, SIZE);
auto* buffer2 = new etl::pool_ext<D2>::element[SIZE];
auto buffer2 = new etl::pool_ext<D2>::element[SIZE];
etl::pool_ext<D2> pool2(buffer2, SIZE);
auto* buffer3 = new etl::pool_ext<D3>::element[SIZE];
auto buffer3 = new etl::pool_ext<D3>::element[SIZE];
etl::pool_ext<D3> pool3(buffer3, SIZE);
auto* buffer4 = new etl::pool_ext<D4>::element[SIZE];
auto buffer4 = new etl::pool_ext<D4>::element[SIZE];
etl::pool_ext<D4> pool4(buffer4, SIZE);
@ -454,17 +472,25 @@ namespace
CHECK_EQUAL(pool4.max_size(), pool4.available());
CHECK_EQUAL(0U, pool4.size());
delete[] buffer0;
delete[] buffer1;
delete[] buffer2;
delete[] buffer3;
delete[] buffer4;
}
//*************************************************************************
TEST(test_allocate_release_non_class)
{
const size_t SIZE = 4;
auto* buffer = new etl::pool_ext<int>::element[SIZE];
auto buffer = new etl::pool_ext<int>::element[SIZE];
etl::pool_ext<int> pool(buffer, SIZE);
int* i = pool.allocate();
pool.release(i);
delete[] buffer;
}
//*************************************************************************
@ -473,7 +499,7 @@ namespace
using elem_type = uint8_t[10];
const size_t SIZE = 3;
auto* buffer = new etl::pool_ext<elem_type>::element[SIZE];
auto buffer = new etl::pool_ext<elem_type>::element[SIZE];
etl::pool_ext<elem_type> memPool(buffer, SIZE);
CHECK_EQUAL(3, memPool.available());
@ -488,6 +514,8 @@ namespace
CHECK_EQUAL(3, memPool.available());
CHECK_EQUAL(0, memPool.size());
delete[] buffer;
}
}
}

22
test/test_variant_pool_external_buffer.cpp
View File

@ -176,7 +176,7 @@ namespace
//*************************************************************************
TEST(test_sizes)
{
auto* buffer = new Factory::element[SIZE];
auto buffer = new Factory::element[SIZE];
Factory variant_pool(buffer, SIZE);
size_t ms = variant_pool.max_size();
@ -202,12 +202,14 @@ namespace
CHECK(variant_pool.full());
CHECK_THROW(variant_pool.create<Derived1>(), etl::pool_no_allocation);
delete[] buffer;
}
//*************************************************************************
TEST(test_create_release)
{
auto* buffer = new Factory::element[SIZE];
auto buffer = new Factory::element[SIZE];
Factory variant_pool(buffer, SIZE);
Base* p;
@ -253,12 +255,14 @@ namespace
// Integral
int* pi = variant_pool.create<int>();
variant_pool.destroy(pi);
delete[] buffer;
}
//*************************************************************************
TEST(test_create_release_const)
{
auto* buffer = new Factory::element[SIZE];
auto buffer = new Factory::element[SIZE];
Factory variant_pool(buffer, SIZE);
const Derived1& d = *variant_pool.create<Derived1>();
@ -267,12 +271,13 @@ namespace
variant_pool.destroy(&d);
CHECK(destructor);
delete[] buffer;
}
//*************************************************************************
TEST(test_create_emplace)
{
auto* buffer = new Factory::element[SIZE];
auto buffer = new Factory::element[SIZE];
Factory variant_pool(buffer, SIZE);
Base* p;
@ -297,14 +302,16 @@ namespace
pd3 = static_cast<Derived3*>(p);
CHECK_EQUAL("constructed1234", pd3->s);
variant_pool.destroy(p);
delete[] buffer;
}
//*************************************************************************
TEST(test_did_not_create)
{
auto* buffer1 = new Factory::element[SIZE];
auto buffer1 = new Factory::element[SIZE];
Factory variant_pool1(buffer1, SIZE);
auto* buffer2 = new Factory::element[SIZE];
auto buffer2 = new Factory::element[SIZE];
Factory variant_pool2(buffer2, SIZE);
Base* p;
@ -314,6 +321,9 @@ namespace
p = variant_pool2.create<Derived1>();
CHECK_THROW(variant_pool1.destroy(p), etl::pool_object_not_in_pool);
delete[] buffer1;
delete[] buffer2;
}
};
}

21
test/test_vector_external_buffer.cpp
View File

@ -32,6 +32,7 @@ SOFTWARE.
#include <array>
#include <algorithm>
#include <cstring>
#include <numeric>
#include "etl/vector.h"
@ -409,6 +410,26 @@ namespace
CHECK_EQUAL(data.size(), NEW_SIZE);
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_uninitialized_resize_after_contruct)
{
int c_buffer[SIZE];
std::iota(c_buffer, c_buffer + SIZE, 1);
int compare_buffer[SIZE];
std::iota(compare_buffer, compare_buffer + SIZE, 1);
Data data(c_buffer, SIZE);
data.uninitialized_resize(SIZE);
CHECK_EQUAL(SIZE, data.size());
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(data[i], compare_buffer[i]);
}
}
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_empty)
{