diff --git a/src/Message.cpp b/src/Message.cpp index ca0a452003..509ac9f6a7 100644 --- a/src/Message.cpp +++ b/src/Message.cpp @@ -59,8 +59,8 @@ std::shared_ptr Message::Read(WireDecoder& decoder, if (decoder.proto_rev() >= 0x0300u) { if (!decoder.Read8(&msg->m_flags)) return nullptr; // flags } - msg->m_value = std::make_shared(); - if (!decoder.ReadValue(type, &(*msg->m_value))) return nullptr; + msg->m_value = decoder.ReadValue(type); + if (!msg->m_value) return nullptr; break; } case kEntryUpdate: { @@ -73,8 +73,8 @@ std::shared_ptr Message::Read(WireDecoder& decoder, type = static_cast(itype); } else type = get_entry_type(msg->m_id); - msg->m_value = std::make_shared(); - if (!decoder.ReadValue(type, &(*msg->m_value))) return nullptr; + msg->m_value = decoder.ReadValue(type); + if (!msg->m_value) return nullptr; break; } case kFlagsUpdate: { @@ -196,7 +196,7 @@ std::shared_ptr Message::EntryDelete(unsigned int id) { } std::shared_ptr Message::ExecuteRpc(unsigned int id, unsigned int uid, - llvm::ArrayRef params) { + llvm::ArrayRef params) { WireEncoder enc(0x0300); for (auto& param : params) enc.WriteValue(param); return ExecuteRpc(id, uid, enc.ToStringRef()); @@ -212,7 +212,7 @@ std::shared_ptr Message::ExecuteRpc(unsigned int id, unsigned int uid, } std::shared_ptr Message::RpcResponse( - unsigned int id, unsigned int uid, llvm::ArrayRef results) { + unsigned int id, unsigned int uid, llvm::ArrayRef results) { WireEncoder enc(0x0300); for (auto& result : results) enc.WriteValue(result); return RpcResponse(id, uid, enc.ToStringRef()); diff --git a/src/Message.h b/src/Message.h index 0bc0c4cb2b..a5d5655915 100644 --- a/src/Message.h +++ b/src/Message.h @@ -9,6 +9,7 @@ #define NT_MESSAGE_H_ #include +#include #include "Value.h" @@ -84,24 +85,22 @@ class Message { unsigned int flags); static std::shared_ptr EntryDelete(unsigned int id); static std::shared_ptr ExecuteRpc(unsigned int id, unsigned int uid, - llvm::ArrayRef params); + llvm::ArrayRef params); static std::shared_ptr ExecuteRpc(unsigned int id, unsigned int uid, llvm::StringRef params); static std::shared_ptr RpcResponse(unsigned int id, unsigned int uid, - llvm::ArrayRef results); + llvm::ArrayRef results); static std::shared_ptr RpcResponse(unsigned int id, unsigned int uid, llvm::StringRef results); Message(const Message&) = delete; Message& operator=(const Message&) = delete; - Message(Message&&) = default; - Message& operator=(Message&&) = default; private: MsgType m_type; // Message data. Use varies by message type. - StringValue m_str; + std::string m_str; std::shared_ptr m_value; unsigned int m_id; // also used for proto_rev unsigned int m_flags; diff --git a/src/Storage.cpp b/src/Storage.cpp index 5d87e34d2c..9f64fbf7a8 100644 --- a/src/Storage.cpp +++ b/src/Storage.cpp @@ -65,8 +65,9 @@ void Storage::SavePersistent(std::ostream& os) const { if (!entry.IsPersistent()) continue; // type - const Value& v = entry.value(); - switch (v.type()) { + auto v = entry.value(); + if (!v) continue; + switch (v->type()) { case NT_BOOLEAN: os << "boolean "; break; @@ -99,23 +100,23 @@ void Storage::SavePersistent(std::ostream& os) const { os << '='; // value - switch (v.type()) { + switch (v->type()) { case NT_BOOLEAN: - os << (v.GetBoolean() ? "true" : "false"); + os << (v->GetBoolean() ? "true" : "false"); break; case NT_DOUBLE: - os << v.GetDouble(); + os << v->GetDouble(); break; case NT_STRING: - WriteString(os, v.GetString()); + WriteString(os, v->GetString()); break; case NT_RAW: - Base64Encode(v.GetRaw(), &base64_encoded); + Base64Encode(v->GetRaw(), &base64_encoded); os << base64_encoded; break; case NT_BOOLEAN_ARRAY: { bool first = true; - for (auto elem : v.GetBooleanArray()) { + for (auto elem : v->GetBooleanArray()) { if (!first) { os << ','; first = false; @@ -126,7 +127,7 @@ void Storage::SavePersistent(std::ostream& os) const { } case NT_DOUBLE_ARRAY: { bool first = true; - for (auto elem : v.GetDoubleArray()) { + for (auto elem : v->GetDoubleArray()) { if (!first) { os << ','; first = false; @@ -137,7 +138,7 @@ void Storage::SavePersistent(std::ostream& os) const { } case NT_STRING_ARRAY: { bool first = true; - for (auto& elem : v.GetStringArray()) { + for (auto& elem : v->GetStringArray()) { if (!first) { os << ','; first = false; @@ -241,7 +242,7 @@ bool Storage::LoadPersistent(std::istream& is, std::string name, str; std::vector boolean_array; std::vector double_array; - std::vector string_array; + std::vector string_array; // ignore blank lines and lines that start with ; or # (comments) while (std::getline(is, line_str)) { @@ -311,9 +312,9 @@ bool Storage::LoadPersistent(std::istream& is, case NT_BOOLEAN: // only true or false is accepted if (line == "true") - entry.value().SetBoolean(true); + entry.set_value(Value::MakeBoolean(true)); else if (line == "false") - entry.value().SetBoolean(false); + entry.set_value(Value::MakeBoolean(false)); else { if (warn) warn(line_num, "unrecognized boolean value, not 'true' or 'false'"); @@ -330,7 +331,7 @@ bool Storage::LoadPersistent(std::istream& is, if (warn) warn(line_num, "invalid double value"); goto next_line; } - entry.value().SetDouble(v); + entry.set_value(Value::MakeDouble(v)); break; } case NT_STRING: { @@ -345,12 +346,12 @@ bool Storage::LoadPersistent(std::istream& is, goto next_line; } UnescapeString(str_tok, &str); - entry.value().SetString(str); + entry.set_value(Value::MakeString(std::move(str))); break; } case NT_RAW: Base64Decode(line, &str); - entry.value().SetRaw(str); + entry.set_value(Value::MakeRaw(std::move(str))); break; case NT_BOOLEAN_ARRAY: { llvm::StringRef elem_tok; @@ -370,7 +371,7 @@ bool Storage::LoadPersistent(std::istream& is, } } - entry.value().SetBooleanArray(boolean_array); + entry.set_value(Value::MakeBooleanArray(std::move(boolean_array))); break; } case NT_DOUBLE_ARRAY: { @@ -391,7 +392,7 @@ bool Storage::LoadPersistent(std::istream& is, double_array.push_back(v); } - entry.value().SetDoubleArray(double_array); + entry.set_value(Value::MakeDoubleArray(std::move(double_array))); break; } case NT_STRING_ARRAY: { @@ -416,10 +417,10 @@ bool Storage::LoadPersistent(std::istream& is, line = line.drop_front().ltrim(" \t"); UnescapeString(elem_tok, &str); - string_array.push_back(StringValue(str)); + string_array.push_back(std::move(str)); } - entry.value().SetStringArray(string_array); + entry.set_value(Value::MakeStringArray(std::move(string_array))); break; } default: diff --git a/src/Storage.h b/src/Storage.h index 61ece6cb68..906c4b98c1 100644 --- a/src/Storage.h +++ b/src/Storage.h @@ -21,20 +21,21 @@ namespace ntimpl { class StorageEntry { public: - StorageEntry() { m_flags = 0; } + StorageEntry() : m_flags(0) {} - Value& value() { return m_value; } - const Value& value() const { return m_value; } + std::shared_ptr value() const { return m_value; } + void set_value(std::shared_ptr value) { m_value = value; } unsigned int flags() const { return m_flags; } void set_flags(unsigned int flags) { m_flags = flags; } + bool IsPersistent() const { return (m_flags & NT_PERSISTENT) != 0; } StorageEntry(const StorageEntry&) = delete; StorageEntry& operator=(const StorageEntry&) = delete; private: - Value m_value; + std::shared_ptr m_value; unsigned int m_flags; }; diff --git a/src/Value.cpp b/src/Value.cpp index aa5708b000..df2ec25476 100644 --- a/src/Value.cpp +++ b/src/Value.cpp @@ -7,90 +7,149 @@ #include "Value.h" -#include -#include -#include - -#include "ntcore.h" - using namespace ntimpl; -StringValue::StringValue(llvm::StringRef val) { - len = val.size(); - str = static_cast(std::malloc(len+1)); - std::memcpy(str, val.data(), len); - str[len] = '\0'; +Value::Value() : m_type(NT_UNASSIGNED) {} + +Value::Value(NT_Type type, const private_init&) : m_type(type) {} + +std::shared_ptr Value::MakeBooleanArray(llvm::ArrayRef value) { + auto val = std::make_shared(NT_BOOLEAN_ARRAY, private_init()); + val->m_boolean_array = value; + return val; } -StringValue& StringValue::operator=(llvm::StringRef val) { - NT_DisposeString(this); - str = nullptr; - len = val.size(); - str = static_cast(std::malloc(len+1)); - std::memcpy(str, val.data(), len); - str[len] = '\0'; - return *this; +std::shared_ptr Value::MakeDoubleArray(llvm::ArrayRef value) { + auto val = std::make_shared(NT_DOUBLE_ARRAY, private_init()); + val->m_double_array = value; + return val; } -void Value::SetBooleanArray(llvm::ArrayRef value) { - // handle type change - if (NT_Value::type != NT_BOOLEAN_ARRAY) { - NT_DisposeValue(this); - data.arr_boolean.arr = nullptr; - data.arr_boolean.size = 0; // set to zero so size change is hit below - NT_Value::type = NT_BOOLEAN_ARRAY; - } - // handle size change - if (data.arr_boolean.size != value.size()) { - std::free(data.arr_boolean.arr); - data.arr_boolean.arr = - static_cast(std::malloc(value.size()*sizeof(int))); - data.arr_boolean.size = value.size(); - } - std::copy(value.begin(), value.end(), data.arr_boolean.arr); +std::shared_ptr Value::MakeStringArray( + llvm::ArrayRef value) { + auto val = std::make_shared(NT_STRING_ARRAY, private_init()); + val->m_string_array = value; + return val; } -void Value::SetDoubleArray(llvm::ArrayRef value) { - // handle type change - if (NT_Value::type != NT_DOUBLE_ARRAY) { - NT_DisposeValue(this); - data.arr_double.arr = nullptr; - data.arr_double.size = 0; // set to zero so size change is hit below - NT_Value::type = NT_DOUBLE_ARRAY; - } - // handle size change - if (data.arr_double.size != value.size()) { - std::free(data.arr_double.arr); - data.arr_double.arr = - static_cast(std::malloc(value.size()*sizeof(double))); - data.arr_double.size = value.size(); - } - std::copy(value.begin(), value.end(), data.arr_double.arr); -} - -void Value::SetStringArray(std::vector& value) { - // handle type change - if (NT_Value::type != NT_STRING_ARRAY) { - NT_DisposeValue(this); - data.arr_string.arr = nullptr; - data.arr_string.size = 0; // set to zero so size change is hit below - NT_Value::type = NT_STRING_ARRAY; - } - // handle size change - if (data.arr_string.size != value.size()) { - std::free(data.arr_string.arr); - data.arr_string.arr = - static_cast(std::malloc(value.size()*sizeof(NT_String))); - // need to initialize array to avoid invalid frees in std::move below. - for (size_t i=0; i(data.arr_string.arr)); +std::shared_ptr Value::MakeBooleanArray(std::vector&& value) { + auto val = std::make_shared(NT_BOOLEAN_ARRAY, private_init()); + val->m_boolean_array = std::move(value); value.clear(); + return val; +} + +std::shared_ptr Value::MakeDoubleArray(std::vector&& value) { + auto val = std::make_shared(NT_DOUBLE_ARRAY, private_init()); + val->m_double_array = std::move(value); + value.clear(); + return val; +} + +std::shared_ptr Value::MakeStringArray( + std::vector&& value) { + auto val = std::make_shared(NT_STRING_ARRAY, private_init()); + val->m_string_array = std::move(value); + value.clear(); + return val; +} + +void ntimpl::ConvertToC(const Value& in, NT_Value* out) { + NT_DisposeValue(out); + switch (in.type()) { + case NT_UNASSIGNED: + return; + case NT_BOOLEAN: + out->data.v_boolean = in.GetBoolean() ? 1 : 0; + break; + case NT_DOUBLE: + out->data.v_double = in.GetDouble(); + break; + case NT_STRING: + NT_InitString(&out->data.v_string); + ConvertToC(in.GetString(), &out->data.v_string); + break; + case NT_RAW: + NT_InitString(&out->data.v_raw); + ConvertToC(in.GetRaw(), &out->data.v_raw); + break; + case NT_RPC: + NT_InitString(&out->data.v_raw); + ConvertToC(in.GetRpc(), &out->data.v_raw); + break; + case NT_BOOLEAN_ARRAY: { + auto v = in.GetBooleanArray(); + out->data.arr_boolean.arr = + static_cast(std::malloc(v.size() * sizeof(int))); + out->data.arr_boolean.size = v.size(); + std::copy(v.begin(), v.end(), out->data.arr_boolean.arr); + break; + } + case NT_DOUBLE_ARRAY: { + auto v = in.GetDoubleArray(); + out->data.arr_double.arr = + static_cast(std::malloc(v.size() * sizeof(double))); + out->data.arr_double.size = v.size(); + std::copy(v.begin(), v.end(), out->data.arr_double.arr); + break; + } + case NT_STRING_ARRAY: { + auto v = in.GetStringArray(); + out->data.arr_string.arr = + static_cast(std::malloc(v.size()*sizeof(NT_String))); + for (size_t i=0; idata.arr_string.arr[i]); + ConvertToC(v[i], &out->data.arr_string.arr[i]); + } + out->data.arr_string.size = v.size(); + break; + } + default: + // assert(false && "unknown value type"); + return; + } + out->type = in.type(); +} + +void ntimpl::ConvertToC(llvm::StringRef in, NT_String* out) { + NT_DisposeString(out); + out->len = in.size(); + out->str = static_cast(std::malloc(in.size()+1)); + std::memcpy(out->str, in.data(), in.size()); + out->str[in.size()] = '\0'; +} + +std::shared_ptr ntimpl::ConvertFromC(const NT_Value& value) { + switch (value.type) { + case NT_UNASSIGNED: + return nullptr; + case NT_BOOLEAN: + return Value::MakeBoolean(value.data.v_boolean != 0); + case NT_DOUBLE: + return Value::MakeDouble(value.data.v_double); + case NT_STRING: + return Value::MakeString(ConvertFromC(value.data.v_string)); + case NT_RAW: + return Value::MakeRaw(ConvertFromC(value.data.v_raw)); + case NT_RPC: + return Value::MakeRpc(ConvertFromC(value.data.v_raw)); + case NT_BOOLEAN_ARRAY: + return Value::MakeBooleanArray(llvm::ArrayRef( + value.data.arr_boolean.arr, value.data.arr_boolean.size)); + case NT_DOUBLE_ARRAY: + return Value::MakeDoubleArray(llvm::ArrayRef( + value.data.arr_double.arr, value.data.arr_double.size)); + case NT_STRING_ARRAY: { + std::vector v; + v.reserve(value.data.arr_string.size); + for (size_t i=0; i +#include +#include #include #include "ntcore.h" @@ -18,189 +20,124 @@ namespace ntimpl { -class Message; -class StringValueTest; -class Storage; -class Value; -class ValueTest; -class WireDecoder; +class Value { + struct private_init {}; -/* - * C++ wrapper class around NT_String. - */ -class StringValue : private NT_String { - friend class Message; - friend class StringValueTest; - friend class Value; - friend class WireDecoder; public: - StringValue() { NT_InitString(this); } - StringValue(llvm::StringRef val); - ~StringValue() { NT_DisposeString(this); } + Value(); + Value(NT_Type type, const private_init&); - operator llvm::StringRef() const { return llvm::StringRef(str, len); } - - StringValue(const StringValue&) = delete; - StringValue& operator=(const StringValue&) = delete; - - StringValue(StringValue&& other) { - str = other.str; - len = other.len; - other.str = nullptr; - other.len = 0; - } - - StringValue& operator=(StringValue&& other) { - if (this != &other) { - NT_DisposeString(this); - str = other.str; - len = other.len; - other.str = nullptr; - other.len = 0; - } - return *this; - } - - StringValue& operator=(llvm::StringRef val); -}; - -inline bool operator==(const StringValue& lhs, const StringValue& rhs) { - return llvm::StringRef(lhs) == llvm::StringRef(rhs); -} -inline bool operator!=(const StringValue& lhs, const StringValue& rhs) { - return llvm::StringRef(lhs) != llvm::StringRef(rhs); -} -inline bool operator==(llvm::StringRef lhs, const StringValue& rhs) { - return lhs == llvm::StringRef(rhs); -} -inline bool operator!=(llvm::StringRef lhs, const StringValue& rhs) { - return lhs != llvm::StringRef(rhs); -} -inline bool operator==(const StringValue& lhs, llvm::StringRef rhs) { - return llvm::StringRef(lhs) == rhs; -} -inline bool operator!=(const StringValue& lhs, llvm::StringRef rhs) { - return llvm::StringRef(lhs) != rhs; -} - -/* - * C++ wrapper class around NT_Value. - */ -class Value : private NT_Value { - friend class Message; - friend class Storage; - friend class ValueTest; - friend class WireDecoder; - public: - Value() { NT_InitValue(this); } - ~Value() { NT_DisposeValue(this); } - - // A little ugly, as it hides the identically-named NT_Value::type. - NT_Type type() const { return NT_Value::type; } + NT_Type type() const { return m_type; } /* * Type-Safe Getters */ bool GetBoolean() const { - assert(NT_Value::type == NT_BOOLEAN); - return data.v_boolean; + assert(m_type == NT_BOOLEAN); + return m_boolean; } double GetDouble() const { - assert(NT_Value::type == NT_DOUBLE); - return data.v_double; + assert(m_type == NT_DOUBLE); + return m_double; } llvm::StringRef GetString() const { - assert(NT_Value::type == NT_STRING); - return static_cast(data.v_string); + assert(m_type == NT_STRING); + return m_string; } llvm::StringRef GetRaw() const { - assert(NT_Value::type == NT_RAW); - return static_cast(data.v_raw); + assert(m_type == NT_RAW); + return m_string; + } + llvm::StringRef GetRpc() const { + assert(m_type == NT_RPC); + return m_string; } llvm::ArrayRef GetBooleanArray() const { - assert(NT_Value::type == NT_BOOLEAN_ARRAY); - return llvm::ArrayRef(data.arr_boolean.arr, data.arr_boolean.size); + assert(m_type == NT_BOOLEAN_ARRAY); + return m_boolean_array; } llvm::ArrayRef GetDoubleArray() const { - assert(NT_Value::type == NT_DOUBLE_ARRAY); - return llvm::ArrayRef(data.arr_double.arr, data.arr_double.size); + assert(m_type == NT_DOUBLE_ARRAY); + return m_double_array; } - llvm::ArrayRef GetStringArray() const { - assert(NT_Value::type == NT_STRING_ARRAY); - return llvm::ArrayRef( - static_cast(data.arr_string.arr), data.arr_string.size); + llvm::ArrayRef GetStringArray() const { + assert(m_type == NT_STRING_ARRAY); + return m_string_array; } - /* - * Type-Safe Setters - */ - void SetBoolean(bool value) { - if (NT_Value::type != NT_BOOLEAN) { - NT_DisposeValue(this); - NT_Value::type = NT_BOOLEAN; - } - data.v_boolean = value ? 1 : 0; + static std::shared_ptr MakeBoolean(bool value) { + auto val = std::make_shared(NT_BOOLEAN, private_init()); + val->m_boolean = value; + return val; } - void SetDouble(double value) { - if (NT_Value::type != NT_DOUBLE) { - NT_DisposeValue(this); - NT_Value::type = NT_DOUBLE; - } - data.v_double = value; + static std::shared_ptr MakeDouble(double value) { + auto val = std::make_shared(NT_DOUBLE, private_init()); + val->m_double = value; + return val; } - void SetString(llvm::StringRef value) { SetString(StringValue(value)); } - void SetString(StringValue&& value) { - if (NT_Value::type != NT_STRING) { - NT_DisposeValue(this); - data.v_string.str = nullptr; - data.v_string.len = 0; - NT_Value::type = NT_STRING; - } - static_cast(data.v_string) = std::move(value); + static std::shared_ptr MakeString(llvm::StringRef value) { + auto val = std::make_shared(NT_STRING, private_init()); + val->m_string = value; + return val; } - void SetRaw(llvm::StringRef value) { SetRaw(StringValue(value)); } - void SetRaw(StringValue&& value) { - if (NT_Value::type != NT_RAW) { - NT_DisposeValue(this); - data.v_raw.str = nullptr; - data.v_raw.len = 0; - NT_Value::type = NT_RAW; - } - static_cast(data.v_raw) = std::move(value); + static std::shared_ptr MakeString(std::string&& value) { + auto val = std::make_shared(NT_STRING, private_init()); + val->m_string = std::move(value); + return val; + } + static std::shared_ptr MakeRaw(llvm::StringRef value) { + auto val = std::make_shared(NT_RAW, private_init()); + val->m_string = value; + return val; + } + static std::shared_ptr MakeRaw(std::string&& value) { + auto val = std::make_shared(NT_RAW, private_init()); + val->m_string = std::move(value); + return val; + } + static std::shared_ptr MakeRpc(llvm::StringRef value) { + auto val = std::make_shared(NT_RPC, private_init()); + val->m_string = value; + return val; + } + static std::shared_ptr MakeRpc(std::string&& value) { + auto val = std::make_shared(NT_RPC, private_init()); + val->m_string = std::move(value); + return val; } - void SetBooleanArray(llvm::ArrayRef value); - void SetDoubleArray(llvm::ArrayRef value); + static std::shared_ptr MakeBooleanArray(llvm::ArrayRef value); + static std::shared_ptr MakeDoubleArray(llvm::ArrayRef value); + static std::shared_ptr MakeStringArray( + llvm::ArrayRef value); - // Note: This function moves the values out of the vector. - void SetStringArray(std::vector& value); + // Note: These functions move the values out of the vector. + static std::shared_ptr MakeBooleanArray(std::vector&& value); + static std::shared_ptr MakeDoubleArray(std::vector&& value); + static std::shared_ptr MakeStringArray( + std::vector&& value); Value(const Value&) = delete; Value& operator=(const Value&) = delete; - - Value(Value&& other) { - NT_Value::type = static_cast(other).type; - last_change = other.last_change; - data = other.data; - static_cast(other).type = NT_UNASSIGNED; - other.last_change = 0; - } - - Value& operator=(Value&& other) { - if (this != &other) { - NT_DisposeValue(this); - NT_Value::type = static_cast(other).type; - last_change = other.last_change; - data = other.data; - static_cast(other).type = NT_UNASSIGNED; - other.last_change = 0; - } - return *this; - } - friend bool operator==(const Value& lhs, const Value& rhs); + + private: + NT_Type m_type; + bool m_boolean; + double m_double; + std::string m_string; + std::vector m_boolean_array; + std::vector m_double_array; + std::vector m_string_array; }; +void ConvertToC(const Value& in, NT_Value* out); +void ConvertToC(llvm::StringRef in, NT_String* out); +std::shared_ptr ConvertFromC(const NT_Value& value); +inline llvm::StringRef ConvertFromC(const NT_String& str) { + return llvm::StringRef(str.str, str.len); +} + bool operator==(const Value& lhs, const Value& rhs); inline bool operator!=(const Value& lhs, const Value& rhs) { return !(lhs == rhs); diff --git a/src/WireDecoder.cpp b/src/WireDecoder.cpp index d161e832e2..befc0bdf84 100644 --- a/src/WireDecoder.cpp +++ b/src/WireDecoder.cpp @@ -108,105 +108,98 @@ bool WireDecoder::ReadType(NT_Type* type) { return true; } -bool WireDecoder::ReadValue(NT_Type type, NT_Value* value) { +std::shared_ptr WireDecoder::ReadValue(NT_Type type) { switch (type) { case NT_BOOLEAN: { unsigned int v; - if (!Read8(&v)) return false; - value->data.v_boolean = v ? 1 : 0; - break; + if (!Read8(&v)) return nullptr; + return Value::MakeBoolean(v != 0); } case NT_DOUBLE: { - if (!ReadDouble(&value->data.v_double)) return false; - break; + double v; + if (!ReadDouble(&v)) return nullptr; + return Value::MakeDouble(v); } - case NT_STRING: - if (!ReadString(&value->data.v_string)) return false; - break; - case NT_RAW: - case NT_RPC: + case NT_STRING: { + std::string v; + if (!ReadString(&v)) return nullptr; + return Value::MakeString(std::move(v)); + } + case NT_RAW: { if (m_proto_rev < 0x0300u) { - m_error = "received raw or RPC value in protocol < 3.0"; - return false; + m_error = "received raw value in protocol < 3.0"; + return nullptr; } - if (!ReadString(&value->data.v_raw)) return false; - break; + std::string v; + if (!ReadString(&v)) return nullptr; + return Value::MakeRaw(std::move(v)); + } + case NT_RPC: { + if (m_proto_rev < 0x0300u) { + m_error = "received RPC value in protocol < 3.0"; + return nullptr; + } + std::string v; + if (!ReadString(&v)) return nullptr; + return Value::MakeRpc(std::move(v)); + } case NT_BOOLEAN_ARRAY: { // size unsigned int size; - if (!Read8(&size)) return false; - value->data.arr_boolean.size = size; + if (!Read8(&size)) return nullptr; // array values const char* buf; - if (!Read(&buf, size)) return false; - value->data.arr_boolean.arr = - static_cast(std::malloc(size * sizeof(int))); + if (!Read(&buf, size)) return nullptr; + std::vector v(size); for (unsigned int i = 0; i < size; ++i) - value->data.arr_boolean.arr[i] = buf[i] ? 1 : 0; - break; + v[i] = buf[i] ? 1 : 0; + return Value::MakeBooleanArray(std::move(v)); } case NT_DOUBLE_ARRAY: { // size unsigned int size; - if (!Read8(&size)) return false; - value->data.arr_double.size = size; + if (!Read8(&size)) return nullptr; // array values const char* buf; - if (!Read(&buf, size * 8)) return false; - value->data.arr_double.arr = - static_cast(std::malloc(size * sizeof(double))); + if (!Read(&buf, size * 8)) return nullptr; + std::vector v(size); for (unsigned int i = 0; i < size; ++i) - value->data.arr_double.arr[i] = ::ReadDouble(buf); - break; + v[i] = ::ReadDouble(buf); + return Value::MakeDoubleArray(std::move(v)); } case NT_STRING_ARRAY: { // size unsigned int size; - if (!Read8(&size)) return false; - value->data.arr_string.size = size; + if (!Read8(&size)) return nullptr; // array values - value->data.arr_string.arr = - static_cast(std::malloc(size * sizeof(NT_String))); + std::vector v(size); for (unsigned int i = 0; i < size; ++i) { - if (!ReadString(&value->data.arr_string.arr[i])) { - // cleanup to avoid memory leaks - for (unsigned int j = 0; j < i; ++j) { - std::free(value->data.arr_string.arr[j].str); - } - std::free(value->data.arr_string.arr); - return false; - } + if (!ReadString(&v[i])) return nullptr; } - break; + return Value::MakeStringArray(std::move(v)); } default: m_error = "invalid type when trying to read value"; - return false; + return nullptr; } - value->type = type; - value->last_change = 0; - return true; } -bool WireDecoder::ReadString(NT_String* str) { +bool WireDecoder::ReadString(std::string* str) { + size_t len; if (m_proto_rev < 0x0300u) { unsigned int v; if (!Read16(&v)) return false; - str->len = v; + len = v; } else { unsigned long v; if (!ReadUleb128(&v)) return false; - str->len = v; + len = v; } - str->str = static_cast(std::malloc(str->len + 1)); // +1 for nul - if (!m_is.read(str->str, str->len)) { - std::free(str->str); - str->str = 0; - return false; - } - str->str[str->len] = '\0'; // be nice and nul-terminate it + const char* buf; + if (!Read(&buf, len)) return false; + *str = llvm::StringRef(buf, len); return true; } diff --git a/src/WireDecoder.h b/src/WireDecoder.h index 749279a9dd..c88308412f 100644 --- a/src/WireDecoder.h +++ b/src/WireDecoder.h @@ -102,17 +102,8 @@ class WireDecoder { } bool ReadType(NT_Type* type); - bool ReadValue(NT_Type type, NT_Value* value); - bool ReadString(NT_String* str); - - bool ReadValue(NT_Type type, Value* value) { - NT_DisposeValue(value); - return ReadValue(type, static_cast(value)); - } - bool ReadString(StringValue* str) { - NT_DisposeString(str); - return ReadString(static_cast(str)); - } + bool ReadString(std::string* str); + std::shared_ptr ReadValue(NT_Type type); WireDecoder(const WireDecoder&) = delete; WireDecoder& operator=(const WireDecoder&) = delete; diff --git a/src/WireEncoder.cpp b/src/WireEncoder.cpp index 9c5a3c66df..b8bc67d512 100644 --- a/src/WireEncoder.cpp +++ b/src/WireEncoder.cpp @@ -105,36 +105,39 @@ void WireEncoder::WriteType(NT_Type type) { ++m_cur; } -std::size_t WireEncoder::GetValueSize(const NT_Value& value) const { - switch (value.type) { +std::size_t WireEncoder::GetValueSize(const Value& value) const { + switch (value.type()) { case NT_BOOLEAN: return 1; case NT_DOUBLE: return 8; case NT_STRING: - return GetStringSize(value.data.v_string); + return GetStringSize(value.GetString()); case NT_RAW: + if (m_proto_rev < 0x0300u) return 0; + return GetStringSize(value.GetRaw()); case NT_RPC: if (m_proto_rev < 0x0300u) return 0; - return GetStringSize(value.data.v_raw); + return GetStringSize(value.GetRpc()); case NT_BOOLEAN_ARRAY: { // 1-byte size, 1 byte per element - std::size_t size = value.data.arr_boolean.size; + std::size_t size = value.GetBooleanArray().size(); if (size > 0xff) size = 0xff; // size is only 1 byte, truncate return 1 + size; } case NT_DOUBLE_ARRAY: { // 1-byte size, 8 bytes per element - std::size_t size = value.data.arr_double.size; + std::size_t size = value.GetDoubleArray().size(); if (size > 0xff) size = 0xff; // size is only 1 byte, truncate return 1 + size * 8; } case NT_STRING_ARRAY: { - std::size_t size = value.data.arr_string.size; + auto v = value.GetStringArray(); + std::size_t size = v.size(); if (size > 0xff) size = 0xff; // size is only 1 byte, truncate std::size_t len = 1; // 1-byte size for (std::size_t i = 0; i < size; ++i) - len += GetStringSize(value.data.arr_string.arr[i]); + len += GetStringSize(v[i]); return len; } default: @@ -142,52 +145,61 @@ std::size_t WireEncoder::GetValueSize(const NT_Value& value) const { } } -void WireEncoder::WriteValue(const NT_Value& value) { - switch (value.type) { +void WireEncoder::WriteValue(const Value& value) { + switch (value.type()) { case NT_BOOLEAN: - Write8(value.data.v_boolean ? 1 : 0); + Write8(value.GetBoolean() ? 1 : 0); break; case NT_DOUBLE: - WriteDouble(value.data.v_double); + WriteDouble(value.GetDouble()); break; case NT_STRING: - WriteString(value.data.v_string); + WriteString(value.GetString()); break; case NT_RAW: - case NT_RPC: if (m_proto_rev < 0x0300u) { - m_error = "raw and rpc values not supported in protocol < 3.0"; + m_error = "raw values not supported in protocol < 3.0"; return; } - WriteString(value.data.v_raw); + WriteString(value.GetRaw()); + break; + case NT_RPC: + if (m_proto_rev < 0x0300u) { + m_error = "RPC values not supported in protocol < 3.0"; + return; + } + WriteString(value.GetRpc()); break; case NT_BOOLEAN_ARRAY: { - std::size_t size = value.data.arr_boolean.size; + auto v = value.GetBooleanArray(); + std::size_t size = v.size(); if (size > 0xff) size = 0xff; // size is only 1 byte, truncate Reserve(1 + size); Write8(size); for (std::size_t i = 0; i < size; ++i) - Write8(value.data.arr_boolean.arr[i] ? 1 : 0); + Write8(v[i] ? 1 : 0); break; } case NT_DOUBLE_ARRAY: { - std::size_t size = value.data.arr_double.size; + auto v = value.GetDoubleArray(); + std::size_t size = v.size(); if (size > 0xff) size = 0xff; // size is only 1 byte, truncate Reserve(1 + size * 8); Write8(size); for (std::size_t i = 0; i < size; ++i) - WriteDouble(value.data.arr_double.arr[i]); + WriteDouble(v[i]); break; } case NT_STRING_ARRAY: { - std::size_t size = value.data.arr_string.size; + auto v = value.GetStringArray(); + std::size_t size = v.size(); if (size > 0xff) size = 0xff; // size is only 1 byte, truncate Write8(size); for (std::size_t i = 0; i < size; ++i) - WriteString(value.data.arr_string.arr[i]); + WriteString(v[i]); break; } default: diff --git a/src/WireEncoder.h b/src/WireEncoder.h index 2f6a804217..b11b84a760 100644 --- a/src/WireEncoder.h +++ b/src/WireEncoder.h @@ -11,9 +11,8 @@ #include #include -#include "ntcore.h" - #include "llvm/StringRef.h" +#include "Value.h" namespace ntimpl { @@ -94,23 +93,17 @@ class WireEncoder { void WriteUleb128(unsigned long val); void WriteType(NT_Type type); - void WriteValue(const NT_Value& value); - void WriteString(const NT_String& str) { - WriteString(llvm::StringRef(str.str, str.len)); - } + void WriteValue(const Value& value); void WriteString(llvm::StringRef str); /* Utility function to get the written size of a value (without actually * writing it). */ - std::size_t GetValueSize(const NT_Value& value) const; + std::size_t GetValueSize(const Value& value) const; /* Utility function to get the written size of a string (without actually * writing it). */ - std::size_t GetStringSize(const NT_String& str) const { - return GetStringSize(llvm::StringRef(str.str, str.len)); - } std::size_t GetStringSize(llvm::StringRef str) const; WireEncoder(const WireEncoder&) = delete; diff --git a/src/ntcore.cpp b/src/ntcore.cpp index e692d9e04c..9cc84e45cb 100644 --- a/src/ntcore.cpp +++ b/src/ntcore.cpp @@ -11,6 +11,7 @@ #include #include +#include "Dispatcher.h" #include "Storage.h" using namespace ntimpl; @@ -80,13 +81,37 @@ NT_Value *NT_GetRpcResult(unsigned int result_uid, size_t *results_len); * Client/Server Functions */ -void NT_SetNetworkIdentity(const char *name, size_t name_len) {} +void NT_SetNetworkIdentity(const char *name, size_t name_len) { + Dispatcher& dispatcher = Dispatcher::GetInstance(); + dispatcher.SetIdentity(llvm::StringRef(name, name_len)); +} + void NT_StartServer(const char *persist_filename, const char *listen_address, - unsigned int port) {} -void NT_StopServer(void) {} -void NT_StartClient(const char *server_name, unsigned int port) {} -void NT_StopClient(void) {} -void NT_SetUpdateRate(double interval) {} + unsigned int port) { + Dispatcher& dispatcher = Dispatcher::GetInstance(); + dispatcher.StartServer(listen_address, port); +} + +void NT_StopServer(void) { + Dispatcher& dispatcher = Dispatcher::GetInstance(); + dispatcher.Stop(); +} + +void NT_StartClient(const char *server_name, unsigned int port) { + Dispatcher& dispatcher = Dispatcher::GetInstance(); + dispatcher.StartClient(server_name, port); +} + +void NT_StopClient(void) { + Dispatcher& dispatcher = Dispatcher::GetInstance(); + dispatcher.Stop(); +} + +void NT_SetUpdateRate(double interval) { + Dispatcher& dispatcher = Dispatcher::GetInstance(); + dispatcher.SetUpdateRate(interval); +} + struct NT_ConnectionInfo *NT_GetConnections(size_t *count) { return nullptr; } diff --git a/test/unit/StringValueTest.cpp b/test/unit/StringValueTest.cpp deleted file mode 100644 index dd74d17d49..0000000000 --- a/test/unit/StringValueTest.cpp +++ /dev/null @@ -1,52 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* Copyright (c) FIRST 2015. All Rights Reserved. */ -/* Open Source Software - may be modified and shared by FRC teams. The code */ -/* must be accompanied by the FIRST BSD license file in the root directory of */ -/* the project. */ -/*----------------------------------------------------------------------------*/ - -#include "StringValueTest.h" - -namespace ntimpl { - -TEST_F(StringValueTest, ConstructEmpty) { - StringValue v; - ASSERT_EQ(nullptr, ToNT(v).str); - ASSERT_EQ(0u, ToNT(v).len); -} - -TEST_F(StringValueTest, ConstructStringRef) { - StringValue v("hello"); - ASSERT_EQ("hello", llvm::StringRef(v)); - ASSERT_EQ(llvm::StringRef("hello"), ToNT(v).str); - ASSERT_EQ(5u, ToNT(v).len); -} - -TEST_F(StringValueTest, ConstructMove) { - StringValue v("hello"); - char* orig = ToNT(v).str; - ASSERT_NE(orig, nullptr); - ASSERT_EQ(5u, ToNT(v).len); - StringValue v2(std::move(v)); - ASSERT_EQ(nullptr, ToNT(v).str); - ASSERT_EQ(0u, ToNT(v).len); - ASSERT_EQ(orig, ToNT(v2).str); - ASSERT_EQ(5u, ToNT(v2).len); -} - -TEST_F(StringValueTest, AssignMove) { - StringValue v("hello"); - char* orig = ToNT(v).str; - ASSERT_NE(orig, nullptr); - ASSERT_EQ(5u, ToNT(v).len); - StringValue v2("goodbye"); - ASSERT_NE(ToNT(v2).str, nullptr); - ASSERT_EQ(7u, ToNT(v2).len); - v2 = std::move(v); - ASSERT_EQ(nullptr, ToNT(v).str); - ASSERT_EQ(0u, ToNT(v).len); - ASSERT_EQ(orig, ToNT(v2).str); - ASSERT_EQ(5u, ToNT(v2).len); -} - -} // namespace ntimpl diff --git a/test/unit/StringValueTest.h b/test/unit/StringValueTest.h deleted file mode 100644 index 25c2737420..0000000000 --- a/test/unit/StringValueTest.h +++ /dev/null @@ -1,24 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* Copyright (c) FIRST 2015. All Rights Reserved. */ -/* Open Source Software - may be modified and shared by FRC teams. The code */ -/* must be accompanied by the FIRST BSD license file in the root directory of */ -/* the project. */ -/*----------------------------------------------------------------------------*/ - -#ifndef NT_TEST_STRINGVALUETEST_H_ -#define NT_TEST_STRINGVALUETEST_H_ - -#include "Value.h" - -#include "gtest/gtest.h" - -namespace ntimpl { - -class StringValueTest : public ::testing::Test { - public: - static NT_String& ToNT(StringValue& v) { return v; } -}; - -} // namespace ntimpl - -#endif diff --git a/test/unit/ValueTest.cpp b/test/unit/ValueTest.cpp index 6e0dbb9a1e..b710751093 100644 --- a/test/unit/ValueTest.cpp +++ b/test/unit/ValueTest.cpp @@ -5,227 +5,250 @@ /* the project. */ /*----------------------------------------------------------------------------*/ -#include "ValueTest.h" +#include "Value.h" + +#include "gtest/gtest.h" namespace ntimpl { +class ValueTest : public ::testing::Test {}; + typedef ValueTest ValueDeathTest; TEST_F(ValueTest, ConstructEmpty) { Value v; - ASSERT_EQ(NT_UNASSIGNED, ToNT(v).type); - ASSERT_EQ(0u, ToNT(v).last_change); ASSERT_EQ(NT_UNASSIGNED, v.type()); } -TEST_F(ValueTest, ConstructMove) { - Value v; - v.SetString("hello"); - ASSERT_EQ(NT_STRING, v.type()); - Value v2(std::move(v)); - ASSERT_EQ(NT_UNASSIGNED, v.type()); - ASSERT_EQ(NT_STRING, v2.type()); -} - -TEST_F(ValueTest, AssignMove) { - Value v; - v.SetString("hello"); - ASSERT_EQ(NT_STRING, v.type()); - Value v2; - v2.SetDouble(0.5); - ASSERT_EQ(NT_DOUBLE, v2.type()); - v2 = std::move(v); - ASSERT_EQ(NT_UNASSIGNED, v.type()); - ASSERT_EQ(NT_STRING, v2.type()); -} - TEST_F(ValueTest, Boolean) { - Value v; - v.SetBoolean(false); - ASSERT_EQ(NT_BOOLEAN, ToNT(v).type); - ASSERT_EQ(0, ToNT(v).data.v_boolean); - ASSERT_EQ(NT_BOOLEAN, v.type()); - ASSERT_FALSE(v.GetBoolean()); - v.SetBoolean(true); - ASSERT_EQ(NT_BOOLEAN, ToNT(v).type); - ASSERT_EQ(1, ToNT(v).data.v_boolean); - ASSERT_EQ(NT_BOOLEAN, v.type()); - ASSERT_TRUE(v.GetBoolean()); + auto v = Value::MakeBoolean(false); + ASSERT_EQ(NT_BOOLEAN, v->type()); + ASSERT_FALSE(v->GetBoolean()); + NT_Value cv; + NT_InitValue(&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()); + ConvertToC(*v, &cv); + ASSERT_EQ(NT_BOOLEAN, cv.type); + ASSERT_EQ(1, cv.data.v_boolean); + + NT_DisposeValue(&cv); } TEST_F(ValueTest, Double) { - Value v; - v.SetDouble(0.5); - ASSERT_EQ(NT_DOUBLE, ToNT(v).type); - ASSERT_EQ(0.5, ToNT(v).data.v_double); - ASSERT_EQ(NT_DOUBLE, v.type()); - ASSERT_EQ(0.5, v.GetDouble()); - v.SetDouble(0.25); - ASSERT_EQ(NT_DOUBLE, ToNT(v).type); - ASSERT_EQ(0.25, ToNT(v).data.v_double); - ASSERT_EQ(NT_DOUBLE, v.type()); - ASSERT_EQ(0.25, v.GetDouble()); + auto v = Value::MakeDouble(0.5); + ASSERT_EQ(NT_DOUBLE, v->type()); + ASSERT_EQ(0.5, v->GetDouble()); + NT_Value cv; + NT_InitValue(&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()); + ConvertToC(*v, &cv); + ASSERT_EQ(NT_DOUBLE, cv.type); + ASSERT_EQ(0.25, cv.data.v_double); + + NT_DisposeValue(&cv); } TEST_F(ValueTest, String) { - Value v; - v.SetString("hello"); - ASSERT_EQ(NT_STRING, ToNT(v).type); - ASSERT_EQ(llvm::StringRef("hello"), ToNT(v).data.v_string.str); - ASSERT_EQ(5u, ToNT(v).data.v_string.len); - ASSERT_EQ(NT_STRING, v.type()); - ASSERT_EQ("hello", v.GetString()); - v.SetString("goodbye"); - ASSERT_EQ(NT_STRING, ToNT(v).type); - ASSERT_EQ(llvm::StringRef("goodbye"), ToNT(v).data.v_string.str); - ASSERT_EQ(7u, ToNT(v).data.v_string.len); - ASSERT_EQ(NT_STRING, v.type()); - ASSERT_EQ("goodbye", v.GetString()); + auto v = Value::MakeString(llvm::StringRef("hello")); + ASSERT_EQ(NT_STRING, v->type()); + ASSERT_EQ("hello", v->GetString()); + NT_Value cv; + NT_InitValue(&cv); + ConvertToC(*v, &cv); + ASSERT_EQ(NT_STRING, cv.type); + ASSERT_EQ(llvm::StringRef("hello"), cv.data.v_string.str); + ASSERT_EQ(5u, cv.data.v_string.len); + + v = Value::MakeString(llvm::StringRef("goodbye")); + ASSERT_EQ(NT_STRING, v->type()); + ASSERT_EQ("goodbye", v->GetString()); + ConvertToC(*v, &cv); + ASSERT_EQ(NT_STRING, cv.type); + ASSERT_EQ(llvm::StringRef("goodbye"), cv.data.v_string.str); + ASSERT_EQ(7u, cv.data.v_string.len); + + NT_DisposeValue(&cv); } TEST_F(ValueTest, Raw) { - Value v; - v.SetRaw("hello"); - ASSERT_EQ(NT_RAW, ToNT(v).type); - ASSERT_EQ(llvm::StringRef("hello"), ToNT(v).data.v_string.str); - ASSERT_EQ(5u, ToNT(v).data.v_string.len); - ASSERT_EQ(NT_RAW, v.type()); - ASSERT_EQ("hello", v.GetRaw()); - v.SetRaw("goodbye"); - ASSERT_EQ(NT_RAW, ToNT(v).type); - ASSERT_EQ(llvm::StringRef("goodbye"), ToNT(v).data.v_string.str); - ASSERT_EQ(7u, ToNT(v).data.v_string.len); - ASSERT_EQ(NT_RAW, v.type()); - ASSERT_EQ("goodbye", v.GetRaw()); + auto v = Value::MakeRaw(llvm::StringRef("hello")); + ASSERT_EQ(NT_RAW, v->type()); + ASSERT_EQ("hello", v->GetRaw()); + NT_Value cv; + NT_InitValue(&cv); + ConvertToC(*v, &cv); + ASSERT_EQ(NT_RAW, cv.type); + ASSERT_EQ(llvm::StringRef("hello"), cv.data.v_string.str); + ASSERT_EQ(5u, cv.data.v_string.len); + + v = Value::MakeRaw(llvm::StringRef("goodbye")); + ASSERT_EQ(NT_RAW, v->type()); + ASSERT_EQ("goodbye", v->GetRaw()); + ConvertToC(*v, &cv); + ASSERT_EQ(NT_RAW, cv.type); + ASSERT_EQ(llvm::StringRef("goodbye"), cv.data.v_string.str); + ASSERT_EQ(7u, cv.data.v_string.len); + + NT_DisposeValue(&cv); } TEST_F(ValueTest, BooleanArray) { - Value v; std::vector vec{1,0,1}; - v.SetBooleanArray(vec); - ASSERT_EQ(NT_BOOLEAN_ARRAY, ToNT(v).type); - ASSERT_EQ(3u, ToNT(v).data.arr_boolean.size); - ASSERT_EQ(vec[0], ToNT(v).data.arr_boolean.arr[0]); - ASSERT_EQ(vec[1], ToNT(v).data.arr_boolean.arr[1]); - ASSERT_EQ(vec[2], ToNT(v).data.arr_boolean.arr[2]); - ASSERT_EQ(NT_BOOLEAN_ARRAY, v.type()); - ASSERT_EQ(llvm::ArrayRef(vec), v.GetBooleanArray()); + auto v = Value::MakeBooleanArray(vec); + ASSERT_EQ(NT_BOOLEAN_ARRAY, v->type()); + ASSERT_EQ(llvm::ArrayRef(vec), v->GetBooleanArray()); + NT_Value cv; + NT_InitValue(&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]); + ASSERT_EQ(vec[1], cv.data.arr_boolean.arr[1]); + ASSERT_EQ(vec[2], cv.data.arr_boolean.arr[2]); // assign with same size vec = {0,1,0}; - v.SetBooleanArray(vec); - ASSERT_EQ(NT_BOOLEAN_ARRAY, ToNT(v).type); - ASSERT_EQ(3u, ToNT(v).data.arr_boolean.size); - ASSERT_EQ(vec[0], ToNT(v).data.arr_boolean.arr[0]); - ASSERT_EQ(vec[1], ToNT(v).data.arr_boolean.arr[1]); - ASSERT_EQ(vec[2], ToNT(v).data.arr_boolean.arr[2]); - ASSERT_EQ(NT_BOOLEAN_ARRAY, v.type()); - ASSERT_EQ(llvm::ArrayRef(vec), v.GetBooleanArray()); + v = Value::MakeBooleanArray(vec); + ASSERT_EQ(NT_BOOLEAN_ARRAY, v->type()); + ASSERT_EQ(llvm::ArrayRef(vec), v->GetBooleanArray()); + 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]); + ASSERT_EQ(vec[1], cv.data.arr_boolean.arr[1]); + ASSERT_EQ(vec[2], cv.data.arr_boolean.arr[2]); // assign with different size vec = {1,0}; - v.SetBooleanArray(vec); - ASSERT_EQ(NT_BOOLEAN_ARRAY, ToNT(v).type); - ASSERT_EQ(2u, ToNT(v).data.arr_boolean.size); - ASSERT_EQ(vec[0], ToNT(v).data.arr_boolean.arr[0]); - ASSERT_EQ(vec[1], ToNT(v).data.arr_boolean.arr[1]); - ASSERT_EQ(NT_BOOLEAN_ARRAY, v.type()); - ASSERT_EQ(llvm::ArrayRef(vec), v.GetBooleanArray()); + v = Value::MakeBooleanArray(vec); + ASSERT_EQ(NT_BOOLEAN_ARRAY, v->type()); + ASSERT_EQ(llvm::ArrayRef(vec), v->GetBooleanArray()); + 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]); + ASSERT_EQ(vec[1], cv.data.arr_boolean.arr[1]); + + NT_DisposeValue(&cv); } TEST_F(ValueTest, DoubleArray) { - Value v; std::vector vec{0.5,0.25,0.5}; - v.SetDoubleArray(vec); - ASSERT_EQ(NT_DOUBLE_ARRAY, ToNT(v).type); - ASSERT_EQ(3u, ToNT(v).data.arr_double.size); - ASSERT_EQ(vec[0], ToNT(v).data.arr_double.arr[0]); - ASSERT_EQ(vec[1], ToNT(v).data.arr_double.arr[1]); - ASSERT_EQ(vec[2], ToNT(v).data.arr_double.arr[2]); - ASSERT_EQ(NT_DOUBLE_ARRAY, v.type()); - ASSERT_EQ(llvm::ArrayRef(vec), v.GetDoubleArray()); + auto v = Value::MakeDoubleArray(vec); + ASSERT_EQ(NT_DOUBLE_ARRAY, v->type()); + ASSERT_EQ(llvm::ArrayRef(vec), v->GetDoubleArray()); + NT_Value cv; + NT_InitValue(&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]); + ASSERT_EQ(vec[1], cv.data.arr_double.arr[1]); + ASSERT_EQ(vec[2], cv.data.arr_double.arr[2]); // assign with same size vec = {0.25,0.5,0.25}; - v.SetDoubleArray(vec); - ASSERT_EQ(NT_DOUBLE_ARRAY, ToNT(v).type); - ASSERT_EQ(3u, ToNT(v).data.arr_double.size); - ASSERT_EQ(vec[0], ToNT(v).data.arr_double.arr[0]); - ASSERT_EQ(vec[1], ToNT(v).data.arr_double.arr[1]); - ASSERT_EQ(vec[2], ToNT(v).data.arr_double.arr[2]); - ASSERT_EQ(NT_DOUBLE_ARRAY, v.type()); - ASSERT_EQ(llvm::ArrayRef(vec), v.GetDoubleArray()); + v = Value::MakeDoubleArray(vec); + ASSERT_EQ(NT_DOUBLE_ARRAY, v->type()); + ASSERT_EQ(llvm::ArrayRef(vec), v->GetDoubleArray()); + 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]); + ASSERT_EQ(vec[1], cv.data.arr_double.arr[1]); + ASSERT_EQ(vec[2], cv.data.arr_double.arr[2]); // assign with different size vec = {0.5,0.25}; - v.SetDoubleArray(vec); - ASSERT_EQ(NT_DOUBLE_ARRAY, ToNT(v).type); - ASSERT_EQ(2u, ToNT(v).data.arr_double.size); - ASSERT_EQ(vec[0], ToNT(v).data.arr_double.arr[0]); - ASSERT_EQ(vec[1], ToNT(v).data.arr_double.arr[1]); - ASSERT_EQ(NT_DOUBLE_ARRAY, v.type()); - ASSERT_EQ(llvm::ArrayRef(vec), v.GetDoubleArray()); + v = Value::MakeDoubleArray(vec); + ASSERT_EQ(NT_DOUBLE_ARRAY, v->type()); + ASSERT_EQ(llvm::ArrayRef(vec), v->GetDoubleArray()); + 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]); + ASSERT_EQ(vec[1], cv.data.arr_double.arr[1]); + + NT_DisposeValue(&cv); } TEST_F(ValueTest, StringArray) { - Value v; - std::vector vec; - vec.push_back(StringValue("hello")); - vec.push_back(StringValue("goodbye")); - vec.push_back(StringValue("string")); - v.SetStringArray(vec); - ASSERT_TRUE(vec.empty()); - ASSERT_EQ(NT_STRING_ARRAY, ToNT(v).type); - ASSERT_EQ(3u, ToNT(v).data.arr_string.size); - ASSERT_EQ(llvm::StringRef("hello"), ToNT(v).data.arr_string.arr[0].str); - ASSERT_EQ(llvm::StringRef("goodbye"), ToNT(v).data.arr_string.arr[1].str); - ASSERT_EQ(llvm::StringRef("string"), ToNT(v).data.arr_string.arr[2].str); - ASSERT_EQ(NT_STRING_ARRAY, v.type()); - ASSERT_EQ(llvm::StringRef("hello"), v.GetStringArray()[0]); - ASSERT_EQ(llvm::StringRef("goodbye"), v.GetStringArray()[1]); - ASSERT_EQ(llvm::StringRef("string"), v.GetStringArray()[2]); + std::vector vec; + vec.push_back("hello"); + 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(llvm::StringRef("hello"), v->GetStringArray()[0]); + ASSERT_EQ(llvm::StringRef("goodbye"), v->GetStringArray()[1]); + ASSERT_EQ(llvm::StringRef("string"), v->GetStringArray()[2]); + NT_Value cv; + NT_InitValue(&cv); + ConvertToC(*v, &cv); + ASSERT_EQ(NT_STRING_ARRAY, cv.type); + ASSERT_EQ(3u, cv.data.arr_string.size); + ASSERT_EQ(llvm::StringRef("hello"), cv.data.arr_string.arr[0].str); + ASSERT_EQ(llvm::StringRef("goodbye"), cv.data.arr_string.arr[1].str); + ASSERT_EQ(llvm::StringRef("string"), cv.data.arr_string.arr[2].str); // assign with same size vec.clear(); - vec.push_back(StringValue("s1")); - vec.push_back(StringValue("str2")); - vec.push_back(StringValue("string3")); - v.SetStringArray(vec); - ASSERT_TRUE(vec.empty()); - ASSERT_EQ(NT_STRING_ARRAY, ToNT(v).type); - ASSERT_EQ(3u, ToNT(v).data.arr_string.size); - ASSERT_EQ(llvm::StringRef("s1"), ToNT(v).data.arr_string.arr[0].str); - ASSERT_EQ(llvm::StringRef("str2"), ToNT(v).data.arr_string.arr[1].str); - ASSERT_EQ(llvm::StringRef("string3"), ToNT(v).data.arr_string.arr[2].str); - ASSERT_EQ(NT_STRING_ARRAY, v.type()); - ASSERT_EQ(llvm::StringRef("s1"), v.GetStringArray()[0]); - ASSERT_EQ(llvm::StringRef("str2"), v.GetStringArray()[1]); - ASSERT_EQ(llvm::StringRef("string3"), v.GetStringArray()[2]); + vec.push_back("s1"); + 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(llvm::StringRef("s1"), v->GetStringArray()[0]); + ASSERT_EQ(llvm::StringRef("str2"), v->GetStringArray()[1]); + ASSERT_EQ(llvm::StringRef("string3"), v->GetStringArray()[2]); + ConvertToC(*v, &cv); + ASSERT_EQ(NT_STRING_ARRAY, cv.type); + ASSERT_EQ(3u, cv.data.arr_string.size); + ASSERT_EQ(llvm::StringRef("s1"), cv.data.arr_string.arr[0].str); + ASSERT_EQ(llvm::StringRef("str2"), cv.data.arr_string.arr[1].str); + ASSERT_EQ(llvm::StringRef("string3"), cv.data.arr_string.arr[2].str); // assign with different size vec.clear(); - vec.push_back(StringValue("short")); - vec.push_back(StringValue("er")); - v.SetStringArray(vec); - ASSERT_TRUE(vec.empty()); - ASSERT_EQ(NT_STRING_ARRAY, ToNT(v).type); - ASSERT_EQ(2u, ToNT(v).data.arr_string.size); - ASSERT_EQ(llvm::StringRef("short"), ToNT(v).data.arr_string.arr[0].str); - ASSERT_EQ(llvm::StringRef("er"), ToNT(v).data.arr_string.arr[1].str); - ASSERT_EQ(NT_STRING_ARRAY, v.type()); - ASSERT_EQ(llvm::StringRef("short"), v.GetStringArray()[0]); - ASSERT_EQ(llvm::StringRef("er"), v.GetStringArray()[1]); + 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(llvm::StringRef("short"), v->GetStringArray()[0]); + ASSERT_EQ(llvm::StringRef("er"), v->GetStringArray()[1]); + ConvertToC(*v, &cv); + ASSERT_EQ(NT_STRING_ARRAY, cv.type); + ASSERT_EQ(2u, cv.data.arr_string.size); + ASSERT_EQ(llvm::StringRef("short"), cv.data.arr_string.arr[0].str); + ASSERT_EQ(llvm::StringRef("er"), cv.data.arr_string.arr[1].str); + + NT_DisposeValue(&cv); } TEST_F(ValueDeathTest, GetAssertions) { Value v; - ASSERT_DEATH(v.GetBoolean(), "NT_Value::type == NT_BOOLEAN"); - ASSERT_DEATH(v.GetDouble(), "NT_Value::type == NT_DOUBLE"); - ASSERT_DEATH(v.GetString(), "NT_Value::type == NT_STRING"); - ASSERT_DEATH(v.GetRaw(), "NT_Value::type == NT_RAW"); - ASSERT_DEATH(v.GetBooleanArray(), "NT_Value::type == NT_BOOLEAN_ARRAY"); - ASSERT_DEATH(v.GetDoubleArray(), "NT_Value::type == NT_DOUBLE_ARRAY"); - ASSERT_DEATH(v.GetStringArray(), "NT_Value::type == NT_STRING_ARRAY"); + ASSERT_DEATH(v.GetBoolean(), "type == NT_BOOLEAN"); + ASSERT_DEATH(v.GetDouble(), "type == NT_DOUBLE"); + ASSERT_DEATH(v.GetString(), "type == NT_STRING"); + ASSERT_DEATH(v.GetRaw(), "type == NT_RAW"); + ASSERT_DEATH(v.GetBooleanArray(), "type == NT_BOOLEAN_ARRAY"); + ASSERT_DEATH(v.GetDoubleArray(), "type == NT_DOUBLE_ARRAY"); + ASSERT_DEATH(v.GetStringArray(), "type == NT_STRING_ARRAY"); } TEST_F(ValueTest, UnassignedComparison) { @@ -234,114 +257,108 @@ TEST_F(ValueTest, UnassignedComparison) { } TEST_F(ValueTest, MixedComparison) { - Value v1, v2; - v1.SetBoolean(true); - ASSERT_NE(v1, v2); // unassigned vs boolean - v2.SetDouble(0.5); - ASSERT_NE(v1, v2); // boolean vs double + Value v1; + auto v2 = Value::MakeBoolean(true); + ASSERT_NE(v1, *v2); // unassigned vs boolean + auto v3 = Value::MakeDouble(0.5); + ASSERT_NE(*v2, *v3); // boolean vs double } TEST_F(ValueTest, BooleanComparison) { - Value v1, v2; - v1.SetBoolean(true); - v2.SetBoolean(true); - ASSERT_EQ(v1, v2); - v2.SetBoolean(false); - ASSERT_NE(v1, v2); + auto v1 = Value::MakeBoolean(true); + auto v2 = Value::MakeBoolean(true); + ASSERT_EQ(*v1, *v2); + v2 = Value::MakeBoolean(false); + ASSERT_NE(*v1, *v2); } TEST_F(ValueTest, DoubleComparison) { - Value v1, v2; - v1.SetDouble(0.25); - v2.SetDouble(0.25); - ASSERT_EQ(v1, v2); - v2.SetDouble(0.5); - ASSERT_NE(v1, v2); + auto v1 = Value::MakeDouble(0.25); + auto v2 = Value::MakeDouble(0.25); + ASSERT_EQ(*v1, *v2); + v2 = Value::MakeDouble(0.5); + ASSERT_NE(*v1, *v2); } TEST_F(ValueTest, StringComparison) { - Value v1, v2; - v1.SetString("hello"); - v2.SetString("hello"); - ASSERT_EQ(v1, v2); - v2.SetString("world"); // different contents - ASSERT_NE(v1, v2); - v2.SetString("goodbye"); // different size - ASSERT_NE(v1, v2); + auto v1 = Value::MakeString(llvm::StringRef("hello")); + auto v2 = Value::MakeString(llvm::StringRef("hello")); + ASSERT_EQ(*v1, *v2); + v2 = Value::MakeString(llvm::StringRef("world")); // different contents + ASSERT_NE(*v1, *v2); + v2 = Value::MakeString(llvm::StringRef("goodbye")); // different size + ASSERT_NE(*v1, *v2); } TEST_F(ValueTest, BooleanArrayComparison) { - Value v1, v2; std::vector vec{1,0,1}; - v1.SetBooleanArray(vec); - v2.SetBooleanArray(vec); - ASSERT_EQ(v1, v2); + auto v1 = Value::MakeBooleanArray(vec); + auto v2 = Value::MakeBooleanArray(vec); + ASSERT_EQ(*v1, *v2); // different contents vec = {1,1,1}; - v2.SetBooleanArray(vec); - ASSERT_NE(v1, v2); + v2 = Value::MakeBooleanArray(vec); + ASSERT_NE(*v1, *v2); // different size vec = {1,0}; - v2.SetBooleanArray(vec); - ASSERT_NE(v1, v2); + v2 = Value::MakeBooleanArray(vec); + ASSERT_NE(*v1, *v2); } TEST_F(ValueTest, DoubleArrayComparison) { - Value v1, v2; std::vector vec{0.5,0.25,0.5}; - v1.SetDoubleArray(vec); - v2.SetDoubleArray(vec); - ASSERT_EQ(v1, v2); + auto v1 = Value::MakeDoubleArray(vec); + auto v2 = Value::MakeDoubleArray(vec); + ASSERT_EQ(*v1, *v2); // different contents vec = {0.5,0.5,0.5}; - v2.SetDoubleArray(vec); - ASSERT_NE(v1, v2); + v2 = Value::MakeDoubleArray(vec); + ASSERT_NE(*v1, *v2); // different size vec = {0.5,0.25}; - v2.SetDoubleArray(vec); - ASSERT_NE(v1, v2); + v2 = Value::MakeDoubleArray(vec); + ASSERT_NE(*v1, *v2); } TEST_F(ValueTest, StringArrayComparison) { - Value v1, v2; - std::vector vec; - vec.push_back(StringValue("hello")); - vec.push_back(StringValue("goodbye")); - vec.push_back(StringValue("string")); - v1.SetStringArray(vec); + std::vector vec; + vec.push_back("hello"); + vec.push_back("goodbye"); + vec.push_back("string"); + auto v1 = Value::MakeStringArray(vec); vec.clear(); - vec.push_back(StringValue("hello")); - vec.push_back(StringValue("goodbye")); - vec.push_back(StringValue("string")); - v2.SetStringArray(vec); - ASSERT_EQ(v1, v2); + vec.push_back("hello"); + vec.push_back("goodbye"); + vec.push_back("string"); + auto v2 = Value::MakeStringArray(std::move(vec)); + ASSERT_EQ(*v1, *v2); // different contents vec.clear(); - vec.push_back(StringValue("hello")); - vec.push_back(StringValue("goodby2")); - vec.push_back(StringValue("string")); - v2.SetStringArray(vec); - ASSERT_NE(v1, v2); + vec.push_back("hello"); + vec.push_back("goodby2"); + vec.push_back("string"); + v2 = Value::MakeStringArray(std::move(vec)); + ASSERT_NE(*v1, *v2); // different sized contents vec.clear(); - vec.push_back(StringValue("hello")); - vec.push_back(StringValue("goodbye2")); - vec.push_back(StringValue("string")); - v2.SetStringArray(vec); - ASSERT_NE(v1, v2); + vec.push_back("hello"); + vec.push_back("goodbye2"); + vec.push_back("string"); + v2 = Value::MakeStringArray(vec); + ASSERT_NE(*v1, *v2); // different size vec.clear(); - vec.push_back(StringValue("hello")); - vec.push_back(StringValue("goodbye")); - v2.SetStringArray(vec); - ASSERT_NE(v1, v2); + vec.push_back("hello"); + vec.push_back("goodbye"); + v2 = Value::MakeStringArray(std::move(vec)); + ASSERT_NE(*v1, *v2); } } // namespace ntimpl diff --git a/test/unit/ValueTest.h b/test/unit/ValueTest.h deleted file mode 100644 index 9e6d78fafc..0000000000 --- a/test/unit/ValueTest.h +++ /dev/null @@ -1,24 +0,0 @@ -/*----------------------------------------------------------------------------*/ -/* Copyright (c) FIRST 2015. All Rights Reserved. */ -/* Open Source Software - may be modified and shared by FRC teams. The code */ -/* must be accompanied by the FIRST BSD license file in the root directory of */ -/* the project. */ -/*----------------------------------------------------------------------------*/ - -#ifndef NT_TEST_VALUETEST_H_ -#define NT_TEST_VALUETEST_H_ - -#include "Value.h" - -#include "gtest/gtest.h" - -namespace ntimpl { - -class ValueTest : public ::testing::Test { - public: - static NT_Value& ToNT(Value& v) { return v; } -}; - -} // namespace ntimpl - -#endif diff --git a/test/unit/WireDecoderTest.cpp b/test/unit/WireDecoderTest.cpp index 155216de89..fd42a2c0b1 100644 --- a/test/unit/WireDecoderTest.cpp +++ b/test/unit/WireDecoderTest.cpp @@ -7,9 +7,6 @@ #include "WireDecoder.h" -#include "StringValueTest.h" -#include "ValueTest.h" - #include "gtest/gtest.h" #include @@ -23,53 +20,46 @@ namespace ntimpl { class WireDecoderTest : public ::testing::Test { protected: virtual void SetUp() { - Value v; - v_boolean.SetBoolean(true); - v_double.SetDouble(1.0); - v_string.SetString("hello"); - v_raw.SetRaw("hello"); - v_boolean_array.SetBooleanArray(std::vector{0, 1, 0}); - v_boolean_array_big.SetBooleanArray(std::vector(255)); - v_double_array.SetDoubleArray(std::vector{0.5, 0.25}); - v_double_array_big.SetDoubleArray(std::vector(255)); + v_boolean = Value::MakeBoolean(true); + v_double = Value::MakeDouble(1.0); + v_string = Value::MakeString(llvm::StringRef("hello")); + v_raw = Value::MakeRaw(llvm::StringRef("hello")); + v_boolean_array = Value::MakeBooleanArray(std::vector{0, 1, 0}); + v_boolean_array_big = Value::MakeBooleanArray(std::vector(255)); + v_double_array = Value::MakeDoubleArray(std::vector{0.5, 0.25}); + v_double_array_big = Value::MakeDoubleArray(std::vector(255)); - std::vector sa; - sa.push_back(StringValue("hello")); - sa.push_back(StringValue("goodbye")); - v_string_array.SetStringArray(sa); + std::vector sa; + sa.push_back("hello"); + sa.push_back("goodbye"); + v_string_array = Value::MakeStringArray(std::move(sa)); sa.clear(); for (int i=0; i<255; ++i) - sa.push_back(StringValue("h")); - v_string_array_big.SetStringArray(sa); + sa.push_back("h"); + v_string_array_big = Value::MakeStringArray(std::move(sa)); s_normal = std::string("hello"); - sv_normal = StringValue(s_normal); s_long.clear(); s_long.append(127, '*'); s_long.push_back('x'); - sv_long = StringValue(s_long); s_big2.clear(); s_big2.append(65534, '*'); s_big2.push_back('x'); - sv_big2 = StringValue(s_big2); s_big3.clear(); s_big3.append(65534, '*'); s_big3.append(3, 'x'); - sv_big3 = StringValue(s_big3); } - Value v_empty; - Value v_boolean, v_double, v_string, v_raw; - Value v_boolean_array, v_boolean_array_big; - Value v_double_array, v_double_array_big; - Value v_string_array, v_string_array_big; + std::shared_ptr v_boolean, v_double, v_string, v_raw; + std::shared_ptr v_boolean_array, v_boolean_array_big; + std::shared_ptr v_double_array, v_double_array_big; + std::shared_ptr v_string_array, v_string_array_big; std::string s_normal, s_long, s_big2, s_big3; - StringValue sv_normal, sv_long, sv_big2, sv_big3; }; TEST_F(WireDecoderTest, Construct) { @@ -224,16 +214,16 @@ TEST_F(WireDecoderTest, Reset) { TEST_F(WireDecoderTest, ReadBooleanValue2) { raw_mem_istream is("\x01\x00", 2); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN, &val)); - EXPECT_EQ(v_boolean, val); + auto val = d.ReadValue(NT_BOOLEAN); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_boolean, *val); - Value v_false; - v_false.SetBoolean(false); - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN, &val)); - EXPECT_EQ(v_false, val); + auto v_false = Value::MakeBoolean(false); + val = d.ReadValue(NT_BOOLEAN); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_false, *val); - ASSERT_FALSE(d.ReadValue(NT_BOOLEAN, &val)); + ASSERT_FALSE(d.ReadValue(NT_BOOLEAN)); ASSERT_EQ(nullptr, d.error()); } @@ -243,53 +233,51 @@ TEST_F(WireDecoderTest, ReadDoubleValue2) { "\x3f\xf0\x00\x00\x00\x00\x00\x00", 16); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_DOUBLE, &val)); - EXPECT_EQ(v_double, val); + auto val = d.ReadValue(NT_DOUBLE); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_double, *val); - Value val2; - ASSERT_TRUE(d.ReadValue(NT_DOUBLE, &val2)); - EXPECT_EQ(v_double, val2); + val = d.ReadValue(NT_DOUBLE); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_double, *val); - ASSERT_FALSE(d.ReadValue(NT_DOUBLE, &val)); + ASSERT_FALSE(d.ReadValue(NT_DOUBLE)); ASSERT_EQ(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadStringValue2) { raw_mem_istream is("\x00\x05hello\x00\x03" "bye\x55", 13); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_STRING, &val)); - EXPECT_EQ(v_string, val); + auto val = d.ReadValue(NT_STRING); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_string, *val); - Value val2; - Value v_bye; - v_bye.SetString("bye"); - ASSERT_TRUE(d.ReadValue(NT_STRING, &val2)); - EXPECT_EQ(v_bye, val2); + auto v_bye = Value::MakeString(llvm::StringRef("bye")); + val = d.ReadValue(NT_STRING); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_bye, *val); unsigned int b; ASSERT_TRUE(d.Read8(&b)); EXPECT_EQ(0x55u, b); - ASSERT_FALSE(d.ReadValue(NT_STRING, &val)); + ASSERT_FALSE(d.ReadValue(NT_STRING)); ASSERT_EQ(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadBooleanArrayValue2) { raw_mem_istream is("\x03\x00\x01\x00\x02\x01\x00\xff", 8); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val)); - EXPECT_EQ(v_boolean_array, val); + auto val = d.ReadValue(NT_BOOLEAN_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_boolean_array, *val); - Value val2; - Value v_boolean_array2; - v_boolean_array2.SetBooleanArray(std::vector{1, 0}); - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val2)); - EXPECT_EQ(v_boolean_array2, val2); + auto v_boolean_array2 = Value::MakeBooleanArray(std::vector{1, 0}); + val = d.ReadValue(NT_BOOLEAN_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_boolean_array2, *val); - ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY)); ASSERT_EQ(nullptr, d.error()); } @@ -299,11 +287,11 @@ TEST_F(WireDecoderTest, ReadBooleanArrayBigValue2) { s.append(255, '\x00'); raw_mem_istream is(s.data(), s.size()); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val)); - EXPECT_EQ(v_boolean_array_big, val); + auto val = d.ReadValue(NT_BOOLEAN_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_boolean_array_big, *val); - ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY)); ASSERT_EQ(nullptr, d.error()); } @@ -313,15 +301,15 @@ TEST_F(WireDecoderTest, ReadDoubleArrayValue2) { "\x3f\xd0\x00\x00\x00\x00\x00\x00\x55", 18); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_DOUBLE_ARRAY, &val)); - EXPECT_EQ(v_double_array, val); + auto val = d.ReadValue(NT_DOUBLE_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_double_array, *val); unsigned int b; ASSERT_TRUE(d.Read8(&b)); EXPECT_EQ(0x55u, b); - ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY)); ASSERT_EQ(nullptr, d.error()); } @@ -331,26 +319,26 @@ TEST_F(WireDecoderTest, ReadDoubleArrayBigValue2) { s.append(255*8, '\x00'); raw_mem_istream is(s.data(), s.size()); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_DOUBLE_ARRAY, &val)); - EXPECT_EQ(v_double_array_big, val); + auto val = d.ReadValue(NT_DOUBLE_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_double_array_big, *val); - ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY)); ASSERT_EQ(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadStringArrayValue2) { raw_mem_istream is("\x02\x00\x05hello\x00\x07goodbye\x55", 18); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_STRING_ARRAY, &val)); - EXPECT_EQ(v_string_array, val); + auto val = d.ReadValue(NT_STRING_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_string_array, *val); unsigned int b; ASSERT_TRUE(d.Read8(&b)); EXPECT_EQ(0x55u, b); - ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY)); ASSERT_EQ(nullptr, d.error()); } @@ -361,43 +349,42 @@ TEST_F(WireDecoderTest, ReadStringArrayBigValue2) { s.append("\x00\x01h", 3); raw_mem_istream is(s.data(), s.size()); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_STRING_ARRAY, &val)); - EXPECT_EQ(v_string_array_big, val); + auto val = d.ReadValue(NT_STRING_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_string_array_big, *val); - ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY)); ASSERT_EQ(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadValueError2) { raw_mem_istream is("", 0); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_FALSE(d.ReadValue(NT_UNASSIGNED, &val)); // unassigned + ASSERT_FALSE(d.ReadValue(NT_UNASSIGNED)); // unassigned ASSERT_NE(nullptr, d.error()); d.Reset(); - ASSERT_FALSE(d.ReadValue(NT_RAW, &val)); // not supported + ASSERT_FALSE(d.ReadValue(NT_RAW)); // not supported ASSERT_NE(nullptr, d.error()); d.Reset(); - ASSERT_FALSE(d.ReadValue(NT_RPC, &val)); // not supported + ASSERT_FALSE(d.ReadValue(NT_RPC)); // not supported ASSERT_NE(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadBooleanValue3) { raw_mem_istream is("\x01\x00", 2); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN, &val)); - EXPECT_EQ(v_boolean, val); + auto val = d.ReadValue(NT_BOOLEAN); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_boolean, *val); - Value v_false; - v_false.SetBoolean(false); - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN, &val)); - EXPECT_EQ(v_false, val); + auto v_false = Value::MakeBoolean(false); + val = d.ReadValue(NT_BOOLEAN); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_false, *val); - ASSERT_FALSE(d.ReadValue(NT_BOOLEAN, &val)); + ASSERT_FALSE(d.ReadValue(NT_BOOLEAN)); ASSERT_EQ(nullptr, d.error()); } @@ -407,74 +394,71 @@ TEST_F(WireDecoderTest, ReadDoubleValue3) { "\x3f\xf0\x00\x00\x00\x00\x00\x00", 16); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_DOUBLE, &val)); - EXPECT_EQ(v_double, val); + auto val = d.ReadValue(NT_DOUBLE); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_double, *val); - Value val2; - ASSERT_TRUE(d.ReadValue(NT_DOUBLE, &val2)); - EXPECT_EQ(v_double, val2); + val = d.ReadValue(NT_DOUBLE); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_double, *val); - ASSERT_FALSE(d.ReadValue(NT_DOUBLE, &val)); + ASSERT_FALSE(d.ReadValue(NT_DOUBLE)); ASSERT_EQ(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadStringValue3) { raw_mem_istream is("\x05hello\x03" "bye\x55", 11); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_STRING, &val)); - EXPECT_EQ(v_string, val); + auto val = d.ReadValue(NT_STRING); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_string, *val); - Value val2; - Value v_bye; - v_bye.SetString("bye"); - ASSERT_TRUE(d.ReadValue(NT_STRING, &val2)); - EXPECT_EQ(v_bye, val2); + auto v_bye = Value::MakeString(llvm::StringRef("bye")); + val = d.ReadValue(NT_STRING); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_bye, *val); unsigned int b; ASSERT_TRUE(d.Read8(&b)); EXPECT_EQ(0x55u, b); - ASSERT_FALSE(d.ReadValue(NT_STRING, &val)); + ASSERT_FALSE(d.ReadValue(NT_STRING)); ASSERT_EQ(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadRawValue3) { raw_mem_istream is("\x05hello\x03" "bye\x55", 11); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_RAW, &val)); - EXPECT_EQ(v_raw, val); + auto val = d.ReadValue(NT_RAW); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_raw, *val); - Value val2; - Value v_bye; - v_bye.SetRaw("bye"); - ASSERT_TRUE(d.ReadValue(NT_RAW, &val2)); - EXPECT_EQ(v_bye, val2); + auto v_bye = Value::MakeRaw(llvm::StringRef("bye")); + val = d.ReadValue(NT_RAW); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_bye, *val); unsigned int b; ASSERT_TRUE(d.Read8(&b)); EXPECT_EQ(0x55u, b); - ASSERT_FALSE(d.ReadValue(NT_RAW, &val)); + ASSERT_FALSE(d.ReadValue(NT_RAW)); ASSERT_EQ(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadBooleanArrayValue3) { raw_mem_istream is("\x03\x00\x01\x00\x02\x01\x00\xff", 8); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val)); - EXPECT_EQ(v_boolean_array, val); + auto val = d.ReadValue(NT_BOOLEAN_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_boolean_array, *val); - Value val2; - Value v_boolean_array2; - v_boolean_array2.SetBooleanArray(std::vector{1, 0}); - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val2)); - EXPECT_EQ(v_boolean_array2, val2); + auto v_boolean_array2 = Value::MakeBooleanArray(std::vector{1, 0}); + val = d.ReadValue(NT_BOOLEAN_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_boolean_array2, *val); - ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY)); ASSERT_EQ(nullptr, d.error()); } @@ -484,11 +468,11 @@ TEST_F(WireDecoderTest, ReadBooleanArrayBigValue3) { s.append(255, '\x00'); raw_mem_istream is(s.data(), s.size()); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_BOOLEAN_ARRAY, &val)); - EXPECT_EQ(v_boolean_array_big, val); + auto val = d.ReadValue(NT_BOOLEAN_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_boolean_array_big, *val); - ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_BOOLEAN_ARRAY)); ASSERT_EQ(nullptr, d.error()); } @@ -498,15 +482,15 @@ TEST_F(WireDecoderTest, ReadDoubleArrayValue3) { "\x3f\xd0\x00\x00\x00\x00\x00\x00\x55", 18); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_DOUBLE_ARRAY, &val)); - EXPECT_EQ(v_double_array, val); + auto val = d.ReadValue(NT_DOUBLE_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_double_array, *val); unsigned int b; ASSERT_TRUE(d.Read8(&b)); EXPECT_EQ(0x55u, b); - ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY)); ASSERT_EQ(nullptr, d.error()); } @@ -516,26 +500,26 @@ TEST_F(WireDecoderTest, ReadDoubleArrayBigValue3) { s.append(255*8, '\x00'); raw_mem_istream is(s.data(), s.size()); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_DOUBLE_ARRAY, &val)); - EXPECT_EQ(v_double_array_big, val); + auto val = d.ReadValue(NT_DOUBLE_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_double_array_big, *val); - ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_DOUBLE_ARRAY)); ASSERT_EQ(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadStringArrayValue3) { raw_mem_istream is("\x02\x05hello\x07goodbye\x55", 16); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_STRING_ARRAY, &val)); - EXPECT_EQ(v_string_array, val); + auto val = d.ReadValue(NT_STRING_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_string_array, *val); unsigned int b; ASSERT_TRUE(d.Read8(&b)); EXPECT_EQ(0x55u, b); - ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY)); ASSERT_EQ(nullptr, d.error()); } @@ -546,19 +530,18 @@ TEST_F(WireDecoderTest, ReadStringArrayBigValue3) { s.append("\x01h", 2); raw_mem_istream is(s.data(), s.size()); WireDecoder d(is, 0x0300u); - Value val; - ASSERT_TRUE(d.ReadValue(NT_STRING_ARRAY, &val)); - EXPECT_EQ(v_string_array_big, val); + auto val = d.ReadValue(NT_STRING_ARRAY); + ASSERT_TRUE(bool(val)); + EXPECT_EQ(*v_string_array_big, *val); - ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY, &val)); + ASSERT_FALSE(d.ReadValue(NT_STRING_ARRAY)); ASSERT_EQ(nullptr, d.error()); } TEST_F(WireDecoderTest, ReadValueError3) { raw_mem_istream is("", 0); WireDecoder d(is, 0x0200u); - Value val; - ASSERT_FALSE(d.ReadValue(NT_UNASSIGNED, &val)); // unassigned + ASSERT_FALSE(d.ReadValue(NT_UNASSIGNED)); // unassigned ASSERT_NE(nullptr, d.error()); } @@ -573,19 +556,19 @@ TEST_F(WireDecoderTest, ReadString2) { s.push_back('\x55'); raw_mem_istream is(s.data(), s.size()); WireDecoder d(is, 0x0200u); - StringValue sv; - ASSERT_TRUE(d.ReadString(&sv)); - EXPECT_EQ(sv_normal, sv); - ASSERT_TRUE(d.ReadString(&sv)); - EXPECT_EQ(sv_long, sv); - ASSERT_TRUE(d.ReadString(&sv)); - EXPECT_EQ(sv_big2, sv); + std::string outs; + ASSERT_TRUE(d.ReadString(&outs)); + EXPECT_EQ(s_normal, outs); + ASSERT_TRUE(d.ReadString(&outs)); + EXPECT_EQ(s_long, outs); + ASSERT_TRUE(d.ReadString(&outs)); + EXPECT_EQ(s_big2, outs); unsigned int b; ASSERT_TRUE(d.Read8(&b)); EXPECT_EQ(0x55u, b); - ASSERT_FALSE(d.ReadString(&sv)); + ASSERT_FALSE(d.ReadString(&outs)); ASSERT_EQ(nullptr, d.error()); } @@ -600,19 +583,19 @@ TEST_F(WireDecoderTest, ReadString3) { s.push_back('\x55'); raw_mem_istream is(s.data(), s.size()); WireDecoder d(is, 0x0300u); - StringValue sv; - ASSERT_TRUE(d.ReadString(&sv)); - EXPECT_EQ(sv_normal, sv); - ASSERT_TRUE(d.ReadString(&sv)); - EXPECT_EQ(sv_long, sv); - ASSERT_TRUE(d.ReadString(&sv)); - EXPECT_EQ(sv_big3, sv); + std::string outs; + ASSERT_TRUE(d.ReadString(&outs)); + EXPECT_EQ(s_normal, outs); + ASSERT_TRUE(d.ReadString(&outs)); + EXPECT_EQ(s_long, outs); + ASSERT_TRUE(d.ReadString(&outs)); + EXPECT_EQ(s_big3, outs); unsigned int b; ASSERT_TRUE(d.Read8(&b)); EXPECT_EQ(0x55u, b); - ASSERT_FALSE(d.ReadString(&sv)); + ASSERT_FALSE(d.ReadString(&outs)); ASSERT_EQ(nullptr, d.error()); } diff --git a/test/unit/WireEncoderTest.cpp b/test/unit/WireEncoderTest.cpp index be0d8f2a02..dfe5bb8a83 100644 --- a/test/unit/WireEncoderTest.cpp +++ b/test/unit/WireEncoderTest.cpp @@ -7,9 +7,6 @@ #include "WireEncoder.h" -#include "StringValueTest.h" -#include "ValueTest.h" - #include "gtest/gtest.h" #include @@ -25,46 +22,44 @@ namespace ntimpl { class WireEncoderTest : public ::testing::Test { protected: virtual void SetUp() { - Value v; - v_boolean.SetBoolean(true); - v_double.SetDouble(1.0); - v_string.SetString("hello"); - v_raw.SetRaw("hello"); - v_boolean_array.SetBooleanArray(std::vector{0, 1, 0}); - v_boolean_array_big.SetBooleanArray(std::vector(256)); - v_double_array.SetDoubleArray(std::vector{0.5, 0.25}); - v_double_array_big.SetDoubleArray(std::vector(256)); + v_empty = std::make_shared(); + v_boolean = Value::MakeBoolean(true); + v_double = Value::MakeDouble(1.0); + v_string = Value::MakeString(llvm::StringRef("hello")); + v_raw = Value::MakeRaw(llvm::StringRef("hello")); + v_boolean_array = Value::MakeBooleanArray(std::vector{0, 1, 0}); + v_boolean_array_big = Value::MakeBooleanArray(std::vector(256)); + v_double_array = Value::MakeDoubleArray(std::vector{0.5, 0.25}); + v_double_array_big = Value::MakeDoubleArray(std::vector(256)); - std::vector sa; - sa.push_back(StringValue("hello")); - sa.push_back(StringValue("goodbye")); - v_string_array.SetStringArray(sa); + std::vector sa; + sa.push_back("hello"); + sa.push_back("goodbye"); + v_string_array = Value::MakeStringArray(std::move(sa)); sa.clear(); for (int i=0; i<256; ++i) - sa.push_back(StringValue("h")); - v_string_array_big.SetStringArray(sa); + sa.push_back("h"); + v_string_array_big = Value::MakeStringArray(std::move(sa)); - sv_normal = StringValue("hello"); + s_normal = "hello"; - std::string longstr; - longstr.append(127, '*'); - longstr.push_back('x'); - sv_long = StringValue(longstr); + s_long.clear(); + s_long.append(127, '*'); + s_long.push_back('x'); - longstr.clear(); - longstr.append(65534, '*'); - longstr.append(3, 'x'); - sv_big = StringValue(longstr); + s_big.clear(); + s_big.append(65534, '*'); + s_big.append(3, 'x'); } - Value v_empty; - Value v_boolean, v_double, v_string, v_raw; - Value v_boolean_array, v_boolean_array_big; - Value v_double_array, v_double_array_big; - Value v_string_array, v_string_array_big; + std::shared_ptr v_empty; + std::shared_ptr v_boolean, v_double, v_string, v_raw; + std::shared_ptr v_boolean_array, v_boolean_array_big; + std::shared_ptr v_double_array, v_double_array_big; + std::shared_ptr v_string_array, v_string_array_big; - StringValue sv_normal, sv_long, sv_big; + std::string s_normal, s_long, s_big; }; TEST_F(WireEncoderTest, Construct) { @@ -206,31 +201,30 @@ TEST_F(WireEncoderTest, Reset) { TEST_F(WireEncoderTest, GetValueSize2) { WireEncoder e(0x0200u); - EXPECT_EQ(0u, e.GetValueSize(ValueTest::ToNT(v_empty))); // empty - EXPECT_EQ(1u, e.GetValueSize(ValueTest::ToNT(v_boolean))); - EXPECT_EQ(8u, e.GetValueSize(ValueTest::ToNT(v_double))); - EXPECT_EQ(7u, e.GetValueSize(ValueTest::ToNT(v_string))); - EXPECT_EQ(0u, e.GetValueSize(ValueTest::ToNT(v_raw))); // not supported + EXPECT_EQ(0u, e.GetValueSize(*v_empty)); // empty + EXPECT_EQ(1u, e.GetValueSize(*v_boolean)); + EXPECT_EQ(8u, e.GetValueSize(*v_double)); + EXPECT_EQ(7u, e.GetValueSize(*v_string)); + EXPECT_EQ(0u, e.GetValueSize(*v_raw)); // not supported - EXPECT_EQ(1u+3u, e.GetValueSize(ValueTest::ToNT(v_boolean_array))); + EXPECT_EQ(1u+3u, e.GetValueSize(*v_boolean_array)); // truncated - EXPECT_EQ(1u+255u, e.GetValueSize(ValueTest::ToNT(v_boolean_array_big))); + EXPECT_EQ(1u+255u, e.GetValueSize(*v_boolean_array_big)); - EXPECT_EQ(1u+2u*8u, e.GetValueSize(ValueTest::ToNT(v_double_array))); + EXPECT_EQ(1u+2u*8u, e.GetValueSize(*v_double_array)); // truncated - EXPECT_EQ(1u+255u*8u, e.GetValueSize(ValueTest::ToNT(v_double_array_big))); + EXPECT_EQ(1u+255u*8u, e.GetValueSize(*v_double_array_big)); - EXPECT_EQ(1u+7u+9u, e.GetValueSize(ValueTest::ToNT(v_string_array))); + EXPECT_EQ(1u+7u+9u, e.GetValueSize(*v_string_array)); // truncated - EXPECT_EQ(1u+255u*3u, e.GetValueSize(ValueTest::ToNT(v_string_array_big))); + EXPECT_EQ(1u+255u*3u, e.GetValueSize(*v_string_array_big)); } TEST_F(WireEncoderTest, WriteBooleanValue2) { WireEncoder e(0x0200u); - e.WriteValue(ValueTest::ToNT(v_boolean)); - Value v_false; - v_false.SetBoolean(false); - e.WriteValue(ValueTest::ToNT(v_false)); + e.WriteValue(*v_boolean); + auto v_false = Value::MakeBoolean(false); + e.WriteValue(*v_false); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(2u, e.size()); ASSERT_EQ(llvm::StringRef("\x01\x00", 2), @@ -239,7 +233,7 @@ TEST_F(WireEncoderTest, WriteBooleanValue2) { TEST_F(WireEncoderTest, WriteDoubleValue2) { WireEncoder e(0x0200u); - e.WriteValue(ValueTest::ToNT(v_double)); + e.WriteValue(*v_double); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(8u, e.size()); ASSERT_EQ(llvm::StringRef("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8), @@ -248,7 +242,7 @@ TEST_F(WireEncoderTest, WriteDoubleValue2) { TEST_F(WireEncoderTest, WriteStringValue2) { WireEncoder e(0x0200u); - e.WriteValue(ValueTest::ToNT(v_string)); + e.WriteValue(*v_string); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(7u, e.size()); ASSERT_EQ(llvm::StringRef("\x00\x05hello", 7), @@ -257,7 +251,7 @@ TEST_F(WireEncoderTest, WriteStringValue2) { TEST_F(WireEncoderTest, WriteBooleanArrayValue2) { WireEncoder e(0x0200u); - e.WriteValue(ValueTest::ToNT(v_boolean_array)); + e.WriteValue(*v_boolean_array); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+3u, e.size()); ASSERT_EQ(llvm::StringRef("\x03\x00\x01\x00", 4), @@ -265,7 +259,7 @@ TEST_F(WireEncoderTest, WriteBooleanArrayValue2) { // truncated e.Reset(); - e.WriteValue(ValueTest::ToNT(v_boolean_array_big)); + e.WriteValue(*v_boolean_array_big); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+255u, e.size()); ASSERT_EQ(llvm::StringRef("\xff\x00", 2), llvm::StringRef(e.data(), 2)); @@ -273,7 +267,7 @@ TEST_F(WireEncoderTest, WriteBooleanArrayValue2) { TEST_F(WireEncoderTest, WriteDoubleArrayValue2) { WireEncoder e(0x0200u); - e.WriteValue(ValueTest::ToNT(v_double_array)); + e.WriteValue(*v_double_array); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+2u*8u, e.size()); ASSERT_EQ(llvm::StringRef("\x02\x3f\xe0\x00\x00\x00\x00\x00\x00" @@ -282,7 +276,7 @@ TEST_F(WireEncoderTest, WriteDoubleArrayValue2) { // truncated e.Reset(); - e.WriteValue(ValueTest::ToNT(v_double_array_big)); + e.WriteValue(*v_double_array_big); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+255u*8u, e.size()); ASSERT_EQ(llvm::StringRef("\xff\x00", 2), llvm::StringRef(e.data(), 2)); @@ -290,7 +284,7 @@ TEST_F(WireEncoderTest, WriteDoubleArrayValue2) { TEST_F(WireEncoderTest, WriteStringArrayValue2) { WireEncoder e(0x0200u); - e.WriteValue(ValueTest::ToNT(v_string_array)); + e.WriteValue(*v_string_array); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+7u+9u, e.size()); ASSERT_EQ(llvm::StringRef("\x02\x00\x05hello\x00\x07goodbye", 17), @@ -298,7 +292,7 @@ TEST_F(WireEncoderTest, WriteStringArrayValue2) { // truncated e.Reset(); - e.WriteValue(ValueTest::ToNT(v_string_array_big)); + e.WriteValue(*v_string_array_big); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+255u*3u, e.size()); ASSERT_EQ(llvm::StringRef("\xff\x00\x01", 3), llvm::StringRef(e.data(), 3)); @@ -306,43 +300,42 @@ TEST_F(WireEncoderTest, WriteStringArrayValue2) { TEST_F(WireEncoderTest, WriteValueError2) { WireEncoder e(0x0200u); - e.WriteValue(ValueTest::ToNT(v_empty)); // empty + e.WriteValue(*v_empty); // empty ASSERT_EQ(0u, e.size()); ASSERT_NE(nullptr, e.error()); e.Reset(); - e.WriteValue(ValueTest::ToNT(v_raw)); // not supported + e.WriteValue(*v_raw); // not supported ASSERT_EQ(0u, e.size()); ASSERT_NE(nullptr, e.error()); } TEST_F(WireEncoderTest, GetValueSize3) { WireEncoder e(0x0300u); - EXPECT_EQ(0u, e.GetValueSize(ValueTest::ToNT(v_empty))); // empty - EXPECT_EQ(1u, e.GetValueSize(ValueTest::ToNT(v_boolean))); - EXPECT_EQ(8u, e.GetValueSize(ValueTest::ToNT(v_double))); - EXPECT_EQ(6u, e.GetValueSize(ValueTest::ToNT(v_string))); - EXPECT_EQ(6u, e.GetValueSize(ValueTest::ToNT(v_raw))); + EXPECT_EQ(0u, e.GetValueSize(*v_empty)); // empty + EXPECT_EQ(1u, e.GetValueSize(*v_boolean)); + EXPECT_EQ(8u, e.GetValueSize(*v_double)); + EXPECT_EQ(6u, e.GetValueSize(*v_string)); + EXPECT_EQ(6u, e.GetValueSize(*v_raw)); - EXPECT_EQ(1u+3u, e.GetValueSize(ValueTest::ToNT(v_boolean_array))); + EXPECT_EQ(1u+3u, e.GetValueSize(*v_boolean_array)); // truncated - EXPECT_EQ(1u+255u, e.GetValueSize(ValueTest::ToNT(v_boolean_array_big))); + EXPECT_EQ(1u+255u, e.GetValueSize(*v_boolean_array_big)); - EXPECT_EQ(1u+2u*8u, e.GetValueSize(ValueTest::ToNT(v_double_array))); + EXPECT_EQ(1u+2u*8u, e.GetValueSize(*v_double_array)); // truncated - EXPECT_EQ(1u+255u*8u, e.GetValueSize(ValueTest::ToNT(v_double_array_big))); + EXPECT_EQ(1u+255u*8u, e.GetValueSize(*v_double_array_big)); - EXPECT_EQ(1u+6u+8u, e.GetValueSize(ValueTest::ToNT(v_string_array))); + EXPECT_EQ(1u+6u+8u, e.GetValueSize(*v_string_array)); // truncated - EXPECT_EQ(1u+255u*2u, e.GetValueSize(ValueTest::ToNT(v_string_array_big))); + EXPECT_EQ(1u+255u*2u, e.GetValueSize(*v_string_array_big)); } TEST_F(WireEncoderTest, WriteBooleanValue3) { WireEncoder e(0x0300u); - e.WriteValue(ValueTest::ToNT(v_boolean)); - Value v_false; - v_false.SetBoolean(false); - e.WriteValue(ValueTest::ToNT(v_false)); + e.WriteValue(*v_boolean); + auto v_false = Value::MakeBoolean(false); + e.WriteValue(*v_false); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(2u, e.size()); ASSERT_EQ(llvm::StringRef("\x01\x00", 2), @@ -351,7 +344,7 @@ TEST_F(WireEncoderTest, WriteBooleanValue3) { TEST_F(WireEncoderTest, WriteDoubleValue3) { WireEncoder e(0x0300u); - e.WriteValue(ValueTest::ToNT(v_double)); + e.WriteValue(*v_double); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(8u, e.size()); ASSERT_EQ(llvm::StringRef("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8), @@ -360,7 +353,7 @@ TEST_F(WireEncoderTest, WriteDoubleValue3) { TEST_F(WireEncoderTest, WriteStringValue3) { WireEncoder e(0x0300u); - e.WriteValue(ValueTest::ToNT(v_string)); + e.WriteValue(*v_string); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(6u, e.size()); ASSERT_EQ(llvm::StringRef("\x05hello", 6), @@ -369,7 +362,7 @@ TEST_F(WireEncoderTest, WriteStringValue3) { TEST_F(WireEncoderTest, WriteRawValue3) { WireEncoder e(0x0300u); - e.WriteValue(ValueTest::ToNT(v_raw)); + e.WriteValue(*v_raw); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(6u, e.size()); ASSERT_EQ(llvm::StringRef("\x05hello", 6), @@ -378,7 +371,7 @@ TEST_F(WireEncoderTest, WriteRawValue3) { TEST_F(WireEncoderTest, WriteBooleanArrayValue3) { WireEncoder e(0x0300u); - e.WriteValue(ValueTest::ToNT(v_boolean_array)); + e.WriteValue(*v_boolean_array); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+3u, e.size()); ASSERT_EQ(llvm::StringRef("\x03\x00\x01\x00", 4), @@ -386,7 +379,7 @@ TEST_F(WireEncoderTest, WriteBooleanArrayValue3) { // truncated e.Reset(); - e.WriteValue(ValueTest::ToNT(v_boolean_array_big)); + e.WriteValue(*v_boolean_array_big); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+255u, e.size()); ASSERT_EQ(llvm::StringRef("\xff\x00", 2), llvm::StringRef(e.data(), 2)); @@ -394,7 +387,7 @@ TEST_F(WireEncoderTest, WriteBooleanArrayValue3) { TEST_F(WireEncoderTest, WriteDoubleArrayValue3) { WireEncoder e(0x0300u); - e.WriteValue(ValueTest::ToNT(v_double_array)); + e.WriteValue(*v_double_array); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+2u*8u, e.size()); ASSERT_EQ(llvm::StringRef("\x02\x3f\xe0\x00\x00\x00\x00\x00\x00" @@ -403,7 +396,7 @@ TEST_F(WireEncoderTest, WriteDoubleArrayValue3) { // truncated e.Reset(); - e.WriteValue(ValueTest::ToNT(v_double_array_big)); + e.WriteValue(*v_double_array_big); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+255u*8u, e.size()); ASSERT_EQ(llvm::StringRef("\xff\x00", 2), llvm::StringRef(e.data(), 2)); @@ -411,7 +404,7 @@ TEST_F(WireEncoderTest, WriteDoubleArrayValue3) { TEST_F(WireEncoderTest, WriteStringArrayValue3) { WireEncoder e(0x0300u); - e.WriteValue(ValueTest::ToNT(v_string_array)); + e.WriteValue(*v_string_array); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+6u+8u, e.size()); ASSERT_EQ(llvm::StringRef("\x02\x05hello\x07goodbye", 15), @@ -419,7 +412,7 @@ TEST_F(WireEncoderTest, WriteStringArrayValue3) { // truncated e.Reset(); - e.WriteValue(ValueTest::ToNT(v_string_array_big)); + e.WriteValue(*v_string_array_big); ASSERT_EQ(nullptr, e.error()); ASSERT_EQ(1u+255u*2u, e.size()); ASSERT_EQ(llvm::StringRef("\xff\x01", 2), llvm::StringRef(e.data(), 2)); @@ -427,7 +420,7 @@ TEST_F(WireEncoderTest, WriteStringArrayValue3) { TEST_F(WireEncoderTest, WriteValueError3) { WireEncoder e(0x0300u); - e.WriteValue(ValueTest::ToNT(v_empty)); // empty + e.WriteValue(*v_empty); // empty ASSERT_EQ(0u, e.size()); ASSERT_NE(nullptr, e.error()); } @@ -435,22 +428,22 @@ TEST_F(WireEncoderTest, WriteValueError3) { TEST_F(WireEncoderTest, GetStringSize2) { // 2-byte length WireEncoder e(0x0200u); - EXPECT_EQ(7u, e.GetStringSize(StringValueTest::ToNT(sv_normal))); - EXPECT_EQ(130u, e.GetStringSize(StringValueTest::ToNT(sv_long))); + EXPECT_EQ(7u, e.GetStringSize(s_normal)); + EXPECT_EQ(130u, e.GetStringSize(s_long)); // truncated - EXPECT_EQ(65537u, e.GetStringSize(StringValueTest::ToNT(sv_big))); + EXPECT_EQ(65537u, e.GetStringSize(s_big)); } TEST_F(WireEncoderTest, WriteString2) { WireEncoder e(0x0200u); - e.WriteString(StringValueTest::ToNT(sv_normal)); + e.WriteString(s_normal); EXPECT_EQ(nullptr, e.error()); EXPECT_EQ(7u, e.size()); EXPECT_EQ(llvm::StringRef("\x00\x05hello", 7), llvm::StringRef(e.data(), e.size())); e.Reset(); - e.WriteString(StringValueTest::ToNT(sv_long)); + e.WriteString(s_long); EXPECT_EQ(nullptr, e.error()); ASSERT_EQ(130u, e.size()); EXPECT_EQ(llvm::StringRef("\x00\x80**", 4), llvm::StringRef(e.data(), 4)); @@ -459,7 +452,7 @@ TEST_F(WireEncoderTest, WriteString2) { // truncated e.Reset(); - e.WriteString(StringValueTest::ToNT(sv_big)); + e.WriteString(s_big); EXPECT_EQ(nullptr, e.error()); ASSERT_EQ(65537u, e.size()); EXPECT_EQ(llvm::StringRef("\xff\xff**", 4), llvm::StringRef(e.data(), 4)); @@ -470,21 +463,21 @@ TEST_F(WireEncoderTest, WriteString2) { TEST_F(WireEncoderTest, GetStringSize3) { // leb128-encoded length WireEncoder e(0x0300u); - EXPECT_EQ(6u, e.GetStringSize(StringValueTest::ToNT(sv_normal))); - EXPECT_EQ(130u, e.GetStringSize(StringValueTest::ToNT(sv_long))); - EXPECT_EQ(65540u, e.GetStringSize(StringValueTest::ToNT(sv_big))); + EXPECT_EQ(6u, e.GetStringSize(s_normal)); + EXPECT_EQ(130u, e.GetStringSize(s_long)); + EXPECT_EQ(65540u, e.GetStringSize(s_big)); } TEST_F(WireEncoderTest, WriteString3) { WireEncoder e(0x0300u); - e.WriteString(StringValueTest::ToNT(sv_normal)); + e.WriteString(s_normal); EXPECT_EQ(nullptr, e.error()); EXPECT_EQ(6u, e.size()); EXPECT_EQ(llvm::StringRef("\x05hello", 6), llvm::StringRef(e.data(), e.size())); e.Reset(); - e.WriteString(StringValueTest::ToNT(sv_long)); + e.WriteString(s_long); EXPECT_EQ(nullptr, e.error()); ASSERT_EQ(130u, e.size()); EXPECT_EQ(llvm::StringRef("\x80\x01**", 4), llvm::StringRef(e.data(), 4)); @@ -493,7 +486,7 @@ TEST_F(WireEncoderTest, WriteString3) { // NOT truncated e.Reset(); - e.WriteString(StringValueTest::ToNT(sv_big)); + e.WriteString(s_big); EXPECT_EQ(nullptr, e.error()); ASSERT_EQ(65540u, e.size()); EXPECT_EQ(llvm::StringRef("\x81\x80\x04*", 4), llvm::StringRef(e.data(), 4));