coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-06-17 09:26:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Array bounds and maybe-uninitialized warning fixes

Browse Source 
Array bounds and maybe-uninitialized warning fixes

Added GCC/clang diagnostic disable for array bounds

Fixed false positive array bounds failure in unit tests

Added -01 & -03 quick tests

Fixed constexpr for exception constructor

Made virtual functions protected

Updated project files

Updated generated file

Updated versions and release notes
This commit is contained in:
John Wellbelove 2023-02-28 19:32:02 +00:00
parent 7bfa2d9429
commit bcad53ebb2
29 changed files with 1168 additions and 545 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arduino/library-arduino.json
View File

@ -1,6 +1,6 @@
{
"name": "Embedded Template Library - Arduino",
"version": "20.35.12",
"version": "20.35.13",
"authors": {
"name": "John Wellbelove",
"email": "john.wellbelove@etlcpp.com"

2
arduino/library-arduino.properties
View File

@ -1,5 +1,5 @@
name=Embedded Template Library - Arduino
version=20.35.12
version=20.35.13
author= John Wellbelove <john.wellbelove@etlcpp.com>
maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
license=MIT

3
include/etl/exception.h
View File

@ -66,11 +66,10 @@ namespace etl
/// Constructor.
//*************************************************************************
ETL_CONSTEXPR
exception(string_type reason_, string_type file_, numeric_type line_)
exception(string_type reason_, string_type /*file_*/, numeric_type line_)
: reason_text(reason_),
line(line_)
{
(void)file_;
}
#endif

21
include/etl/fixed_sized_memory_block_allocator.h
View File

@ -46,6 +46,7 @@ namespace etl
class fixed_sized_memory_block_allocator : public imemory_block_allocator
{
public:
static ETL_CONSTANT size_t Block_Size = VBlock_Size;
static ETL_CONSTANT size_t Alignment = VAlignment;
static ETL_CONSTANT size_t Size = VSize;
@ -57,13 +58,7 @@ namespace etl
{
}
private:
/// A structure that has the size Block_Size.
struct block
{
char data[Block_Size];
};
protected:
//*************************************************************************
/// The overridden virtual function to allocate a block.
@ -71,8 +66,8 @@ namespace etl
virtual void* allocate_block(size_t required_size, size_t required_alignment) ETL_OVERRIDE
{
if ((required_alignment <= Alignment) &&
(required_size <= Block_Size) &&
!pool.full())
(required_size <= Block_Size) &&
!pool.full())
{
return pool.template allocate<block>();
}
@ -106,6 +101,14 @@ namespace etl
return pool.is_in_pool(pblock);
}
private:
/// A structure that has the size Block_Size.
struct block
{
char data[Block_Size];
};
/// The generic pool from which allocate memory blocks.
etl::generic_pool<Block_Size, Alignment, Size> pool;
};

70
include/etl/message_packet.h
View File

@ -286,9 +286,6 @@ namespace etl
new (p) etl::remove_reference_t<TMessage>((etl::forward<TMessage>(msg)));
}
typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
bool valid;
//********************************************
template <typename TType>
bool add_new_message_type(const etl::imessage& msg)
@ -320,6 +317,9 @@ namespace etl
return false;
}
}
typename etl::aligned_storage<SIZE, ALIGNMENT>::type data;
bool valid;
};
#else
@ -543,7 +543,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -553,7 +553,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -836,7 +836,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -846,7 +846,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -1127,7 +1127,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -1137,7 +1137,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -1416,7 +1416,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -1426,7 +1426,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -1699,7 +1699,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -1709,7 +1709,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -1980,7 +1980,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -1990,7 +1990,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -2259,7 +2259,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -2269,7 +2269,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -2536,7 +2536,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -2546,7 +2546,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -2807,7 +2807,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -2817,7 +2817,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -3076,7 +3076,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -3086,7 +3086,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -3343,7 +3343,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -3353,7 +3353,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -3608,7 +3608,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -3618,7 +3618,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -3867,7 +3867,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -3877,7 +3877,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -4124,7 +4124,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -4134,7 +4134,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -4379,7 +4379,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -4389,7 +4389,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)
@ -4632,7 +4632,7 @@ namespace etl
private:
//********************************************
#include "etl/private/diagnostic_uninitialized_push.h"
#include "etl/private/diagnostic_uninitialized_push.h"
void delete_current_message()
{
if (valid)
@ -4642,7 +4642,7 @@ namespace etl
pmsg->~imessage();
}
}
#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
//********************************************
void add_new_message(const etl::imessage& msg)

155
include/etl/optional.h
View File

