feedc0de/ArduinoJson
1
0
Fork 0
forked from bblanchon/ArduinoJson
Code Pull Requests Activity

Clang-format: set DerivePointerAlignment to false

Browse Source
This commit is contained in:
Benoit Blanchon
2022-08-09 16:52:17 +02:00
parent 62e83133cd
commit 8002722f3b
53 changed files with 514 additions and 513 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
extras/fuzzing/json_fuzzer.cpp
View File

@ -1,6 +1,6 @@
#include <ArduinoJson.h>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
DynamicJsonDocument doc(4096);
DeserializationError error = deserializeJson(doc, data, size);
if (!error) {

2
extras/fuzzing/msgpack_fuzzer.cpp
View File

@ -1,6 +1,6 @@
#include <ArduinoJson.h>
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
DynamicJsonDocument doc(4096);
DeserializationError error = deserializeMsgPack(doc, data, size);
if (!error) {

4
extras/tests/JsonArray/std_string.cpp
View File

@ -5,8 +5,8 @@
#include <ArduinoJson.h>
#include <catch.hpp>
static void eraseString(std::string &str) {
char *p = const_cast<char *>(str.c_str());
static void eraseString(std::string& str) {
char* p = const_cast<char*>(str.c_str());
while (*p) *p++ = '*';
}

18
extras/tests/JsonDocument/ElementProxy.cpp
View File

@ -10,7 +10,7 @@ using namespace ARDUINOJSON_NAMESPACE;
TEST_CASE("ElementProxy::add()") {
DynamicJsonDocument doc(4096);
doc.add();
ElementProxy<JsonDocument &> ep = doc[0];
ElementProxy<JsonDocument&> ep = doc[0];
SECTION("add(int)") {
ep.add(42);
@ -36,7 +36,7 @@ TEST_CASE("ElementProxy::add()") {
TEST_CASE("ElementProxy::clear()") {
DynamicJsonDocument doc(4096);
doc.add();
ElementProxy<JsonDocument &> ep = doc[0];
ElementProxy<JsonDocument&> ep = doc[0];
SECTION("size goes back to zero") {
ep.add(42);
@ -96,7 +96,7 @@ TEST_CASE("ElementProxy::operator==()") {
TEST_CASE("ElementProxy::remove()") {
DynamicJsonDocument doc(4096);
doc.add();
ElementProxy<JsonDocument &> ep = doc[0];
ElementProxy<JsonDocument&> ep = doc[0];
SECTION("remove(int)") {
ep.add(1);
@ -143,7 +143,7 @@ TEST_CASE("ElementProxy::remove()") {
TEST_CASE("ElementProxy::set()") {
DynamicJsonDocument doc(4096);
ElementProxy<JsonDocument &> ep = doc[0];
ElementProxy<JsonDocument&> ep = doc[0];
SECTION("set(int)") {
ep.set(42);
@ -169,7 +169,7 @@ TEST_CASE("ElementProxy::set()") {
TEST_CASE("ElementProxy::size()") {
DynamicJsonDocument doc(4096);
doc.add();
ElementProxy<JsonDocument &> ep = doc[0];
ElementProxy<JsonDocument&> ep = doc[0];
SECTION("returns 0") {
REQUIRE(ep.size() == 0);
@ -191,7 +191,7 @@ TEST_CASE("ElementProxy::size()") {
TEST_CASE("ElementProxy::memoryUsage()") {
DynamicJsonDocument doc(4096);
doc.add();
ElementProxy<JsonDocument &> ep = doc[0];
ElementProxy<JsonDocument&> ep = doc[0];
SECTION("returns 0 for null") {
REQUIRE(ep.memoryUsage() == 0);
@ -205,7 +205,7 @@ TEST_CASE("ElementProxy::memoryUsage()") {
TEST_CASE("ElementProxy::operator[]") {
DynamicJsonDocument doc(4096);
ElementProxy<JsonDocument &> ep = doc[1];
ElementProxy<JsonDocument&> ep = doc[1];
SECTION("set member") {
ep["world"] = 42;
@ -224,7 +224,7 @@ TEST_CASE("ElementProxy cast to JsonVariantConst") {
DynamicJsonDocument doc(4096);
doc[0] = "world";
const ElementProxy<JsonDocument &> ep = doc[0];
const ElementProxy<JsonDocument&> ep = doc[0];
JsonVariantConst var = ep;
@ -235,7 +235,7 @@ TEST_CASE("ElementProxy cast to JsonVariant") {
DynamicJsonDocument doc(4096);
doc[0] = "world";
ElementProxy<JsonDocument &> ep = doc[0];
ElementProxy<JsonDocument&> ep = doc[0];
JsonVariant var = ep;

24
extras/tests/JsonDocument/MemberProxy.cpp
View File

@ -9,7 +9,7 @@ using namespace ARDUINOJSON_NAMESPACE;
TEST_CASE("MemberProxy::add()") {
DynamicJsonDocument doc(4096);
MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
SECTION("add(int)") {
mp.add(42);
@ -26,7 +26,7 @@ TEST_CASE("MemberProxy::add()") {
TEST_CASE("MemberProxy::clear()") {
DynamicJsonDocument doc(4096);
MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
SECTION("size goes back to zero") {
mp.add(42);
@ -85,7 +85,7 @@ TEST_CASE("MemberProxy::operator==()") {
TEST_CASE("MemberProxy::containsKey()") {
DynamicJsonDocument doc(4096);
MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
SECTION("containsKey(const char*)") {
mp["key"] = "value";
@ -115,9 +115,9 @@ TEST_CASE("MemberProxy::operator|()") {
SECTION("Issue #1411") {
doc["sensor"] = "gps";
const char *test = "test"; // <- the literal must be captured in a variable
const char* test = "test"; // <- the literal must be captured in a variable
// to trigger the bug
const char *sensor = doc["sensor"] | test; // "gps"
const char* sensor = doc["sensor"] | test; // "gps"
REQUIRE(sensor == std::string("gps"));
}
@ -136,7 +136,7 @@ TEST_CASE("MemberProxy::operator|()") {
TEST_CASE("MemberProxy::remove()") {
DynamicJsonDocument doc(4096);
MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
SECTION("remove(int)") {
mp.add(1);
@ -183,7 +183,7 @@ TEST_CASE("MemberProxy::remove()") {
TEST_CASE("MemberProxy::set()") {
DynamicJsonDocument doc(4096);
MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
SECTION("set(int)") {
mp.set(42);
@ -208,7 +208,7 @@ TEST_CASE("MemberProxy::set()") {
TEST_CASE("MemberProxy::size()") {
DynamicJsonDocument doc(4096);
MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
SECTION("returns 0") {
REQUIRE(mp.size() == 0);
@ -231,7 +231,7 @@ TEST_CASE("MemberProxy::size()") {
TEST_CASE("MemberProxy::memoryUsage()") {
DynamicJsonDocument doc(4096);
MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
SECTION("returns 0 when null") {
REQUIRE(mp.memoryUsage() == 0);
@ -245,7 +245,7 @@ TEST_CASE("MemberProxy::memoryUsage()") {
TEST_CASE("MemberProxy::operator[]") {
DynamicJsonDocument doc(4096);
MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
SECTION("set member") {
mp["world"] = 42;
@ -264,7 +264,7 @@ TEST_CASE("MemberProxy cast to JsonVariantConst") {
DynamicJsonDocument doc(4096);
doc["hello"] = "world";
const MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
const MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
JsonVariantConst var = mp;
@ -275,7 +275,7 @@ TEST_CASE("MemberProxy cast to JsonVariant") {
DynamicJsonDocument doc(4096);
doc["hello"] = "world";
MemberProxy<JsonDocument &, const char *> mp = doc["hello"];
MemberProxy<JsonDocument&, const char*> mp = doc["hello"];
JsonVariant var = mp;

4
extras/tests/JsonObject/std_string.cpp
View File

@ -5,8 +5,8 @@
#include <ArduinoJson.h>
#include <catch.hpp>
static void eraseString(std::string &str) {
char *p = const_cast<char *>(str.c_str());
static void eraseString(std::string& str) {
char* p = const_cast<char*>(str.c_str());
while (*p) *p++ = '*';
}

10
extras/tests/JsonSerializer/CustomWriter.cpp
View File

@ -14,18 +14,18 @@ class CustomWriter {
return 1;
}
size_t write(const uint8_t *s, size_t n) {
_str.append(reinterpret_cast<const char *>(s), n);
size_t write(const uint8_t* s, size_t n) {
_str.append(reinterpret_cast<const char*>(s), n);
return n;
}
const std::string &str() const {
const std::string& str() const {
return _str;
}
private:
CustomWriter(const CustomWriter &); // non-copiable
CustomWriter &operator=(const CustomWriter &);
CustomWriter(const CustomWriter&); // non-copiable
CustomWriter& operator=(const CustomWriter&);
std::string _str;
};

2
extras/tests/JsonSerializer/JsonArray.cpp
View File

@ -23,7 +23,7 @@ TEST_CASE("serializeJson(JsonArray)") {
}
SECTION("Null") {
array.add(static_cast<char *>(0));
array.add(static_cast<char*>(0));
check(array, "[null]");
}

6
extras/tests/JsonSerializer/JsonObject.cpp
View File

@ -6,7 +6,7 @@
#include <catch.hpp>
#include <string>
static void checkObject(const JsonObject obj, const std::string &expected) {
static void checkObject(const JsonObject obj, const std::string& expected) {
char actual[256];
memset(actual, '!', sizeof(actual));
@ -84,8 +84,8 @@ TEST_CASE("serializeJson(JsonObject)") {
}
SECTION("TwoNull") {
obj["a"] = static_cast<char *>(0);
obj["b"] = static_cast<char *>(0);
obj["a"] = static_cast<char*>(0);
obj["b"] = static_cast<char*>(0);
checkObject(obj, "{\"a\":null,\"b\":null}");
}

4
extras/tests/JsonSerializer/JsonVariant.cpp
View File

@ -7,7 +7,7 @@
#include <limits>
template <typename T>
void check(T value, const std::string &expected) {
void check(T value, const std::string& expected) {
DynamicJsonDocument doc(4096);
doc.to<JsonVariant>().set(value);
char buffer[256] = "";
@ -22,7 +22,7 @@ TEST_CASE("serializeJson(JsonVariant)") {
}
SECTION("Null string") {
check(static_cast<char *>(0), "null");
check(static_cast<char*>(0), "null");
}
SECTION("const char*") {

40
extras/tests/JsonVariant/is.cpp
View File

@ -19,7 +19,7 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<JsonVariant>() == false);
CHECK(variant.is<JsonVariantConst>() == false);
CHECK(variant.is<bool>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<const char*>() == false);
CHECK(variant.is<int>() == false);
CHECK(variant.is<std::string>() == false);
CHECK(variant.is<JsonString>() == false);
@ -34,7 +34,7 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<JsonObject>() == false);
CHECK(variant.is<JsonArray>() == false);
CHECK(variant.is<bool>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<const char*>() == false);
CHECK(variant.is<int>() == false);
CHECK(variant.is<std::string>() == false);
CHECK(variant.is<JsonString>() == false);
@ -50,7 +50,7 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<JsonVariantConst>() == true);
CHECK(variant.is<JsonObject>() == false);
CHECK(variant.is<JsonArray>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<const char*>() == false);
CHECK(variant.is<int>() == false);
CHECK(variant.is<std::string>() == false);
CHECK(variant.is<JsonString>() == false);
@ -66,7 +66,7 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<JsonVariantConst>() == true);
CHECK(variant.is<JsonObject>() == false);
CHECK(variant.is<JsonArray>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<const char*>() == false);
CHECK(variant.is<int>() == false);
CHECK(variant.is<std::string>() == false);
CHECK(variant.is<JsonString>() == false);
@ -88,7 +88,7 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<bool>() == false);
CHECK(variant.is<JsonObject>() == false);
CHECK(variant.is<JsonArray>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<const char*>() == false);
CHECK(variant.is<std::string>() == false);
CHECK(variant.is<JsonString>() == false);
}
@ -103,7 +103,7 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<bool>() == false);
CHECK(variant.is<JsonObject>() == false);
CHECK(variant.is<JsonArray>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<const char*>() == false);
CHECK(variant.is<int>() == false);
CHECK(variant.is<std::string>() == false);
CHECK(variant.is<JsonString>() == false);
@ -113,8 +113,8 @@ TEST_CASE("JsonVariant::is<T>()") {
SECTION("const char*") {
variant.set("4.2");
CHECK(variant.is<const char *>() == true);
CHECK(variant.is<const char *>() == true);
CHECK(variant.is<const char*>() == true);
CHECK(variant.is<const char*>() == true);
CHECK(variant.is<std::string>() == true);
CHECK(variant.is<JsonString>() == true);
CHECK(variant.is<JsonVariant>() == true);
@ -140,7 +140,7 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<int>() == false);
CHECK(variant.is<float>() == false);
CHECK(variant.is<bool>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<const char*>() == false);
CHECK(variant.is<MYENUM2>() == false);
}
@ -156,7 +156,7 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<int>() == false);
CHECK(variant.is<float>() == false);
CHECK(variant.is<bool>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<const char*>() == false);
CHECK(variant.is<MYENUM2>() == false);
CHECK(variant.is<JsonVariant>() == true);
CHECK(variant.is<JsonVariantConst>() == true);
@ -178,7 +178,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<JsonVariantConst>() == false);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
@ -192,7 +192,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
@ -208,7 +208,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
@ -224,7 +224,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
@ -246,7 +246,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
}
@ -261,7 +261,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
@ -271,8 +271,8 @@ TEST_CASE("JsonVariantConst::is<T>()") {
SECTION("const char*") {
variant.set("4.2");
CHECK(cvariant.is<const char *>() == true);
CHECK(cvariant.is<const char *>() == true);
CHECK(cvariant.is<const char*>() == true);
CHECK(cvariant.is<const char*>() == true);
CHECK(cvariant.is<std::string>() == true);
CHECK(cvariant.is<JsonString>() == true);
CHECK(cvariant.is<double>() == false);
@ -297,7 +297,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<float>() == false);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
@ -313,7 +313,7 @@ TEST_CASE("JsonVariantConst::is<T>()") {
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<float>() == false);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
}

10
extras/tests/JsonVariant/set.cpp
View File

@ -15,7 +15,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
char str[16];
strcpy(str, "hello");
bool result = variant.set(static_cast<const char *>(str));
bool result = variant.set(static_cast<const char*>(str));
strcpy(str, "world");
REQUIRE(result == true);
@ -23,7 +23,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
}
SECTION("(const char*)0") {
bool result = variant.set(static_cast<const char *>(0));
bool result = variant.set(static_cast<const char*>(0));
REQUIRE(result == true);
REQUIRE(variant.isNull());
@ -41,7 +41,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
}
SECTION("(char*)0") {
bool result = variant.set(static_cast<char *>(0));
bool result = variant.set(static_cast<char*>(0));
REQUIRE(result == true);
REQUIRE(variant.isNull());
@ -51,7 +51,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
char str[16];
strcpy(str, "hello");
bool result = variant.set(reinterpret_cast<unsigned char *>(str));
bool result = variant.set(reinterpret_cast<unsigned char*>(str));
strcpy(str, "world");
REQUIRE(result == true);
@ -62,7 +62,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
char str[16];
strcpy(str, "hello");
bool result = variant.set(reinterpret_cast<signed char *>(str));
bool result = variant.set(reinterpret_cast<signed char*>(str));
strcpy(str, "world");
REQUIRE(result == true);

8
extras/tests/JsonVariant/types.cpp
View File

@ -17,9 +17,9 @@ void checkValue(T expected) {
}
template <typename T>
void checkReference(T &expected) {
void checkReference(T& expected) {
JsonVariant variant = expected;
REQUIRE(expected == variant.as<T &>());
REQUIRE(expected == variant.as<T&>());
}
template <typename T>
@ -46,10 +46,10 @@ TEST_CASE("JsonVariant set()/get()") {
#endif
SECTION("Null") {
checkValue<const char *>(NULL);
checkValue<const char*>(NULL);
}
SECTION("const char*") {
checkValue<const char *>("hello");
checkValue<const char*>("hello");
}
SECTION("std::string") {
checkValue<std::string>("hello");

2
extras/tests/MemoryPool/clear.cpp
View File

@ -22,7 +22,7 @@ TEST_CASE("MemoryPool::clear()") {
}
SECTION("Discards allocated strings") {
pool.saveString(adaptString(const_cast<char *>("123456789")));
pool.saveString(adaptString(const_cast<char*>("123456789")));
REQUIRE(pool.size() == 10);
pool.clear();

40
extras/tests/MemoryPool/saveString.cpp
View File

@ -8,11 +8,11 @@
using namespace ARDUINOJSON_NAMESPACE;
static const char *saveString(MemoryPool &pool, const char *s) {
return pool.saveString(adaptString(const_cast<char *>(s)));
static const char* saveString(MemoryPool& pool, const char* s) {
return pool.saveString(adaptString(const_cast<char*>(s)));
}
static const char *saveString(MemoryPool &pool, const char *s, size_t n) {
static const char* saveString(MemoryPool& pool, const char* s, size_t n) {
return pool.saveString(adaptString(s, n));
}
@ -21,36 +21,36 @@ TEST_CASE("MemoryPool::saveString()") {
MemoryPool pool(buffer, 32);
SECTION("Duplicates different strings") {
const char *a = saveString(pool, "hello");
const char *b = saveString(pool, "world");
const char* a = saveString(pool, "hello");
const char* b = saveString(pool, "world");
REQUIRE(a != b);
REQUIRE(pool.size() == 6 + 6);
}
SECTION("Deduplicates identical strings") {
const char *a = saveString(pool, "hello");
const char *b = saveString(pool, "hello");
const char* a = saveString(pool, "hello");
const char* b = saveString(pool, "hello");
REQUIRE(a == b);
REQUIRE(pool.size() == 6);
}
SECTION("Deduplicates identical strings that contain NUL") {
const char *a = saveString(pool, "hello\0world", 11);
const char *b = saveString(pool, "hello\0world", 11);
const char* a = saveString(pool, "hello\0world", 11);
const char* b = saveString(pool, "hello\0world", 11);
REQUIRE(a == b);
REQUIRE(pool.size() == 12);
}
SECTION("Reuse part of a string if it ends with NUL") {
const char *a = saveString(pool, "hello\0world", 11);
const char *b = saveString(pool, "hello");
const char* a = saveString(pool, "hello\0world", 11);
const char* b = saveString(pool, "hello");
REQUIRE(a == b);
REQUIRE(pool.size() == 12);
}
SECTION("Don't stop on first NUL") {
const char *a = saveString(pool, "hello");
const char *b = saveString(pool, "hello\0world", 11);
const char* a = saveString(pool, "hello");
const char* b = saveString(pool, "hello\0world", 11);
REQUIRE(a != b);
REQUIRE(pool.size() == 18);
}
@ -58,16 +58,16 @@ TEST_CASE("MemoryPool::saveString()") {
SECTION("Returns NULL when full") {
REQUIRE(pool.capacity() == 32);
const void *p1 = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
const void* p1 = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
REQUIRE(p1 != 0);
REQUIRE(pool.size() == 32);
const void *p2 = saveString(pool, "b");
const void* p2 = saveString(pool, "b");
REQUIRE(p2 == 0);
}
SECTION("Returns NULL when pool is too small") {
const void *p = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
const void* p = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
REQUIRE(0 == p);
}
@ -82,15 +82,15 @@ TEST_CASE("MemoryPool::saveString()") {
}
SECTION("Returns same address after clear()") {
const void *a = saveString(pool, "hello");
const void* a = saveString(pool, "hello");
pool.clear();
const void *b = saveString(pool, "world");
const void* b = saveString(pool, "world");
REQUIRE(a == b);
}
SECTION("Can use full capacity when fresh") {
const void *a = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
const void* a = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
REQUIRE(a != 0);
}
@ -99,7 +99,7 @@ TEST_CASE("MemoryPool::saveString()") {
saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
pool.clear();
const void *a = saveString(pool, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
const void* a = saveString(pool, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
REQUIRE(a != 0);
}

2
extras/tests/MsgPackSerializer/destination_types.cpp
View File

@ -9,7 +9,7 @@ TEST_CASE("serialize MsgPack to various destination types") {
DynamicJsonDocument doc(4096);
JsonObject object = doc.to<JsonObject>();
object["hello"] = "world";
const char *expected_result = "\x81\xA5hello\xA5world";
const char* expected_result = "\x81\xA5hello\xA5world";
const size_t expected_length = 13;
SECTION("std::string") {

2
extras/tests/MsgPackSerializer/misc.cpp
View File

@ -3,7 +3,7 @@
#include <limits>
template <typename T>
void check(T value, const std::string &expected) {
void check(T value, const std::string& expected) {
DynamicJsonDocument doc(4096);
doc.to<JsonVariant>().set(value);
char buffer[256] = "";