Skip to content

Commit

Permalink
Fixed final sanitizer issues
Browse files Browse the repository at this point in the history
  • Loading branch information
@jwellbelove
jwellbelove committed May 19, 2022
1 parent 9299610 commit 752d9ad
Show file tree
Hide file tree
Showing 6 changed files with 117 additions and 36 deletions.
18 changes: 18 additions & 0 deletions include/etl/memory.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
2 changes: 0 additions & 2 deletions test/runtests.sh
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
#******************************************************************************
Expand Down
30 changes: 18 additions & 12 deletions test/test_memory.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,9 +39,9 @@ SOFTWARE.
#include <iterator>
#include <numeric>
#include <stdint.h>

#include <vector>


namespace
{
typedef std::string non_trivial_t;
Expand Down Expand Up @@ -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;
}

//*************************************************************************
Expand Down Expand Up @@ -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);
Expand All @@ -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));
Expand All @@ -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];
Expand All @@ -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);
Expand All @@ -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;

Expand All @@ -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);
Expand Down
60 changes: 44 additions & 16 deletions test/test_pool_external_buffer.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand All @@ -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();
Expand All @@ -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();
Expand Down Expand Up @@ -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());
Expand All @@ -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());
Expand All @@ -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());
Expand All @@ -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;
Expand All @@ -366,6 +380,8 @@ namespace

CHECK(pool.is_in_pool(p1));
CHECK(!pool.is_in_pool(&not_in_pool));

delete[] buffer;
}

//*************************************************************************
Expand All @@ -378,32 +394,34 @@ 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;
}

//*************************************************************************
TEST(test_create_destroy)
{
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);


Expand Down Expand Up @@ -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;
}

//*************************************************************************
Expand All @@ -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());
Expand All @@ -488,6 +514,8 @@ namespace

CHECK_EQUAL(3, memPool.available());
CHECK_EQUAL(0, memPool.size());

delete[] buffer;
}
}
}
Expand Down
Loading

0 comments on commit 752d9ad

Please sign in to comment.