Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-23 01:21:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

[ntcore] NetworkTables 4 (#3217)

Browse Source
This commit is contained in:
Peter Johnson
2022-10-08 10:01:31 -07:00
committed by GitHub
parent 90cfa00115
commit 77301b126c
380 changed files with 34573 additions and 22095 deletions
Download Patch File Download Diff File Expand all files Collapse all files

176
ntcore/src/test/native/cpp/ValueTest.cpp
View File

@@ -13,8 +13,8 @@
using namespace std::string_view_literals;
namespace wpi {
template <typename T>
inline bool operator==(span<T> lhs, span<T> rhs) {
template <typename T, typename U>
inline bool operator==(span<T> lhs, span<U> rhs) {
if (lhs.size() != rhs.size()) {
return false;
}
@@ -35,19 +35,19 @@ TEST_F(ValueTest, ConstructEmpty) {
TEST_F(ValueTest, Boolean) {
auto v = Value::MakeBoolean(false);
ASSERT_EQ(NT_BOOLEAN, v->type());
ASSERT_FALSE(v->GetBoolean());
ASSERT_EQ(NT_BOOLEAN, v.type());
ASSERT_FALSE(v.GetBoolean());
NT_Value cv;
NT_InitValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_BOOLEAN, cv.type);
ASSERT_EQ(0, cv.data.v_boolean);
v = Value::MakeBoolean(true);
ASSERT_EQ(NT_BOOLEAN, v->type());
ASSERT_TRUE(v->GetBoolean());
ASSERT_EQ(NT_BOOLEAN, v.type());
ASSERT_TRUE(v.GetBoolean());
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_BOOLEAN, cv.type);
ASSERT_EQ(1, cv.data.v_boolean);
@@ -56,19 +56,19 @@ TEST_F(ValueTest, Boolean) {
TEST_F(ValueTest, Double) {
auto v = Value::MakeDouble(0.5);
ASSERT_EQ(NT_DOUBLE, v->type());
ASSERT_EQ(0.5, v->GetDouble());
ASSERT_EQ(NT_DOUBLE, v.type());
ASSERT_EQ(0.5, v.GetDouble());
NT_Value cv;
NT_InitValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_DOUBLE, cv.type);
ASSERT_EQ(0.5, cv.data.v_double);
v = Value::MakeDouble(0.25);
ASSERT_EQ(NT_DOUBLE, v->type());
ASSERT_EQ(0.25, v->GetDouble());
ASSERT_EQ(NT_DOUBLE, v.type());
ASSERT_EQ(0.25, v.GetDouble());
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_DOUBLE, cv.type);
ASSERT_EQ(0.25, cv.data.v_double);
@@ -77,20 +77,20 @@ TEST_F(ValueTest, Double) {
TEST_F(ValueTest, String) {
auto v = Value::MakeString("hello");
ASSERT_EQ(NT_STRING, v->type());
ASSERT_EQ("hello", v->GetString());
ASSERT_EQ(NT_STRING, v.type());
ASSERT_EQ("hello", v.GetString());
NT_Value cv;
NT_InitValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_STRING, cv.type);
ASSERT_EQ("hello"sv, cv.data.v_string.str);
ASSERT_EQ(5u, cv.data.v_string.len);
v = Value::MakeString("goodbye");
ASSERT_EQ(NT_STRING, v->type());
ASSERT_EQ("goodbye", v->GetString());
ASSERT_EQ(NT_STRING, v.type());
ASSERT_EQ("goodbye", v.GetString());
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_STRING, cv.type);
ASSERT_EQ("goodbye"sv, cv.data.v_string.str);
ASSERT_EQ(7u, cv.data.v_string.len);
@@ -99,24 +99,28 @@ TEST_F(ValueTest, String) {
}
TEST_F(ValueTest, Raw) {
auto v = Value::MakeRaw("hello");
ASSERT_EQ(NT_RAW, v->type());
ASSERT_EQ("hello", v->GetRaw());
std::vector<uint8_t> arr{5, 4, 3, 2, 1};
auto v = Value::MakeRaw(arr);
ASSERT_EQ(NT_RAW, v.type());
ASSERT_EQ(wpi::span<const uint8_t>(arr), v.GetRaw());
NT_Value cv;
NT_InitValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_RAW, cv.type);
ASSERT_EQ("hello"sv, cv.data.v_string.str);
ASSERT_EQ(5u, cv.data.v_string.len);
ASSERT_EQ(5u, cv.data.v_raw.size);
ASSERT_EQ(wpi::span(reinterpret_cast<const uint8_t*>("\5\4\3\2\1"), 5),
wpi::span(cv.data.v_raw.data, 5));
v = Value::MakeRaw("goodbye");
ASSERT_EQ(NT_RAW, v->type());
ASSERT_EQ("goodbye", v->GetRaw());
std::vector<uint8_t> arr2{1, 2, 3, 4, 5, 6};
v = Value::MakeRaw(arr2);
ASSERT_EQ(NT_RAW, v.type());
ASSERT_EQ(wpi::span<const uint8_t>(arr2), v.GetRaw());
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_RAW, cv.type);
ASSERT_EQ("goodbye"sv, cv.data.v_string.str);
ASSERT_EQ(7u, cv.data.v_string.len);
ASSERT_EQ(6u, cv.data.v_raw.size);
ASSERT_EQ(wpi::span(reinterpret_cast<const uint8_t*>("\1\2\3\4\5\6"), 6),
wpi::span(cv.data.v_raw.data, 6));
NT_DisposeValue(&cv);
}
@@ -124,11 +128,11 @@ TEST_F(ValueTest, Raw) {
TEST_F(ValueTest, BooleanArray) {
std::vector<int> vec{1, 0, 1};
auto v = Value::MakeBooleanArray(vec);
ASSERT_EQ(NT_BOOLEAN_ARRAY, v->type());
ASSERT_EQ(wpi::span<const int>(vec), v->GetBooleanArray());
ASSERT_EQ(NT_BOOLEAN_ARRAY, v.type());
ASSERT_EQ(wpi::span<const int>(vec), v.GetBooleanArray());
NT_Value cv;
NT_InitValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_BOOLEAN_ARRAY, cv.type);
ASSERT_EQ(3u, cv.data.arr_boolean.size);
ASSERT_EQ(vec[0], cv.data.arr_boolean.arr[0]);
@@ -138,10 +142,10 @@ TEST_F(ValueTest, BooleanArray) {
// assign with same size
vec = {0, 1, 0};
v = Value::MakeBooleanArray(vec);
ASSERT_EQ(NT_BOOLEAN_ARRAY, v->type());
ASSERT_EQ(wpi::span<const int>(vec), v->GetBooleanArray());
ASSERT_EQ(NT_BOOLEAN_ARRAY, v.type());
ASSERT_EQ(wpi::span<const int>(vec), v.GetBooleanArray());
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_BOOLEAN_ARRAY, cv.type);
ASSERT_EQ(3u, cv.data.arr_boolean.size);
ASSERT_EQ(vec[0], cv.data.arr_boolean.arr[0]);
@@ -151,10 +155,10 @@ TEST_F(ValueTest, BooleanArray) {
// assign with different size
vec = {1, 0};
v = Value::MakeBooleanArray(vec);
ASSERT_EQ(NT_BOOLEAN_ARRAY, v->type());
ASSERT_EQ(wpi::span<const int>(vec), v->GetBooleanArray());
ASSERT_EQ(NT_BOOLEAN_ARRAY, v.type());
ASSERT_EQ(wpi::span<const int>(vec), v.GetBooleanArray());
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_BOOLEAN_ARRAY, cv.type);
ASSERT_EQ(2u, cv.data.arr_boolean.size);
ASSERT_EQ(vec[0], cv.data.arr_boolean.arr[0]);
@@ -166,11 +170,11 @@ TEST_F(ValueTest, BooleanArray) {
TEST_F(ValueTest, DoubleArray) {
std::vector<double> vec{0.5, 0.25, 0.5};
auto v = Value::MakeDoubleArray(vec);
ASSERT_EQ(NT_DOUBLE_ARRAY, v->type());
ASSERT_EQ(wpi::span<const double>(vec), v->GetDoubleArray());
ASSERT_EQ(NT_DOUBLE_ARRAY, v.type());
ASSERT_EQ(wpi::span<const double>(vec), v.GetDoubleArray());
NT_Value cv;
NT_InitValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_DOUBLE_ARRAY, cv.type);
ASSERT_EQ(3u, cv.data.arr_double.size);
ASSERT_EQ(vec[0], cv.data.arr_double.arr[0]);
@@ -180,10 +184,10 @@ TEST_F(ValueTest, DoubleArray) {
// assign with same size
vec = {0.25, 0.5, 0.25};
v = Value::MakeDoubleArray(vec);
ASSERT_EQ(NT_DOUBLE_ARRAY, v->type());
ASSERT_EQ(wpi::span<const double>(vec), v->GetDoubleArray());
ASSERT_EQ(NT_DOUBLE_ARRAY, v.type());
ASSERT_EQ(wpi::span<const double>(vec), v.GetDoubleArray());
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_DOUBLE_ARRAY, cv.type);
ASSERT_EQ(3u, cv.data.arr_double.size);
ASSERT_EQ(vec[0], cv.data.arr_double.arr[0]);
@@ -193,10 +197,10 @@ TEST_F(ValueTest, DoubleArray) {
// assign with different size
vec = {0.5, 0.25};
v = Value::MakeDoubleArray(vec);
ASSERT_EQ(NT_DOUBLE_ARRAY, v->type());
ASSERT_EQ(wpi::span<const double>(vec), v->GetDoubleArray());
ASSERT_EQ(NT_DOUBLE_ARRAY, v.type());
ASSERT_EQ(wpi::span<const double>(vec), v.GetDoubleArray());
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_DOUBLE_ARRAY, cv.type);
ASSERT_EQ(2u, cv.data.arr_double.size);
ASSERT_EQ(vec[0], cv.data.arr_double.arr[0]);
@@ -211,14 +215,14 @@ TEST_F(ValueTest, StringArray) {
vec.push_back("goodbye");
vec.push_back("string");
auto v = Value::MakeStringArray(std::move(vec));
ASSERT_EQ(NT_STRING_ARRAY, v->type());
ASSERT_EQ(3u, v->GetStringArray().size());
ASSERT_EQ("hello"sv, v->GetStringArray()[0]);
ASSERT_EQ("goodbye"sv, v->GetStringArray()[1]);
ASSERT_EQ("string"sv, v->GetStringArray()[2]);
ASSERT_EQ(NT_STRING_ARRAY, v.type());
ASSERT_EQ(3u, v.GetStringArray().size());
ASSERT_EQ("hello"sv, v.GetStringArray()[0]);
ASSERT_EQ("goodbye"sv, v.GetStringArray()[1]);
ASSERT_EQ("string"sv, v.GetStringArray()[2]);
NT_Value cv;
NT_InitValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_STRING_ARRAY, cv.type);
ASSERT_EQ(3u, cv.data.arr_string.size);
ASSERT_EQ("hello"sv, cv.data.arr_string.arr[0].str);
@@ -231,13 +235,13 @@ TEST_F(ValueTest, StringArray) {
vec.push_back("str2");
vec.push_back("string3");
v = Value::MakeStringArray(vec);
ASSERT_EQ(NT_STRING_ARRAY, v->type());
ASSERT_EQ(3u, v->GetStringArray().size());
ASSERT_EQ("s1"sv, v->GetStringArray()[0]);
ASSERT_EQ("str2"sv, v->GetStringArray()[1]);
ASSERT_EQ("string3"sv, v->GetStringArray()[2]);
ASSERT_EQ(NT_STRING_ARRAY, v.type());
ASSERT_EQ(3u, v.GetStringArray().size());
ASSERT_EQ("s1"sv, v.GetStringArray()[0]);
ASSERT_EQ("str2"sv, v.GetStringArray()[1]);
ASSERT_EQ("string3"sv, v.GetStringArray()[2]);
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_STRING_ARRAY, cv.type);
ASSERT_EQ(3u, cv.data.arr_string.size);
ASSERT_EQ("s1"sv, cv.data.arr_string.arr[0].str);
@@ -249,12 +253,12 @@ TEST_F(ValueTest, StringArray) {
vec.push_back("short");
vec.push_back("er");
v = Value::MakeStringArray(std::move(vec));
ASSERT_EQ(NT_STRING_ARRAY, v->type());
ASSERT_EQ(2u, v->GetStringArray().size());
ASSERT_EQ("short"sv, v->GetStringArray()[0]);
ASSERT_EQ("er"sv, v->GetStringArray()[1]);
ASSERT_EQ(NT_STRING_ARRAY, v.type());
ASSERT_EQ(2u, v.GetStringArray().size());
ASSERT_EQ("short"sv, v.GetStringArray()[0]);
ASSERT_EQ("er"sv, v.GetStringArray()[1]);
NT_DisposeValue(&cv);
ConvertToC(*v, &cv);
ConvertToC(v, &cv);
ASSERT_EQ(NT_STRING_ARRAY, cv.type);
ASSERT_EQ(2u, cv.data.arr_string.size);
ASSERT_EQ("short"sv, cv.data.arr_string.arr[0].str);
@@ -286,69 +290,69 @@ TEST_F(ValueTest, UnassignedComparison) {
TEST_F(ValueTest, MixedComparison) {
Value v1;
auto v2 = Value::MakeBoolean(true);
ASSERT_NE(v1, *v2); // unassigned vs boolean
ASSERT_NE(v1, v2); // unassigned vs boolean
auto v3 = Value::MakeDouble(0.5);
ASSERT_NE(*v2, *v3); // boolean vs double
ASSERT_NE(v2, v3); // boolean vs double
}
TEST_F(ValueTest, BooleanComparison) {
auto v1 = Value::MakeBoolean(true);
auto v2 = Value::MakeBoolean(true);
ASSERT_EQ(*v1, *v2);
ASSERT_EQ(v1, v2);
v2 = Value::MakeBoolean(false);
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
}
TEST_F(ValueTest, DoubleComparison) {
auto v1 = Value::MakeDouble(0.25);
auto v2 = Value::MakeDouble(0.25);
ASSERT_EQ(*v1, *v2);
ASSERT_EQ(v1, v2);
v2 = Value::MakeDouble(0.5);
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
}
TEST_F(ValueTest, StringComparison) {
auto v1 = Value::MakeString("hello");
auto v2 = Value::MakeString("hello");
ASSERT_EQ(*v1, *v2);
ASSERT_EQ(v1, v2);
v2 = Value::MakeString("world"); // different contents
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
v2 = Value::MakeString("goodbye"); // different size
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
}
TEST_F(ValueTest, BooleanArrayComparison) {
std::vector<int> vec{1, 0, 1};
auto v1 = Value::MakeBooleanArray(vec);
auto v2 = Value::MakeBooleanArray(vec);
ASSERT_EQ(*v1, *v2);
ASSERT_EQ(v1, v2);
// different contents
vec = {1, 1, 1};
v2 = Value::MakeBooleanArray(vec);
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
// different size
vec = {1, 0};
v2 = Value::MakeBooleanArray(vec);
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
}
TEST_F(ValueTest, DoubleArrayComparison) {
std::vector<double> vec{0.5, 0.25, 0.5};
auto v1 = Value::MakeDoubleArray(vec);
auto v2 = Value::MakeDoubleArray(vec);
ASSERT_EQ(*v1, *v2);
ASSERT_EQ(v1, v2);
// different contents
vec = {0.5, 0.5, 0.5};
v2 = Value::MakeDoubleArray(vec);
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
// different size
vec = {0.5, 0.25};
v2 = Value::MakeDoubleArray(vec);
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
}
TEST_F(ValueTest, StringArrayComparison) {
@@ -362,7 +366,7 @@ TEST_F(ValueTest, StringArrayComparison) {
vec.push_back("goodbye");
vec.push_back("string");
auto v2 = Value::MakeStringArray(std::move(vec));
ASSERT_EQ(*v1, *v2);
ASSERT_EQ(v1, v2);
// different contents
vec.clear();
@@ -370,7 +374,7 @@ TEST_F(ValueTest, StringArrayComparison) {
vec.push_back("goodby2");
vec.push_back("string");
v2 = Value::MakeStringArray(std::move(vec));
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
// different sized contents
vec.clear();
@@ -378,14 +382,14 @@ TEST_F(ValueTest, StringArrayComparison) {
vec.push_back("goodbye2");
vec.push_back("string");
v2 = Value::MakeStringArray(vec);
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
// different size
vec.clear();
vec.push_back("hello");
vec.push_back("goodbye");
v2 = Value::MakeStringArray(std::move(vec));
ASSERT_NE(*v1, *v2);
ASSERT_NE(v1, v2);
}
} // namespace nt