@ -60,7 +60,7 @@ namespace etl
private:
// Can't take address of nullopt.
void operator&() const;
void operator&() const ETL_DELETE;
};
//*****************************************************************************
@ -115,7 +115,6 @@ namespace etl
{
public:
#include "etl/private/diagnostic_uninitialized_push.h"
//***************************************************************************
/// Constructor.
//***************************************************************************
@ -188,7 +187,6 @@ namespace etl
{
storage.destroy();
}
#include "etl/private/diagnostic_pop.h"
//***************************************************************************
/// Assignment operator from nullopt.
@ -282,7 +280,7 @@ namespace etl
ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
return &storage.value;
return &storage.u.value;
}
//***************************************************************************
@ -295,7 +293,7 @@ namespace etl
ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
return &storage.value;
return &storage.u.value;
}
//***************************************************************************
@ -308,7 +306,7 @@ namespace etl
ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
return storage.value;
return storage.u.value;
}
//***************************************************************************
@ -321,7 +319,7 @@ namespace etl
ETL_ASSERT(has_value(), ETL_ERROR(optional_invalid));
#endif
return storage.value;
return storage.u.value;
}
//***************************************************************************
@ -422,7 +420,10 @@ namespace etl
storage.destroy();
}
::new (&storage.value) T(value1);
T* p = ::new (&storage.u.value) T(value1);
storage.valid = true;
return *p;
}
//*************************************************************************
@ -438,7 +439,10 @@ namespace etl
storage.destroy();
}
::new (&storage.value) T(value1, value2);
T* p = ::new (&storage.u.value) T(value1, value2);
storage.valid = true;
return *p;
}
//*************************************************************************
@ -454,7 +458,10 @@ namespace etl
storage.destroy();
}
::new (&storage.value) T(value1, value2, value3);
T* p = ::new (&storage.u.value) T(value1, value2, value3);
storage.valid = true;
return *p;
}
//*************************************************************************
@ -470,7 +477,10 @@ namespace etl
storage.destroy();
}
::new (&storage.value) T(value1, value2, value3, value4);
T* p = ::new (&storage.u.value) T(value1, value2, value3, value4);
storage.valid = true;
return *p;
}
#endif
@ -484,7 +494,6 @@ namespace etl
: u()
, valid(false)
{
u.dummy = 0;
}
//*******************************
@ -878,17 +887,19 @@ namespace etl
T storage;
};
#include "etl/private/diagnostic_uninitialized_push.h"
//***************************************************************************
/// Equality operator. cppreference 1
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
{
if (bool(lhs) != bool(rhs))
if (lhs.has_value() != rhs.has_value())
{
return false;
}
else if (!bool(lhs) && !bool(rhs))
else if (!lhs.has_value() && !rhs.has_value())
{
return true;
}
@ -913,11 +924,11 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator <(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
{
if (!bool(rhs))
if (!rhs.has_value())
{
return false;
}
else if (!bool(lhs))
else if (!lhs.has_value())
{
return true;
}
@ -933,18 +944,20 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
{
if (!bool(lhs))
{
return true;
}
else if (!bool(rhs))
{
return false;
}
else
{
return lhs.value() <= rhs.value();
}
return !(rhs < lhs);
//if (!lhs.has_value())
//{
// return true;
//}
//else if (!rhs.has_value())
//{
// return false;
//}
//else
//{
// return lhs.value() <= rhs.value();
//}
}
//***************************************************************************
@ -953,18 +966,20 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
{
if (!bool(lhs))
{
return false;
}
else if (!bool(rhs))
{
return true;
}
else
{
return lhs.value() > rhs.value();
}
return (rhs < lhs);
//if (!lhs.has_value())
//{
// return false;
//}
//else if (!rhs.has_value())
//{
// return true;
//}
//else
//{
// return lhs.value() > rhs.value();
//}
}
//***************************************************************************
@ -973,18 +988,20 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>& lhs, const etl::optional<T>& rhs)
{
if (!bool(rhs))
{
return true;
}
else if (!bool(lhs))
{
return false;
}
else
{
return lhs.value() >= rhs.value();
}
return !(lhs < rhs);
//if (!rhs.has_value())
//{
// return true;
//}
//else if (!lhs.has_value())
//{
// return false;
//}
//else
//{
// return lhs.value() >= rhs.value();
//}
}
//***************************************************************************
@ -993,7 +1010,7 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, etl::nullopt_t)
{
return !bool(lhs);
return !lhs.has_value();
}
//***************************************************************************
@ -1002,7 +1019,7 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator ==(etl::nullopt_t, const etl::optional<T>& rhs)
{
return !bool(rhs);
return !rhs.has_value();
}
//***************************************************************************
@ -1038,7 +1055,7 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator <(etl::nullopt_t, const etl::optional<T>& rhs)
{
return bool(rhs);
return rhs.has_value();
}
//***************************************************************************
@ -1047,7 +1064,7 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, etl::nullopt_t)
{
return !bool(lhs);
return !lhs.has_value();
}
//***************************************************************************
@ -1065,7 +1082,7 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, etl::nullopt_t)
{
return bool(lhs);
return lhs.has_value();
}
//***************************************************************************
@ -1092,7 +1109,7 @@ namespace etl
template <typename T>
ETL_CONSTEXPR14 bool operator >=(etl::nullopt_t, const etl::optional<T>& rhs)
{
return !bool(rhs);
return !rhs.has_value();
}
//***************************************************************************
@ -1101,7 +1118,7 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator ==(const etl::optional<T>& lhs, const U& rhs)
{
return bool(lhs) ? lhs.value() == rhs : false;
return lhs.has_value() ? lhs.value() == rhs : false;
}
//***************************************************************************
@ -1119,7 +1136,7 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator ==(const U& lhs, const etl::optional<T>& rhs)
{
return bool(rhs) ? rhs.value() == lhs : false;
return rhs.has_value() ? rhs.value() == lhs : false;
}
//***************************************************************************
@ -1137,7 +1154,7 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator <(const etl::optional<T>& lhs, const U& rhs)
{
return bool(lhs) ? lhs.value() < rhs : true;
return lhs.has_value() ? lhs.value() < rhs : true;
}
//***************************************************************************
@ -1146,7 +1163,7 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator <(const U& lhs, const etl::optional<T>& rhs)
{
return bool(rhs) ? lhs < rhs.value() : false;
return rhs.has_value() ? lhs < rhs.value() : false;
}
//***************************************************************************
@ -1155,7 +1172,7 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator <=(const etl::optional<T>& lhs, const U& rhs)
{
return bool(lhs) ? lhs.value() <= rhs : true;
return lhs.has_value() ? lhs.value() <= rhs : true;
}
//***************************************************************************
@ -1164,7 +1181,7 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator <=(const U& lhs, const etl::optional<T>& rhs)
{
return bool(rhs) ? lhs <= rhs.value() : false;
return rhs.has_value() ? lhs <= rhs.value() : false;
}
//***************************************************************************
@ -1173,7 +1190,7 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator >(const etl::optional<T>& lhs, const U& rhs)
{
return bool(lhs) ? lhs.value() > rhs : false;
return lhs.has_value() ? lhs.value() > rhs : false;
}
//***************************************************************************
@ -1182,7 +1199,7 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator >(const U& lhs, const etl::optional<T>& rhs)
{
return bool(rhs) ? lhs > rhs.value() : true;
return rhs.has_value() ? lhs > rhs.value() : true;
}
//***************************************************************************
@ -1191,7 +1208,7 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator >=(const etl::optional<T>& lhs, const U& rhs)
{
return bool(lhs) ? lhs.value() >= rhs : false;
return lhs.has_value() ? lhs.value() >= rhs : false;
}
//***************************************************************************
@ -1200,9 +1217,11 @@ namespace etl
template <typename T, typename U>
ETL_CONSTEXPR14 bool operator >=(const U& lhs, const etl::optional<T>& rhs)
{
return bool(rhs) ? lhs >= rhs.value() : true;
return rhs.has_value() ? lhs >= rhs.value() : true;
}
#include "etl/private/diagnostic_pop.h"
//***************************************************************************
/// Make an optional.
//***************************************************************************

