m5/M5Unit-NFC
0
0
Fork 0
mirror of https://github.com/m5stack/M5Unit-NFC.git synced 2026-05-20 11:48:34 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
M5Unit-NFC/test/ndef_test.cpp
T

674 lines
21 KiB
C++
Raw Permalink Blame History

/*
* SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
*
* SPDX-License-Identifier: MIT
*/
/*
UnitTest for NDEF
*/
#include <gtest/gtest.h>
#include <M5Unified.h>
#include <nfc/ndef/ndef.hpp>
#include <nfc/ndef/ndef_tlv.hpp>
#include <nfc/ndef/ndef_record.hpp>
#include <cstring>
using namespace m5::nfc::ndef;
namespace {
constexpr char en_data[] = "Hello M5Stack"; // 13
constexpr char ja_data[] = "こんにちは M5Stack"; // 23
constexpr char zh_data[] = "你好 M5Stack"; // 14
constexpr char en_lang[] = "en";
constexpr char ja_lang[] = "ja";
constexpr char zh_lang[] = "zh";
constexpr char ftp_data[] = "ftp://anonymous:anonymous@example.com/";
} // namespace
TEST(NDEF, Record)
{
Record r(TNF::Wellknown);
EXPECT_EQ(r.tnf(), TNF::Wellknown);
EXPECT_EQ(r.required(), 3U); // attr + type len + payload len
EXPECT_FALSE(r.attribute().idLength());
EXPECT_TRUE(strcmp(r.type(), "") == 0);
EXPECT_EQ(r.identifierSize(), 0U);
EXPECT_EQ(r.identifier(), nullptr);
EXPECT_EQ(r.payloadSize(), 0U);
EXPECT_EQ(r.payload(), nullptr);
// r.dump();
// ID
{
uint8_t id[7] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
r.setIdentifier(id, 7);
EXPECT_EQ(r.required(), 4U + 7U); // attr + type len + payload len + id len + id[7]
EXPECT_TRUE(r.attribute().idLength());
EXPECT_EQ(r.identifierSize(), 7U);
EXPECT_NE(r.identifier(), nullptr);
// r.dump();
uint8_t id2{0x52};
r.setIdentifier(&id2, 1);
EXPECT_EQ(r.required(), 4U + 1U); // id[1]
EXPECT_TRUE(r.attribute().idLength());
EXPECT_EQ(r.identifierSize(), 1U);
EXPECT_NE(r.identifier(), nullptr);
// r.dump();
r.clearIdentifier();
EXPECT_EQ(r.required(), 3U);
EXPECT_FALSE(r.attribute().idLength());
EXPECT_EQ(r.identifierSize(), 0U);
EXPECT_EQ(r.identifier(), nullptr);
// r.dump();
r.setIdentifier(id, 7);
EXPECT_EQ(r.required(), 4U + 7U);
EXPECT_TRUE(r.attribute().idLength());
EXPECT_EQ(r.identifierSize(), 7U);
EXPECT_NE(r.identifier(), nullptr);
// r.dump();
}
// Payload
{
EXPECT_TRUE(strcmp(r.type(), "") == 0);
r.setTextPayload(en_data, "en");
EXPECT_TRUE(strcmp(r.type(), "T") == 0);
EXPECT_EQ(r.required(), 4U + 1U + 7U + // attr + type len + payload len + id len + type[1] + id[7]
1U + 2U + 13U); // status + lang[2] + txt[13]
// r.dump();
r.setURIPayload("https://m5stack.com", URIProtocol::HTTPS);
EXPECT_TRUE(strcmp(r.type(), "U") == 0);
r.setTextPayload(ja_data, "ja");
EXPECT_TRUE(strcmp(r.type(), "T") == 0);
EXPECT_EQ(r.required(), 4U + 1U + 7U + //
1U + 2U + 23U); // status + lang[2] + txt[23]
// r.dump();
r.setTextPayload(zh_data, "zh");
EXPECT_TRUE(strcmp(r.type(), "T") == 0);
EXPECT_EQ(r.required(), 4U + 1U + 7U + //
1U + 2U + 14U); // status + lang[2] + txt[14]
// r.dump();
}
{
uint8_t buf[256]{};
auto encoded = r.encode(buf, 256);
EXPECT_EQ(encoded, 4U + 1U + 7U + //
1U + 2U + 14U); // status + lang[2] + txt[14]
Record r2{};
auto decoded = r2.decode(buf, encoded);
EXPECT_EQ(encoded, decoded);
EXPECT_EQ(r.attribute().value, r2.attribute().value);
auto tlen = strlen(r.type());
auto tlen2 = strlen(r2.type());
EXPECT_EQ(tlen, tlen2);
EXPECT_TRUE(std::memcmp(r.type(), r2.type(), tlen) == 0);
auto ilen = r.identifierSize();
auto ilen2 = r2.identifierSize();
EXPECT_EQ(ilen, ilen2);
EXPECT_TRUE(std::memcmp(r.identifier(), r2.identifier(), ilen) == 0);
auto plen = r.payloadSize();
auto plen2 = r2.payloadSize();
EXPECT_EQ(plen, plen2);
EXPECT_TRUE(std::memcmp(r.payload(), r2.payload(), plen) == 0);
}
// Decode error cases
{
uint8_t buf[256]{};
auto encoded = r.encode(buf, 256);
// Too short header
Record r3{};
EXPECT_EQ(r3.decode(buf, 2), 0u);
// Payload length exceeds buffer
buf[0] |= Attribute::SR; // ensure short record
buf[2] = 0xFF; // payload length too large
Record r4{};
EXPECT_EQ(r4.decode(buf, encoded), 0u);
// Long record but too short for 4-byte length
uint8_t long_buf[] = {0x00, 0x01, 0x00, 0x00, 0x00};
Record r5{};
EXPECT_EQ(r5.decode(long_buf, sizeof(long_buf)), 0u);
}
}
TEST(NDEF, TLV)
{
constexpr uint8_t empty[3] = {0x03, 0x00, 0xFE};
uint8_t buf[1024]{};
TLV msg{Tag::Message};
Record r0{}, r1{}, r2{};
{
EXPECT_EQ(msg.tag(), Tag::Message);
EXPECT_EQ(msg.records().size(), 0U);
EXPECT_EQ(msg.required(), 2); // tag + record len
// msg.dump();
auto encoded = msg.encode(buf, 256);
EXPECT_EQ(encoded, 2);
EXPECT_TRUE(std::memcmp(buf, empty, 2) == 0);
//
// 0
r0.setTextPayload(en_data, en_lang);
EXPECT_TRUE(strcmp(r0.type(), "T") == 0);
EXPECT_EQ(r0.required(), 20);
EXPECT_TRUE(strcmp(en_data, r0.payloadAsString().c_str()) == 0);
msg.push_back(r0);
EXPECT_EQ(msg.records().size(), 1U);
EXPECT_EQ(msg.required(), 2 + 20); // tag + record len + records
EXPECT_EQ(msg.required(), 2 + r0.required());
encoded = msg.encode(buf, 1024);
EXPECT_EQ(encoded, 22);
EXPECT_EQ(encoded, msg.required());
// 1
r1.setTextPayload(zh_data, zh_lang);
EXPECT_TRUE(strcmp(r1.type(), "T") == 0);
EXPECT_EQ(r1.required(), 21);
EXPECT_TRUE(strcmp(zh_data, r1.payloadAsString().c_str()) == 0);
msg.push_back(r1);
EXPECT_EQ(msg.records().size(), 2U);
EXPECT_EQ(msg.required(), 2 + 20 + 21); // tag + record len + records
EXPECT_EQ(msg.required(), 2 + r0.required() + r1.required());
encoded = msg.encode(buf, 1024);
EXPECT_EQ(encoded, 43);
EXPECT_EQ(encoded, msg.required());
// 2
r2.setURIPayload(ftp_data, URIProtocol::FTP_AA);
EXPECT_TRUE(strcmp(r2.type(), "U") == 0);
EXPECT_EQ(r2.required(), 17);
EXPECT_TRUE(strcmp(ftp_data, r2.payloadAsString().c_str()) == 0);
msg.push_back(r2);
EXPECT_EQ(msg.records().size(), 3U);
EXPECT_EQ(msg.required(), 2 + 20 + 21 + 17); // tag + record len + records
EXPECT_EQ(msg.required(), 2 + r0.required() + r1.required() + r2.required());
encoded = msg.encode(buf, 1024);
EXPECT_EQ(encoded, 60);
EXPECT_EQ(encoded, msg.required());
// M5_LOGI("[%s]", r2.payloadAsString().c_str());
// msg.dump();
}
{
auto encoded = msg.encode(buf, 256);
TLV msg2{};
auto decoded = msg2.decode(buf, encoded);
EXPECT_EQ(encoded, decoded);
auto t = msg.tag();
auto t2 = msg2.tag();
EXPECT_EQ(t, t2);
EXPECT_EQ(msg.records().size(), msg2.records().size());
EXPECT_EQ(msg.required(), msg2.required());
EXPECT_EQ(msg.records(), msg2.records());
}
// Decode error cases
{
// Invalid tag
uint8_t invalid_tag[] = {0x04, 0x00};
TLV t{};
EXPECT_EQ(t.decode(invalid_tag, sizeof(invalid_tag)), 0u);
// Extended length but too short
uint8_t short_ext_len[] = {0x01, 0xFF, 0x00};
EXPECT_EQ(t.decode(short_ext_len, sizeof(short_ext_len)), 0u);
// Payload length exceeds buffer (non-message)
uint8_t long_len[] = {0x01, 0xFF, 0x00, 0x10, 0xAA};
EXPECT_EQ(t.decode(long_len, sizeof(long_len)), 0u);
// Message TLV with MB cleared should fail
uint8_t buf2[256]{};
auto encoded = msg.encode(buf2, 256);
buf2[2] = static_cast<uint8_t>(buf2[2] & ~Attribute::MB);
TLV msg3{};
EXPECT_EQ(msg3.decode(buf2, encoded), 0u);
// Second record with MB=1 should fail
uint8_t buf3[256]{};
auto encoded3 = msg.encode(buf3, 256);
buf3[2 + r0.required()] = static_cast<uint8_t>(buf3[2 + r0.required()] | Attribute::MB);
TLV msg4{};
EXPECT_EQ(msg4.decode(buf3, encoded3), 0u);
// Last record missing ME should fail
uint8_t buf4[256]{};
auto encoded4 = msg.encode(buf4, 256);
buf4[2 + r0.required() + r1.required()] =
static_cast<uint8_t>(buf4[2 + r0.required() + r1.required()] & ~Attribute::ME);
TLV msg5{};
EXPECT_EQ(msg5.decode(buf4, encoded4), 0u);
}
}
TEST(NDEF, TagAndTagBits)
{
// tag_to_tagbit
EXPECT_EQ(tag_to_tagbit(Tag::Null), 1u << 0);
EXPECT_EQ(tag_to_tagbit(Tag::LockControl), 1u << 1);
EXPECT_EQ(tag_to_tagbit(Tag::MemoryControl), 1u << 2);
EXPECT_EQ(tag_to_tagbit(Tag::Message), 1u << 3);
EXPECT_EQ(tag_to_tagbit(Tag::Proprietary), 1u << 4);
EXPECT_EQ(tag_to_tagbit(Tag::Terminator), 1u << 5);
// make_tag_bits
auto bits1 = make_tag_bits(Tag::Message);
EXPECT_EQ(bits1, 1u << 3);
auto bits2 = make_tag_bits(Tag::Message, Tag::Terminator);
EXPECT_EQ(bits2, (1u << 3) | (1u << 5));
// contains_tag
EXPECT_TRUE(contains_tag(bits2, Tag::Message));
EXPECT_TRUE(contains_tag(bits2, Tag::Terminator));
EXPECT_FALSE(contains_tag(bits2, Tag::Null));
EXPECT_FALSE(contains_tag(bits2, Tag::LockControl));
// Pre-defined constants
EXPECT_TRUE(contains_tag(tagBitsAll, Tag::LockControl));
EXPECT_TRUE(contains_tag(tagBitsAll, Tag::MemoryControl));
EXPECT_TRUE(contains_tag(tagBitsAll, Tag::Message));
EXPECT_TRUE(contains_tag(tagBitsAll, Tag::Proprietary));
EXPECT_TRUE(contains_tag(tagBitsAll, Tag::Terminator));
EXPECT_TRUE(contains_tag(tagBitsMessage, Tag::Message));
EXPECT_FALSE(contains_tag(tagBitsMessage, Tag::Terminator));
// is_valid_tag
EXPECT_TRUE(is_valid_tag(0x00)); // Null
EXPECT_TRUE(is_valid_tag(0x01)); // LockControl
EXPECT_TRUE(is_valid_tag(0x02)); // MemoryControl
EXPECT_TRUE(is_valid_tag(0x03)); // Message
EXPECT_TRUE(is_valid_tag(0xFD)); // Proprietary
EXPECT_TRUE(is_valid_tag(0xFE)); // Terminator
EXPECT_FALSE(is_valid_tag(0x04)); // Invalid
EXPECT_FALSE(is_valid_tag(0xFF)); // Invalid
// is_terminator_tag
EXPECT_TRUE(is_terminator_tag(0xFE));
EXPECT_FALSE(is_terminator_tag(0x00));
EXPECT_FALSE(is_terminator_tag(0x03));
}
TEST(NDEF, URIProtocol)
{
// get_uri_idc_string
EXPECT_STREQ(get_uri_idc_string(URIProtocol::NA), "");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::HTTP_WWW), "http://www.");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::HTTPS_WWW), "https://www.");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::HTTP), "http://");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::HTTPS), "https://");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::TEL), "tel:");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::MAILTO), "mailto:");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::FTP_AA), "ftp://anonymous:anonymous@");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::FTP), "ftp://");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::FILE), "file://");
EXPECT_STREQ(get_uri_idc_string(URIProtocol::NFC), "urn:nfc:");
}
TEST(NDEF, Type2CapabilityContainer)
{
type2::CapabilityContainer cc{};
// Invalid by default (block[0] != MAGIC_NO)
EXPECT_FALSE(cc.valid());
// Set valid values
cc.block[0] = MAGIC_NO_CC4;
cc.major_version(NDEF_MAJOR_VERSION);
cc.minor_version(NDEF_MINOR_VERSION);
cc.ndef_size(256);
cc.read_access(ACCESS_FREE);
cc.write_access(ACCESS_FREE);
EXPECT_TRUE(cc.valid());
EXPECT_TRUE(cc.can_read());
EXPECT_TRUE(cc.can_write());
EXPECT_EQ(cc.major_version(), NDEF_MAJOR_VERSION);
EXPECT_EQ(cc.minor_version(), NDEF_MINOR_VERSION);
EXPECT_EQ(cc.ndef_size(), 256);
EXPECT_EQ(cc.read_access(), ACCESS_FREE);
EXPECT_EQ(cc.write_access(), ACCESS_FREE);
// Test read-only
cc.write_access(ACCESS_PROPRIETARY);
EXPECT_TRUE(cc.can_read());
EXPECT_FALSE(cc.can_write());
// Max NDEF size test (>2040 sets to 0)
cc.ndef_size(2048);
EXPECT_EQ(cc.ndef_size(), 0);
cc.ndef_size(2040);
EXPECT_EQ(cc.ndef_size(), 2040);
}
TEST(NDEF, Type3AttributeBlock)
{
type3::AttributeBlock ab{};
// Default version
EXPECT_EQ(ab.version(), +type3::AttributeBlock::DEFAULT_VERSION);
// Set values
ab.max_block_to_read(4);
ab.max_block_to_write(1);
ab.blocks_for_ndef_storage(0x000D); // 13 blocks
ab.write_flag(type3::AttributeBlock::WriteFlag::Done);
ab.access_flag(type3::AttributeBlock::AccessFlag::ReadWrite);
ab.current_ndef_message_length(100);
EXPECT_EQ(ab.max_block_to_read(), 4);
EXPECT_EQ(ab.max_block_to_write(), 1);
EXPECT_EQ(ab.blocks_for_ndef_storage(), 0x000D);
EXPECT_EQ(ab.write_flag(), type3::AttributeBlock::WriteFlag::Done);
EXPECT_EQ(ab.access_flag(), type3::AttributeBlock::AccessFlag::ReadWrite);
EXPECT_EQ(ab.current_ndef_message_length(), 100u);
// WriteFlag::InProgress
ab.write_flag(type3::AttributeBlock::WriteFlag::InProgress);
EXPECT_EQ(ab.write_flag(), type3::AttributeBlock::WriteFlag::InProgress);
// Checksum
auto checksum = ab.calculate_check_sum();
EXPECT_NE(checksum, 0);
ab.update_check_sum();
EXPECT_EQ(ab.check_sum(), checksum);
}
TEST(NDEF, Type4FileControl)
{
using namespace type4;
// fc_to_fcbit
EXPECT_EQ(fc_to_fcbit(FileControlTag::Message), 1u << 0);
EXPECT_EQ(fc_to_fcbit(FileControlTag::Proprietary), 1u << 1);
// make_fc_bits
auto bits = make_fc_bits(FileControlTag::Message, FileControlTag::Proprietary);
EXPECT_TRUE(contains_file_control_tag(bits, FileControlTag::Message));
EXPECT_TRUE(contains_file_control_tag(bits, FileControlTag::Proprietary));
EXPECT_TRUE(contains_file_control_tag(fcBitsAll, FileControlTag::Message));
EXPECT_TRUE(contains_file_control_tag(fcBitsAll, FileControlTag::Proprietary));
EXPECT_TRUE(contains_file_control_tag(fcBitsMessage, FileControlTag::Message));
EXPECT_FALSE(contains_file_control_tag(fcBitsMessage, FileControlTag::Proprietary));
// FileControlTLV
FileControlTLV fctlv{};
fctlv.tag = 0x04;
EXPECT_EQ(fctlv.fctag(), FileControlTag::Message);
// CapabilityContainer (basic)
CapabilityContainer cc{};
EXPECT_FALSE(cc.valid()); // Empty fctlvs
}
TEST(NDEF, Type5CapabilityContainer)
{
type5::CapabilityContainer cc{};
// Invalid by default
EXPECT_FALSE(cc.valid());
EXPECT_EQ(cc.size(), 0);
// 4-byte CC
cc.block[0] = MAGIC_NO_CC4;
cc.major_version(NDEF_MAJOR_VERSION);
cc.minor_version(NDEF_MINOR_VERSION);
cc.ndef_size(256);
cc.read_access(ACCESS_FREE);
cc.write_access(ACCESS_FREE);
EXPECT_TRUE(cc.valid());
EXPECT_EQ(cc.size(), 4);
EXPECT_TRUE(cc.can_read());
EXPECT_TRUE(cc.can_write());
EXPECT_EQ(cc.major_version(), NDEF_MAJOR_VERSION);
EXPECT_EQ(cc.minor_version(), NDEF_MINOR_VERSION);
EXPECT_EQ(cc.ndef_size(), 256);
// 8-byte CC
type5::CapabilityContainer cc8{};
cc8.block[0] = MAGIC_NO_CC8;
cc8.major_version(NDEF_MAJOR_VERSION);
cc8.minor_version(NDEF_MINOR_VERSION);
cc8.block[6] = 0x10; // ndef_size high byte
cc8.block[7] = 0x00; // ndef_size low byte (4096)
EXPECT_TRUE(cc8.valid());
EXPECT_EQ(cc8.size(), 8);
EXPECT_EQ(cc8.ndef_size(), 0x1000);
// Additional feature
cc.additional_feature(0x01);
EXPECT_EQ(cc.additional_feature(), 0x01);
}
TEST(NDEF, TLVExtended)
{
// Terminator TLV
EXPECT_TRUE(TLV::Terminator.isTerminatorTLV());
EXPECT_FALSE(TLV::Terminator.isMessageTLV());
EXPECT_FALSE(TLV::Terminator.isNullTLV());
EXPECT_EQ(TLV::Terminator.tag(), Tag::Terminator);
// Null TLV
TLV nullTlv{Tag::Null};
EXPECT_TRUE(nullTlv.isNullTLV());
EXPECT_FALSE(nullTlv.isMessageTLV());
EXPECT_FALSE(nullTlv.isTerminatorTLV());
// Message TLV
TLV msgTlv{Tag::Message};
EXPECT_TRUE(msgTlv.isMessageTLV());
EXPECT_FALSE(msgTlv.isNullTLV());
EXPECT_FALSE(msgTlv.isTerminatorTLV());
// pop_back
Record r;
r.setTextPayload("Test", "en");
msgTlv.push_back(r);
EXPECT_EQ(msgTlv.records().size(), 1u);
msgTlv.pop_back();
EXPECT_EQ(msgTlv.records().size(), 0u);
// clear (note: tag is reset to Null by clear())
msgTlv.push_back(r);
msgTlv.push_back(r);
EXPECT_EQ(msgTlv.records().size(), 2u);
msgTlv.clear();
EXPECT_EQ(msgTlv.records().size(), 0u);
EXPECT_EQ(msgTlv.tag(), Tag::Null);
EXPECT_EQ(msgTlv.payload().size(), 0u);
// Non-message TLV payload
TLV lockTlv{Tag::LockControl};
lockTlv.payload().push_back(0x01);
lockTlv.payload().push_back(0x02);
EXPECT_EQ(lockTlv.payload().size(), 2u);
}
TEST(NDEF, RecordLengthBoundary)
{
Record r(TNF::Wellknown);
r.setType("U");
std::vector<uint8_t> payload255(255, 0xAB);
r.setPayload(payload255.data(), payload255.size());
EXPECT_TRUE(r.attribute().shortRecord());
std::vector<uint8_t> buf(512);
auto encoded = r.encode(buf.data(), buf.size());
EXPECT_GT(encoded, 0u);
Record r2{};
auto decoded = r2.decode(buf.data(), encoded);
EXPECT_EQ(decoded, encoded);
EXPECT_TRUE(r2.attribute().shortRecord());
std::vector<uint8_t> payload256(256, 0xCD);
r.setPayload(payload256.data(), payload256.size());
EXPECT_FALSE(r.attribute().shortRecord());
encoded = r.encode(buf.data(), buf.size());
EXPECT_GT(encoded, 0u);
decoded = r2.decode(buf.data(), encoded);
EXPECT_EQ(decoded, encoded);
EXPECT_FALSE(r2.attribute().shortRecord());
}
TEST(NDEF, RecordEmptyTNF)
{
Record r(TNF::Empty);
uint8_t id[2] = {0x01, 0x02};
uint8_t payload[3] = {0xAA, 0xBB, 0xCC};
r.setIdentifier(id, sizeof(id));
r.setPayload(payload, sizeof(payload));
EXPECT_EQ(r.identifierSize(), 0u);
EXPECT_EQ(r.payloadSize(), 0u);
EXPECT_EQ(r.required(), 3u);
}
TEST(NDEF, TLVExtendedLength)
{
uint8_t buf[1024]{};
TLV lockTlv{Tag::LockControl};
lockTlv.payload().assign(0xFF, 0x11);
auto encoded = lockTlv.encode(buf, sizeof(buf));
EXPECT_GT(encoded, 0u);
EXPECT_EQ(buf[0], m5::stl::to_underlying(Tag::LockControl));
EXPECT_EQ(buf[1], 0xFF);
EXPECT_EQ(buf[2], 0x00);
EXPECT_EQ(buf[3], 0xFF);
TLV lockTlv2{};
auto decoded = lockTlv2.decode(buf, encoded);
EXPECT_EQ(decoded, encoded);
EXPECT_EQ(lockTlv2.payload().size(), 0xFFu);
lockTlv.payload().assign(0x100, 0x22);
encoded = lockTlv.encode(buf, sizeof(buf));
EXPECT_GT(encoded, 0u);
EXPECT_EQ(buf[1], 0xFF);
EXPECT_EQ(buf[2], 0x01);
EXPECT_EQ(buf[3], 0x00);
decoded = lockTlv2.decode(buf, encoded);
EXPECT_EQ(decoded, encoded);
EXPECT_EQ(lockTlv2.payload().size(), 0x100u);
}
TEST(NDEF, Attribute)
{
Attribute attr{};
// Default state
EXPECT_FALSE(attr.messageBegin());
EXPECT_FALSE(attr.messageEnd());
EXPECT_FALSE(attr.chunk());
EXPECT_FALSE(attr.shortRecord());
EXPECT_FALSE(attr.idLength());
EXPECT_EQ(attr.tnf(), TNF::Empty);
// Set flags
attr.messageBegin(true);
EXPECT_TRUE(attr.messageBegin());
EXPECT_EQ(attr.value & Attribute::MB, Attribute::MB);
attr.messageEnd(true);
EXPECT_TRUE(attr.messageEnd());
attr.chunk(true);
EXPECT_TRUE(attr.chunk());
attr.shortRecord(true);
EXPECT_TRUE(attr.shortRecord());
attr.idLength(true);
EXPECT_TRUE(attr.idLength());
attr.tnf(TNF::Wellknown);
EXPECT_EQ(attr.tnf(), TNF::Wellknown);
// Clear flags
attr.messageBegin(false);
EXPECT_FALSE(attr.messageBegin());
// TNF values
attr.tnf(TNF::MIMEMedia);
EXPECT_EQ(attr.tnf(), TNF::MIMEMedia);
attr.tnf(TNF::URI);
EXPECT_EQ(attr.tnf(), TNF::URI);
attr.tnf(TNF::External);
EXPECT_EQ(attr.tnf(), TNF::External);
}
TEST(NDEF, RecordExtended)
{
// Record comparison
Record r1(TNF::Wellknown);
Record r2(TNF::Wellknown);
r1.setTextPayload("Hello", "en");
r2.setTextPayload("Hello", "en");
EXPECT_TRUE(r1 == r2);
EXPECT_FALSE(r1 != r2);
r2.setTextPayload("World", "en");
EXPECT_FALSE(r1 == r2);
EXPECT_TRUE(r1 != r2);
// Different TNF
Record r3(TNF::MIMEMedia);
r3.setType("text/plain");
EXPECT_FALSE(r1 == r3);
// Record::clear
r1.clear();
EXPECT_EQ(r1.payloadSize(), 0u);
EXPECT_EQ(r1.identifierSize(), 0u);
EXPECT_TRUE(strcmp(r1.type(), "") == 0);
// URI payload with different protocols
Record uriRec(TNF::Wellknown);
uriRec.setURIPayload("https://www.example.com", URIProtocol::HTTPS_WWW);
EXPECT_STREQ(uriRec.type(), "U");
// The protocol prefix should be stripped
EXPECT_TRUE(uriRec.payloadSize() > 0);
}
Reference in New Issue View Git Blame Copy Permalink