44
include/etl/private/diagnostic_array_bounds_push.h Normal file
View File

@ -0,0 +1,44 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2023 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
/*
* The header include guard has been intentionally omitted.
* This file is intended to evaluated multiple times by design.
*/
#if defined(__GNUC__) && !defined(__clang__) && !defined(__llvm__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif
#if defined(__clang__) || defined(__llvm__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warray-bounds"
#endif

21
include/etl/private/pvoidvector.h
View File

@ -439,19 +439,24 @@ namespace etl
//*********************************************************************
iterator insert(const_iterator position, value_type value)
{
iterator position_ = to_iterator(position);
ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
if (position_ != end())
if (size() != CAPACITY)
{
++p_end;
etl::copy_backward(position_, end() - 1, end());
*position_ = value;
}
else
{
*p_end++ = value;
if (position_ != end())
{
++p_end;
etl::copy_backward(position_, end() - 1, end());
*position_ = value;
}
else
{
*p_end++ = value;
}
}
return position_;

2
include/etl/version.h
View File

@ -40,7 +40,7 @@ SOFTWARE.
#define ETL_VERSION_MAJOR 20
#define ETL_VERSION_MINOR 35
#define ETL_VERSION_PATCH 12
#define ETL_VERSION_PATCH 13
#define ETL_VERSION ETL_STRING(ETL_VERSION_MAJOR) "." ETL_STRING(ETL_VERSION_MINOR) "." ETL_STRING(ETL_VERSION_PATCH)
#define ETL_VERSION_W ETL_WIDE_STRING(ETL_VERSION_MAJOR) L"." ETL_WIDE_STRING(ETL_VERSION_MINOR) L"." ETL_WIDE_STRING(ETL_VERSION_PATCH)

2
library.json
View File

@ -1,6 +1,6 @@
{
"name": "Embedded Template Library",
"version": "20.35.12",
"version": "20.35.13",
"authors": {
"name": "John Wellbelove",
"email": "john.wellbelove@etlcpp.com"

2
library.properties
View File

@ -1,5 +1,5 @@
name=Embedded Template Library
version=20.35.12
version=20.35.13
author= John Wellbelove <john.wellbelove@etlcpp.com>
maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
license=MIT

6
support/Release notes.txt
View File

@ -1,3 +1,9 @@
===============================================================================
20.35.13
#649 Fixed the false positive 'array-bounds' errors for ETL unit tests.
#652 Fixed false positives 'maybe-uninitialized' errors for ETL unit tests.
Moved virtual functions in etl::fixed_sized_memory_block_allocator from 'private' to 'protected'.
===============================================================================
20.35.12
#615 Addition of etl::expected

1
test/CMakeLists.txt
View File

@ -321,7 +321,6 @@ target_link_libraries(etl_tests PRIVATE UnitTestpp)
if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
target_compile_options(etl_tests
PRIVATE
-pipe
-fsanitize=address,undefined,bounds
-fno-omit-frame-pointer
-Wall

1
test/etl_error_handler/exceptions/CMakeLists.txt
View File

@ -37,7 +37,6 @@ target_include_directories(etl_tests
if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
target_compile_options(etl_tests
PRIVATE
-pipe
-fsanitize=address,undefined,bounds
-fno-omit-frame-pointer
-Wall

1
test/etl_error_handler/log_errors/CMakeLists.txt
View File

@ -37,7 +37,6 @@ target_include_directories(etl_tests
if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
target_compile_options(etl_tests
PRIVATE
-pipe
-fsanitize=address,undefined,bounds
-fno-omit-frame-pointer
-Wall

1
test/etl_error_handler/log_errors_and_exceptions/CMakeLists.txt
View File

@ -38,7 +38,6 @@ target_include_directories(etl_tests
if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
target_compile_options(etl_tests
PRIVATE
-pipe
-fsanitize=address,undefined,bounds
-fno-omit-frame-pointer
-Wall

1
test/etl_initializer_list/CMakeLists.txt
View File

@ -38,7 +38,6 @@ target_include_directories(etl_tests
if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
target_compile_options(etl_tests
PRIVATE
-pipe
-fsanitize=address,undefined,bounds
-fno-omit-frame-pointer
-Wall

238
test/runtests-01.sh Normal file
View File

@ -0,0 +1,238 @@
#!/bin/sh
clear
mkdir -p build-make || exit 1
cd build-make || exit 1
echo "ETL Tests" > log.txt
opt="-O1"
#******************************************************************************
# GCC
#******************************************************************************
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Initializer list test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../etl_initializer_list/
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed initializer_list Compilation >>>>"
else
echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Initializer list test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed initializer_list Compilation >>>>"
else
echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'log_errors' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../etl_error_handler/log_errors
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'log_errors and exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/log_errors_and_exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'log_errors' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/log_errors
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'log_errors and exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/log_errors_and_exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
cd ../..
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " All Tests Completed OK" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt

238
test/runtests-03.sh Normal file
View File

@ -0,0 +1,238 @@
#!/bin/sh
clear
mkdir -p build-make || exit 1
cd build-make || exit 1
echo "ETL Tests" > log.txt
opt="-O3"
#******************************************************************************
# GCC
#******************************************************************************
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - STL" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Compilation >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Initializer list test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../etl_initializer_list/
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed initializer_list Compilation >>>>"
else
echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Initializer list test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed initializer_list Compilation >>>>"
else
echo "****************\n**** Failed initializer_list ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'log_errors' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../etl_error_handler/log_errors
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " GCC - Error macros 'log_errors and exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/log_errors_and_exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
gcc --version | grep gcc | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="g++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'log_errors' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/log_errors
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " Clang - Error macros 'log_errors and exceptions' test" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt
cd ../../../etl_error_handler/log_errors_and_exceptions
mkdir -p build-make || exit 1
cd build-make || exit 1
rm * -rf
clang --version | grep clang | tee -a log.txt
cmake -DCMAKE_CXX_COMPILER="clang++" -DETL_OPTIMISATION=$opt ..
make -j4
if [ $? -eq 0 ]; then
echo "<<<< Passed Error macros 'log_errors and exceptions' Compilation >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
./etl_tests
if [ $? -eq 0 ]; then
echo "<<<< Passed Tests >>>>"
else
echo "****************\n**** Failed Error macros 'log_errors and exceptions' ****\n****************" | tee -a ../log.txt
exit $?
fi
cd ../..
echo ""
echo "-----------------------------------------------" | tee -a log.txt
echo " All Tests Completed OK" | tee -a log.txt
echo "-----------------------------------------------" | tee -a log.txt

55
test/test_fixed_sized_memory_block_allocator.cpp
View File

@ -36,6 +36,47 @@ namespace
using Allocator16 = etl::fixed_sized_memory_block_allocator<sizeof(int16_t), alignof(int16_t), 4>;
using Allocator32 = etl::fixed_sized_memory_block_allocator<sizeof(int32_t), alignof(int32_t), 4>;
class CustomAllocator8 : public Allocator8
{
public:
bool allocate_block_called = false;
bool release_block_called = false;
mutable bool is_owner_of_block_called = false;
protected:
//*************************************************************************
/// The overridden virtual function to allocate a block.
//*************************************************************************
void* allocate_block(size_t required_size, size_t required_alignment) override
{
allocate_block_called = true;
return Allocator8::allocate_block(required_size, required_alignment);
}
//*************************************************************************
/// The overridden virtual function to release a block.
//*************************************************************************
bool release_block(const void* const pblock) override
{
release_block_called = true;
return Allocator8::release_block(pblock);
}
//*************************************************************************
/// Returns true if the allocator is the owner of the block.
//*************************************************************************
bool is_owner_of_block(const void* const pblock) const override
{
is_owner_of_block_called = true;
return Allocator8::is_owner_of_block(pblock);
}
};
SUITE(test_fixed_sized_memory_block_allocator)
{
//*************************************************************************
@ -230,5 +271,19 @@ namespace
CHECK(allocator8.release(p10));
CHECK(allocator8.release(p11));
}
//*************************************************************************
TEST(test_custom_allocator)
{
CustomAllocator8 allocator8;
int8_t* p1 = static_cast<int8_t*>(allocator8.allocate(sizeof(int8_t), alignof(int8_t)));
CHECK(allocator8.allocate_block_called);
CHECK(p1 != nullptr);
CHECK(allocator8.is_owner_of(p1));
CHECK(allocator8.is_owner_of_block_called);
CHECK(allocator8.release(p1));
CHECK(allocator8.release_block_called);
}
}
}

815
test/test_optional.cpp
View File

@ -56,364 +56,359 @@ namespace
{
SUITE(test_optional)
{
// //*************************************************************************
// TEST(test_initialisation)
// {
// etl::optional<Data> data1;
// etl::optional<Data> data2;
//
// CHECK(!bool(data1));
// CHECK(!bool(data2));
// CHECK(!data1.has_value());
// CHECK(!data2.has_value());
//
// data1 = Data("Hello");
// CHECK(bool(data1));
// CHECK(data1.has_value());
// CHECK_EQUAL(Data("Hello"), data1);
//
// data1 = data2;
// CHECK(!bool(data1));
// CHECK(!bool(data2));
// CHECK(!data1.has_value());
// CHECK(!data2.has_value());
//
// data1 = Data("World");
// data2 = data1;
// CHECK(bool(data1));
// CHECK(bool(data2));
// CHECK(data1.has_value());
// CHECK(data2.has_value());
//
// etl::optional<Data> data3(data1);
// CHECK(bool(data3));
// CHECK(data3.has_value());
// CHECK_EQUAL(data1, data3);
//
// etl::optional<Data> data4;
// data4 = Data("Hello");
// data4 = etl::nullopt;
// CHECK(!bool(data4));
// CHECK(!data4.has_value());
// }
//
// //*************************************************************************
// TEST(test_deduced_initialisation)
// {
// Data data("Hello");
//
// etl::optional opt{ data };
//
// CHECK(opt.has_value());
// CHECK(bool(opt));
// CHECK_EQUAL(data, opt);
// }
//
// //*************************************************************************
// TEST(test_emplace)
// {
// etl::optional<DataM> data;
//
// data.emplace(1U);
// CHECK_EQUAL(1U, data.value().value);
//
// data.emplace(2U);
// CHECK_EQUAL(2U, data.value().value);
//
// data.emplace(3U);
// CHECK_EQUAL(3U, data.value().value);
//
// CHECK_EQUAL(1, DataM::get_instance_count());
// }
//
// //*************************************************************************
// TEST(test_moveable)
// {
//#include "etl/private/diagnostic_pessimizing_move_push.h"
// etl::optional<DataM> data(std::move(DataM(1)));
// CHECK_EQUAL(1U, data.value().value);
// CHECK(bool(data));
//
// data = std::move(etl::optional<DataM>(std::move(DataM(2))));
// CHECK_EQUAL(2U, data.value().value);
// CHECK(bool(data));
//
// etl::optional<DataM> data2(etl::move(data));
// CHECK_EQUAL(2U, data2.value().value);
// CHECK(bool(data2));
//#include "etl/private/diagnostic_pop.h"
// }
//
// //*************************************************************************
// TEST(test_nullopt)
// {
// etl::optional<Data> data;
// data = Data("Hello");
// data = etl::nullopt;
// CHECK(!bool(data));
// }
//
// //*************************************************************************
// TEST(test_value_or)
// {
// etl::optional<Data> data;
//
// Data result = data.value_or(Data("Default"));
// CHECK_EQUAL(Data("Default"), result);
//
// data = Data("Value");
// result = data.value_or(Data("Default"));
// CHECK_EQUAL(Data("Value"), result);
// }
//
// //*************************************************************************
// TEST(test_equality)
// {
// etl::optional<Data> data1;
// etl::optional<Data> data2;
//
// CHECK(data1 == data2);
// CHECK(data2 == data1);
//
// data1 = Data("Data1");
// CHECK(!(data1 == data2));
// CHECK(!(data2 == data1));
//
// data1 = etl::nullopt;
// data2 = Data("Data2");
// CHECK(!(data1 == data2));
// CHECK(!(data2 == data1));
//
// data1 = Data("Data1");
// data2 = Data("Data1");
// CHECK(data1 == data2);
// CHECK(data2 == data1);
//
// data1 = Data("Data1");
// data2 = Data("Data2");
// CHECK(!(data1 == data2));
// CHECK(!(data2 == data1));
//
// CHECK(!(etl::nullopt == data2));
// CHECK(!(data1 == etl::nullopt));
//
// CHECK(data1 == Data("Data1"));
// CHECK(!(data1 == Data("Data2")));
// CHECK(Data("Data1") == data1);
// CHECK(!(Data("Data2") == data1));
// }
//
// //*************************************************************************
// TEST(test_inequality)
// {
// etl::optional<Data> data1;
// etl::optional<Data> data2;
//
// CHECK(!(data1 != data2));
// CHECK(!(data2 != data1));
//
// data1 = Data("Data1");
// CHECK(data1 != data2);
// CHECK(data2 != data1);
//
// data1 = etl::nullopt;
// data2 = Data("Data2");
// CHECK(data1 != data2);
// CHECK(data2 != data1);
//
// data1 = Data("Data1");
// data2 = Data("Data1");
// CHECK(!(data1 != data2));
// CHECK(!(data2 != data1));
//
// data1 = Data("Data1");
// data2 = Data("Data2");
// CHECK(data1 != data2);
// CHECK(data2 != data1);
//
// CHECK(etl::nullopt != data2);
// CHECK(data1 != etl::nullopt);
//
// CHECK(!(data1 != Data("Data1")));
// CHECK(data1 != Data("Data2"));
// CHECK(!(Data("Data1") != data1));
// CHECK(Data("Data2") != data1);
// }
//*************************************************************************
TEST(test_initialisation)
{
etl::optional<Data> data1;
etl::optional<Data> data2;
CHECK(!bool(data1));
CHECK(!bool(data2));
CHECK(!data1.has_value());
CHECK(!data2.has_value());
data1 = Data("Hello");
CHECK(bool(data1));
CHECK(data1.has_value());
CHECK_EQUAL(Data("Hello"), data1);
data1 = data2;
CHECK(!bool(data1));
CHECK(!bool(data2));
CHECK(!data1.has_value());
CHECK(!data2.has_value());
data1 = Data("World");
data2 = data1;
CHECK(bool(data1));
CHECK(bool(data2));
CHECK(data1.has_value());
CHECK(data2.has_value());
etl::optional<Data> data3(data1);
CHECK(bool(data3));
CHECK(data3.has_value());
CHECK_EQUAL(data1, data3);
etl::optional<Data> data4;
data4 = Data("Hello");
data4 = etl::nullopt;
CHECK(!bool(data4));
CHECK(!data4.has_value());
}
//*************************************************************************
//#include "etl/private/diagnostic_uninitialized_push.h"
TEST(test_deduced_initialisation)
{
Data data("Hello");
etl::optional opt{ data };
CHECK(opt.has_value());
CHECK(bool(opt));
CHECK_EQUAL(data, opt);
}
//*************************************************************************
TEST(test_emplace)
{
etl::optional<DataM> data;
data.emplace(1U);
CHECK_EQUAL(1U, data.value().value);
data.emplace(2U);
CHECK_EQUAL(2U, data.value().value);
data.emplace(3U);
CHECK_EQUAL(3U, data.value().value);
CHECK_EQUAL(1, DataM::get_instance_count());
}
//*************************************************************************
TEST(test_moveable)
{
#include "etl/private/diagnostic_pessimizing_move_push.h"
etl::optional<DataM> data(std::move(DataM(1)));
CHECK_EQUAL(1U, data.value().value);
CHECK(bool(data));
data = std::move(etl::optional<DataM>(std::move(DataM(2))));
CHECK_EQUAL(2U, data.value().value);
CHECK(bool(data));
etl::optional<DataM> data2(etl::move(data));
CHECK_EQUAL(2U, data2.value().value);
CHECK(bool(data2));
#include "etl/private/diagnostic_pop.h"
}
//*************************************************************************
TEST(test_nullopt)
{
etl::optional<Data> data;
data = Data("Hello");
data = etl::nullopt;
CHECK(!bool(data));
}
//*************************************************************************
TEST(test_value_or)
{
etl::optional<Data> data;
Data result = data.value_or(Data("Default"));
CHECK_EQUAL(Data("Default"), result);
data = Data("Value");
result = data.value_or(Data("Default"));
CHECK_EQUAL(Data("Value"), result);
}
//*************************************************************************
TEST(test_equality)
{
etl::optional<Data> data1;
etl::optional<Data> data2;
CHECK(data1 == data2);
CHECK(data2 == data1);
data1 = Data("Data1");
CHECK(!(data1 == data2));
CHECK(!(data2 == data1));
data1 = etl::nullopt;
data2 = Data("Data2");
CHECK(!(data1 == data2));
CHECK(!(data2 == data1));
data1 = Data("Data1");
data2 = Data("Data1");
CHECK(data1 == data2);
CHECK(data2 == data1);
data1 = Data("Data1");
data2 = Data("Data2");
CHECK(!(data1 == data2));
CHECK(!(data2 == data1));
CHECK(!(etl::nullopt == data2));
CHECK(!(data1 == etl::nullopt));
CHECK(data1 == Data("Data1"));
CHECK(!(data1 == Data("Data2")));
CHECK(Data("Data1") == data1);
CHECK(!(Data("Data2") == data1));
}
//*************************************************************************
TEST(test_inequality)
{
etl::optional<Data> data1;
etl::optional<Data> data2;
CHECK(!(data1 != data2));
CHECK(!(data2 != data1));
data1 = Data("Data1");
CHECK(data1 != data2);
CHECK(data2 != data1);
data1 = etl::nullopt;
data2 = Data("Data2");
CHECK(data1 != data2);
CHECK(data2 != data1);
data1 = Data("Data1");
data2 = Data("Data1");
CHECK(!(data1 != data2));
CHECK(!(data2 != data1));
data1 = Data("Data1");
data2 = Data("Data2");
CHECK(data1 != data2);
CHECK(data2 != data1);
CHECK(etl::nullopt != data2);
CHECK(data1 != etl::nullopt);
CHECK(!(data1 != Data("Data1")));
CHECK(data1 != Data("Data2"));
CHECK(!(Data("Data1") != data1));
CHECK(Data("Data2") != data1);
}
//*************************************************************************
#include "etl/private/diagnostic_uninitialized_push.h"
TEST(test_less_than)
{
struct S
{
std::string str;
};
etl::optional<Data> data1;
etl::optional<Data> data2;
etl::optional<S> data1;
etl::optional<S> data2;
CHECK(!(data2 < data1));
CHECK(!(data1 < data2));
//CHECK(!(data2 < data1));
//CHECK(!(data1 < data2));
data1 = Data("Data1");
CHECK(!(data1 < data2));
CHECK(data2 < data1);
//data1 = Data("Data1");
//CHECK(!(data1 < data2));
//CHECK(data2 < data1);
data1 = etl::nullopt;
data2 = Data("Data2");
CHECK(data1 < data2);
CHECK(!(data2 < data2));
//data1 = etl::nullopt;
//data2 = Data("Data2");
//CHECK(data1 < data2);
//CHECK(!(data2 < data2));
data1 = Data("Data1");
data2 = Data("Data2");
CHECK(data1 < data2);
CHECK(!(data2 < data1));
//data1 = Data("Data1");
//data2 = Data("Data2");
//CHECK(data1 < data2);
//CHECK(!(data2 < data1));
CHECK(etl::nullopt < data2);
CHECK(!(data1 < etl::nullopt));
//CHECK(etl::nullopt < data2);
//CHECK(!(data1 < etl::nullopt));
//CHECK(data1 < Data("Data2"));
//CHECK(!(data1 < Data("Data1")));
//CHECK(!(Data("Data2") < data1));
//CHECK(Data("Data1") < data2);
CHECK(data1 < Data("Data2"));
CHECK(!(data1 < Data("Data1")));
CHECK(!(Data("Data2") < data1));
CHECK(Data("Data1") < data2);
}
//#include "etl/private/diagnostic_pop.h"
#include "etl/private/diagnostic_pop.h"
// //*************************************************************************
// TEST(test_less_than_equal)
// {
// etl::optional<Data> data1;
// etl::optional<Data> data2;
//
// CHECK(data1 <= data2);
// CHECK(data2 <= data1);
//
// data1 = Data("Data1");
// CHECK(!(data1 <= data2));
// CHECK(data2 <= data1);
//
// data1 = etl::nullopt;
// data2 = Data("Data2");
// CHECK(data1 <= data2);
// CHECK(!(data2 <= data1));
//
// data1 = Data("Data1");
// data2 = Data("Data2");
// CHECK(data1 <= data2);
// CHECK(!(data2 <= data1));
//
// CHECK(etl::nullopt <= data2);
// CHECK(!(data1 <= etl::nullopt));
//
// CHECK(data1 <= Data("Data2"));
// CHECK(!(data2 <= Data("Data1")));
// CHECK(data1 <= Data("Data1"));
// CHECK(!(Data("Data2") <= data1));
// CHECK(Data("Data1") <= data2);
// CHECK(Data("Data1") <= data1);
// }
//
// //*************************************************************************
// TEST(test_greater_than)
// {
// etl::optional<Data> data1;
// etl::optional<Data> data2;
//
// CHECK(!(data1 > data2));
// CHECK(!(data2 > data1));
//
// data1 = Data("Data1");
// CHECK(data1 > data2);
// CHECK(!(data2 > data1));
//
// data1 = etl::nullopt;
// data2 = Data("Data2");
// CHECK(!(data1 > data2));
// CHECK(data2 > data1);
//
// data1 = Data("Data1");
// data2 = Data("Data2");
// CHECK(data2 > data1);
// CHECK(!(data1 > data2));
//
// CHECK(!(etl::nullopt > data2));
// CHECK(data1 > etl::nullopt);
//
// CHECK(!(data1 > Data("Data2")));
// CHECK(data2 > Data("Data1"));
// CHECK(Data("Data2") > data1);
// CHECK(!(Data("Data1") > data2));
// }
//
// //*************************************************************************
// TEST(test_greater_than_equal)
// {
// etl::optional<Data> data1;
// etl::optional<Data> data2;
//
// CHECK(data1 >= data2);
// CHECK(data2 >= data1);
//
// data1 = Data("Data1");
// CHECK(data1 >= data2);
// CHECK(!(data2 >= data1));
//
// data1 = etl::nullopt;
// data2 = Data("Data2");
// CHECK(!(data1 >= data2));
// CHECK(data2 >= data1);
//
// data1 = Data("Data1");
// data2 = Data("Data2");
// CHECK(!(data1 >= data2));
// CHECK(data2 >= data1);
//
// CHECK(!(etl::nullopt >= data2));
// CHECK(data1 >= etl::nullopt);
//
// CHECK(!(data1 >= Data("Data2")));
// CHECK(data2 >= Data("Data1"));
// CHECK(data1 >= Data("Data1"));
// CHECK(Data("Data2") >= data1);
// CHECK(!(Data("Data1") >= data2));
// CHECK(Data("Data1") >= data1);
// }
//
// //*************************************************************************
// TEST(test_container_of_optional)
// {
// etl::vector<etl::optional<Data>, 10> container;
//
// container.resize(5, Data("1"));
//
// CHECK(bool(container[0]));
// CHECK(bool(container[1]));
// CHECK(bool(container[2]));
// CHECK(bool(container[3]));
// CHECK(bool(container[4]));
// }
//
// //*************************************************************************
// TEST(test_optional_container)
// {
// // The indexed access doesn't work in Linux for some reason!!!
//#ifndef ETL_PLATFORM_LINUX
// etl::optional<etl::vector<Data, 10>> container;
// CHECK(!bool(container));//
//
// container = etl::vector<Data, 10>();
// CHECK(bool(container));
//
// container.value().resize(5, Data("1"));
// CHECK_EQUAL(5U, container.value().size());
//
// CHECK_EQUAL(Data("1"), container.value()[0]);
// CHECK_EQUAL(Data("1"), container.value()[1]);
// CHECK_EQUAL(Data("1"), container.value()[2]);
// CHECK_EQUAL(Data("1"), container.value()[3]);
// CHECK_EQUAL(Data("1"), container.value()[4]);
//#endif
// }
//*************************************************************************
TEST(test_less_than_equal)
{
etl::optional<Data> data1;
etl::optional<Data> data2;
CHECK(data1 <= data2);
CHECK(data2 <= data1);
data1 = Data("Data1");
CHECK(!(data1 <= data2));
CHECK(data2 <= data1);
data1 = etl::nullopt;
data2 = Data("Data2");
CHECK(data1 <= data2);
CHECK(!(data2 <= data1));
data1 = Data("Data1");
data2 = Data("Data2");
CHECK(data1 <= data2);
CHECK(!(data2 <= data1));
CHECK(etl::nullopt <= data2);
CHECK(!(data1 <= etl::nullopt));
CHECK(data1 <= Data("Data2"));
CHECK(!(data2 <= Data("Data1")));
CHECK(data1 <= Data("Data1"));
CHECK(!(Data("Data2") <= data1));
CHECK(Data("Data1") <= data2);
CHECK(Data("Data1") <= data1);
}
//*************************************************************************
TEST(test_greater_than)
{
etl::optional<Data> data1;
etl::optional<Data> data2;
CHECK(!(data1 > data2));
CHECK(!(data2 > data1));
data1 = Data("Data1");
CHECK(data1 > data2);
CHECK(!(data2 > data1));
data1 = etl::nullopt;
data2 = Data("Data2");
CHECK(!(data1 > data2));
CHECK(data2 > data1);
data1 = Data("Data1");
data2 = Data("Data2");
CHECK(data2 > data1);
CHECK(!(data1 > data2));
CHECK(!(etl::nullopt > data2));
CHECK(data1 > etl::nullopt);
CHECK(!(data1 > Data("Data2")));
CHECK(data2 > Data("Data1"));
CHECK(Data("Data2") > data1);
CHECK(!(Data("Data1") > data2));
}
//*************************************************************************
TEST(test_greater_than_equal)
{
etl::optional<Data> data1;
etl::optional<Data> data2;
CHECK(data1 >= data2);
CHECK(data2 >= data1);
data1 = Data("Data1");
CHECK(data1 >= data2);
CHECK(!(data2 >= data1));
data1 = etl::nullopt;
data2 = Data("Data2");
CHECK(!(data1 >= data2));
CHECK(data2 >= data1);
data1 = Data("Data1");
data2 = Data("Data2");
CHECK(!(data1 >= data2));
CHECK(data2 >= data1);
CHECK(!(etl::nullopt >= data2));
CHECK(data1 >= etl::nullopt);
CHECK(!(data1 >= Data("Data2")));
CHECK(data2 >= Data("Data1"));
CHECK(data1 >= Data("Data1"));
CHECK(Data("Data2") >= data1);
CHECK(!(Data("Data1") >= data2));
CHECK(Data("Data1") >= data1);
}
//*************************************************************************
TEST(test_container_of_optional)
{
etl::vector<etl::optional<Data>, 10> container;
container.resize(5, Data("1"));
CHECK(bool(container[0]));
CHECK(bool(container[1]));
CHECK(bool(container[2]));
CHECK(bool(container[3]));
CHECK(bool(container[4]));
}
//*************************************************************************
TEST(test_optional_container)
{
// The indexed access doesn't work in Linux for some reason!!!
#ifndef ETL_PLATFORM_LINUX
etl::optional<etl::vector<Data, 10>> container;
CHECK(!bool(container));//
container = etl::vector<Data, 10>();
CHECK(bool(container));
container.value().resize(5, Data("1"));
CHECK_EQUAL(5U, container.value().size());
CHECK_EQUAL(Data("1"), container.value()[0]);
CHECK_EQUAL(Data("1"), container.value()[1]);
CHECK_EQUAL(Data("1"), container.value()[2]);
CHECK_EQUAL(Data("1"), container.value()[3]);
CHECK_EQUAL(Data("1"), container.value()[4]);
#endif
}
//*************************************************************************
TEST(test_exception)
@ -423,83 +418,83 @@ namespace
CHECK_THROW(data1.value(), etl::optional_invalid);
}
////*************************************************************************
//TEST(test_swap)
//{
// etl::optional<Data> original1(Data("1"));
// etl::optional<Data> original2(Data("2"));
//*************************************************************************
TEST(test_swap)
{
etl::optional<Data> original1(Data("1"));
etl::optional<Data> original2(Data("2"));
// etl::optional<Data> data1;
// etl::optional<Data> data2;
etl::optional<Data> data1;
etl::optional<Data> data2;
// // Both invalid.
// swap(data1, data2);
// CHECK(!bool(data1));
// CHECK(!bool(data2));
// Both invalid.
swap(data1, data2);
CHECK(!bool(data1));
CHECK(!bool(data2));
// // Data1 valid;
// data1 = original1;
// data2 = etl::nullopt;
// swap(data1, data2);
// CHECK(!bool(data1));
// CHECK(bool(data2));
// CHECK_EQUAL(data2, original1);
// Data1 valid;
data1 = original1;
data2 = etl::nullopt;
swap(data1, data2);
CHECK(!bool(data1));
CHECK(bool(data2));
CHECK_EQUAL(data2, original1);
// // Data2 valid;
// data1 = etl::nullopt;
// data2 = original2;
// swap(data1, data2);
// CHECK(bool(data1));
// CHECK(!bool(data2));
// CHECK_EQUAL(data1, original2);
// Data2 valid;
data1 = etl::nullopt;
data2 = original2;
swap(data1, data2);
CHECK(bool(data1));
CHECK(!bool(data2));
CHECK_EQUAL(data1, original2);
// // Both valid;
// data1 = original1;
// data2 = original2;
// swap(data1, data2);
// CHECK(bool(data1));
// CHECK(bool(data2));
// CHECK_EQUAL(data1, original2);
// CHECK_EQUAL(data2, original1);
//}
// Both valid;
data1 = original1;
data2 = original2;
swap(data1, data2);
CHECK(bool(data1));
CHECK(bool(data2));
CHECK_EQUAL(data1, original2);
CHECK_EQUAL(data2, original1);
}
////*************************************************************************
//TEST(test_reset)
//{
// etl::optional<Data> data(Data("1"));
// CHECK(bool(data));
//*************************************************************************
TEST(test_reset)
{
etl::optional<Data> data(Data("1"));
CHECK(bool(data));
// data.reset();
// CHECK(!bool(data));
//}
data.reset();
CHECK(!bool(data));
}
////*************************************************************************
//etl::optional<std::uint8_t> get_optional_test_bug_634()
//{
// etl::optional<std::uint8_t> result = 8;
// result.reset();
//
// return result;
//}
//*************************************************************************
etl::optional<std::uint8_t> get_optional_test_bug_634()
{
etl::optional<std::uint8_t> result = 8;
result.reset();
return result;
}
//TEST(test_bug_634)
//{
// etl::optional<std::uint8_t> result;
TEST(test_bug_634)
{
etl::optional<std::uint8_t> result;
// result = get_optional_test_bug_634();
result = get_optional_test_bug_634();
// CHECK_EQUAL(false, result.has_value());
//}
CHECK_EQUAL(false, result.has_value());
}
////*************************************************************************
//TEST(test_optional_emplace_bug_636)
//{
// etl::optional<std::uint8_t> result = 1;
// result.emplace(2);
//*************************************************************************
TEST(test_optional_emplace_bug_636)
{
etl::optional<std::uint8_t> result = 1;
result.emplace(2);
// CHECK_TRUE(result.has_value());
// CHECK_EQUAL(2, result.value());
//}
CHECK_TRUE(result.has_value());
CHECK_EQUAL(2, result.value());
}
};
}

2
test/test_vector.cpp
View File

@ -796,6 +796,7 @@ namespace
}
//*************************************************************************
#include "etl/private/diagnostic_array_bounds_push.h"
TEST_FIXTURE(SetupFixture, test_insert_position_value_excess)
{
const size_t INITIAL_SIZE = SIZE;
@ -815,6 +816,7 @@ namespace
CHECK_THROW(data.insert(data.cbegin() + offset, INITIAL_VALUE), etl::vector_full);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_insert_position_n_value)

2
test/test_vector_external_buffer.cpp
View File

@ -782,6 +782,7 @@ namespace
}
//*************************************************************************
#include "etl/private/diagnostic_array_bounds_push.h"
TEST_FIXTURE(SetupFixture, test_insert_position_value_excess)
{
const size_t INITIAL_SIZE = SIZE;
@ -801,6 +802,7 @@ namespace
CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_insert_position_n_value)

2
test/test_vector_non_trivial.cpp
View File

@ -963,6 +963,7 @@ namespace
}
//*************************************************************************
#include "etl/private/diagnostic_array_bounds_push.h"
TEST_FIXTURE(SetupFixture, test_insert_position_value_excess)
{
const size_t INITIAL_SIZE = SIZE;
@ -983,6 +984,7 @@ namespace
CHECK_THROW(data.insert(data.begin() + offset, INITIAL_VALUE), etl::vector_full);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_insert_position_n_value)

6
test/test_vector_pointer.cpp
View File

@ -1179,10 +1179,11 @@ namespace
}
//*************************************************************************
#include "etl/private/diagnostic_array_bounds_push.h"
TEST_FIXTURE(SetupFixture, test_insert_position_value_excess)
{
const size_t INITIAL_SIZE = SIZE;
int INITIAL_VALUE = 1;
const size_t INITIAL_SIZE = SIZE;
int INITIAL_VALUE = 1;
Data data(INITIAL_SIZE, &INITIAL_VALUE);
@ -1198,6 +1199,7 @@ namespace
CHECK_THROW(data.insert(data.begin() + offset, &INITIAL_VALUE), etl::vector_full);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_emplace_position_value)

2
test/test_vector_pointer_external_buffer.cpp
View File

@ -1165,6 +1165,7 @@ namespace
}
//*************************************************************************
#include "etl/private/diagnostic_array_bounds_push.h"
TEST_FIXTURE(SetupFixture, test_insert_position_value_excess)
{
const size_t INITIAL_SIZE = SIZE;
@ -1184,6 +1185,7 @@ namespace
CHECK_THROW(data.insert(data.begin() + offset, &INITIAL_VALUE), etl::vector_full);
}
#include "etl/private/diagnostic_pop.h"
//*************************************************************************
TEST_FIXTURE(SetupFixture, test_emplace_position_value)

4
test/vs2019/etl.vcxproj
View File

@ -2525,6 +2525,7 @@
<ClInclude Include="..\..\include\etl\poly_span.h" />
<ClInclude Include="..\..\include\etl\private\bitset_legacy.h" />
<ClInclude Include="..\..\include\etl\private\bitset_new.h" />
<ClInclude Include="..\..\include\etl\private\diagnostic_array_bounds_push.h" />
<ClInclude Include="..\..\include\etl\private\diagnostic_uninitialized_push.h" />
<ClInclude Include="..\..\include\etl\private\diagnostic_pessimizing_move_push.h" />
<ClInclude Include="..\..\include\etl\private\diagnostic_pop.h" />
@ -12697,6 +12698,9 @@
<None Include="..\..\scripts\update_release.py" />
<None Include="..\meson.build" />
<None Include="..\runsanitychecks.sh" />
<None Include="..\runtests-01.sh" />
<None Include="..\runtests-02.sh" />
<None Include="..\runtests-03.sh" />
<None Include="..\runtests.sh" />
<None Include="cpp.hint" />
</ItemGroup>

12
test/vs2019/etl.vcxproj.filters
View File

@ -1344,6 +1344,9 @@
<ClInclude Include="..\..\include\etl\optional.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\include\etl\private\diagnostic_array_bounds_push.h">
<Filter>ETL\Private</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\test_string_char.cpp">
@ -3514,6 +3517,15 @@
<None Include="..\meson.build">
<Filter>Tests\Test Support</Filter>
</None>
<None Include="..\runtests-01.sh">
<Filter>Tests\Scripts</Filter>
</None>
<None Include="..\runtests-03.sh">
<Filter>Tests\Scripts</Filter>
</None>
<None Include="..\runtests-02.sh">
<Filter>Tests\Scripts</Filter>
</None>
</ItemGroup>
<ItemGroup>
<Text Include="..\..\support\Release notes.txt">

2
version.txt
View File

@ -1 +1 @@
20.35.12
20.35.13