ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Re-run astyle

pull/7822/head
Donatien Garnier 2018-08-29 16:59:45 +01:00
parent 64d65fdf56
commit bfd433984f
6 changed files with 273 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

410
TESTS/nfc/eeprom/main.cpp
View File

@ -31,38 +31,38 @@ using namespace utest::v1;
/* individual steps that map to specific operations that include parameters */ /* individual steps that map to specific operations that include parameters */
typedef enum { typedef enum {
START_SESSION = 0x0000, START_SESSION = 0x0000,
END_SESSION = 0x0100, END_SESSION = 0x0100,
READ_BYTES = 0x0200, READ_BYTES = 0x0200,
READ_2_BYTES = 0x0201, READ_2_BYTES = 0x0201,
READ_2_BYTES_OFFSET_FAIL = 0x0202, READ_2_BYTES_OFFSET_FAIL = 0x0202,
READ_4_BYTES = 0x0203, READ_4_BYTES = 0x0203,
READ_4_BYTES_MIXED = 0x0204, READ_4_BYTES_MIXED = 0x0204,
READ_4_BYTES_OFFSET = 0x0205, READ_4_BYTES_OFFSET = 0x0205,
READ_4_BYTES_ERASED = 0x0206, READ_4_BYTES_ERASED = 0x0206,
READ_4_BYTES_FAIL = 0x0207, READ_4_BYTES_FAIL = 0x0207,
WRITE_BYTES = 0x0300, WRITE_BYTES = 0x0300,
WRITE_2_BYTES = 0x0301, WRITE_2_BYTES = 0x0301,
WRITE_2_BYTES_OFFSET = 0x0302, WRITE_2_BYTES_OFFSET = 0x0302,
WRITE_2_BYTES_OFFSET_FAIL = 0x0303, WRITE_2_BYTES_OFFSET_FAIL = 0x0303,
WRITE_4_BYTES = 0x0304, WRITE_4_BYTES = 0x0304,
WRITE_4_BYTES_FAIL = 0x0305, WRITE_4_BYTES_FAIL = 0x0305,
ERASE_BYTES = 0x0400, ERASE_BYTES = 0x0400,
ERASE_4_BYTES = 0x0401, ERASE_4_BYTES = 0x0401,
READ_SIZE = 0x0500, READ_SIZE = 0x0500,
READ_SIZE_2 = 0x0501, READ_SIZE_2 = 0x0501,
READ_SIZE_4 = 0x0502, READ_SIZE_4 = 0x0502,
WRITE_SIZE = 0x0600, WRITE_SIZE = 0x0600,
WRITE_SIZE_2 = 0x0601, WRITE_SIZE_2 = 0x0601,
WRITE_SIZE_4 = 0x0602, WRITE_SIZE_4 = 0x0602,
TERMINATE = 0xFF00 TERMINATE = 0xFF00
} TestCommand_t; } TestCommand_t;
/* We group the command based on their fist byte to simplify step checking. /* We group the command based on their fist byte to simplify step checking.
@ -72,15 +72,15 @@ const size_t TEST_COMMAND_GROUP_MASK = 0xFF00;
/* test case sequences that index into the array of commands which comprise them */ /* test case sequences that index into the array of commands which comprise them */
typedef enum { typedef enum {
SESSION_TEST, SESSION_TEST,
WRITE_READ_TEST, WRITE_READ_TEST,
ERASE_TEST, ERASE_TEST,
WRITE_READ_SIZE_TEST, WRITE_READ_SIZE_TEST,
TRUNCATE_TEST, TRUNCATE_TEST,
WRITE_TRUNCATE_TEST, WRITE_TRUNCATE_TEST,
WRITE_WITH_OFFSET_TEST, WRITE_WITH_OFFSET_TEST,
WRITE_BEYOND_SIZE_TEST, WRITE_BEYOND_SIZE_TEST,
SEQUENCE_MAX SEQUENCE_MAX
} TestSequence_t; } TestSequence_t;
static EventQueue event_queue(/* event count */ 10 * EVENTS_EVENT_SIZE); static EventQueue event_queue(/* event count */ 10 * EVENTS_EVENT_SIZE);
@ -95,32 +95,46 @@ static const TestCommand_t SEQUENCES[SEQUENCE_MAX][MAX_STEP] = {
{ START_SESSION, END_SESSION, TERMINATE }, { START_SESSION, END_SESSION, TERMINATE },
/* WRITE_READ_TEST */ /* WRITE_READ_TEST */
{ START_SESSION, WRITE_SIZE_4, READ_SIZE_4, WRITE_4_BYTES, READ_4_BYTES, {
WRITE_2_BYTES, READ_4_BYTES_MIXED, END_SESSION, TERMINATE }, START_SESSION, WRITE_SIZE_4, READ_SIZE_4, WRITE_4_BYTES, READ_4_BYTES,
WRITE_2_BYTES, READ_4_BYTES_MIXED, END_SESSION, TERMINATE
},
/* ERASE_TEST */ /* ERASE_TEST */
{ START_SESSION, WRITE_SIZE_4, READ_SIZE_4, WRITE_4_BYTES, READ_4_BYTES, {
ERASE_4_BYTES, READ_4_BYTES_ERASED, END_SESSION, TERMINATE }, START_SESSION, WRITE_SIZE_4, READ_SIZE_4, WRITE_4_BYTES, READ_4_BYTES,
ERASE_4_BYTES, READ_4_BYTES_ERASED, END_SESSION, TERMINATE
},
/* WRITE_READ_SIZE_TEST */ /* WRITE_READ_SIZE_TEST */
{ START_SESSION, WRITE_SIZE_2, READ_SIZE_2, WRITE_SIZE_4, READ_SIZE_4, {
END_SESSION, TERMINATE }, START_SESSION, WRITE_SIZE_2, READ_SIZE_2, WRITE_SIZE_4, READ_SIZE_4,
END_SESSION, TERMINATE
},
/* TRUNCATE_TEST */ /* TRUNCATE_TEST */
{ START_SESSION, WRITE_SIZE_4, READ_SIZE_4, WRITE_4_BYTES, READ_4_BYTES, {
WRITE_SIZE_2, READ_SIZE_2, READ_4_BYTES_FAIL, END_SESSION, TERMINATE }, START_SESSION, WRITE_SIZE_4, READ_SIZE_4, WRITE_4_BYTES, READ_4_BYTES,
WRITE_SIZE_2, READ_SIZE_2, READ_4_BYTES_FAIL, END_SESSION, TERMINATE
},
/* WRITE_TRUNCATE_TEST */ /* WRITE_TRUNCATE_TEST */
{ START_SESSION, WRITE_SIZE_2, READ_SIZE_2, WRITE_4_BYTES_FAIL, READ_4_BYTES_FAIL, {
END_SESSION, TERMINATE }, START_SESSION, WRITE_SIZE_2, READ_SIZE_2, WRITE_4_BYTES_FAIL, READ_4_BYTES_FAIL,
END_SESSION, TERMINATE
},
/* WRITE_WITH_OFFSET_TEST */ /* WRITE_WITH_OFFSET_TEST */
{ START_SESSION, WRITE_SIZE_4, READ_SIZE_4, WRITE_4_BYTES, READ_4_BYTES, {
WRITE_2_BYTES_OFFSET, READ_4_BYTES_OFFSET, END_SESSION, TERMINATE }, START_SESSION, WRITE_SIZE_4, READ_SIZE_4, WRITE_4_BYTES, READ_4_BYTES,
WRITE_2_BYTES_OFFSET, READ_4_BYTES_OFFSET, END_SESSION, TERMINATE
},
/* WRITE_BEYOND_SIZE_TEST */ /* WRITE_BEYOND_SIZE_TEST */
{ START_SESSION, WRITE_SIZE_2, READ_SIZE_2, WRITE_2_BYTES_OFFSET_FAIL, READ_2_BYTES_OFFSET_FAIL, {
WRITE_2_BYTES, READ_2_BYTES, END_SESSION, TERMINATE } START_SESSION, WRITE_SIZE_2, READ_SIZE_2, WRITE_2_BYTES_OFFSET_FAIL, READ_2_BYTES_OFFSET_FAIL,
WRITE_2_BYTES, READ_2_BYTES, END_SESSION, TERMINATE
}
}; };
static const uint8_t DATA_4_BYTES[] = { 0x01, 0x02, 0x03, 0x04 }; static const uint8_t DATA_4_BYTES[] = { 0x01, 0x02, 0x03, 0x04 };
@ -129,23 +143,23 @@ static const uint8_t DATA_4_BYTES_MIXED[] = { 0x05, 0x06, 0x03, 0x04 };
static const uint8_t DATA_4_BYTES_OFFSET[] = { 0x01, 0x02, 0x05, 0x06 }; static const uint8_t DATA_4_BYTES_OFFSET[] = { 0x01, 0x02, 0x05, 0x06 };
static const uint8_t DATA_4_BYTES_ERASED[] = { 0x00, 0x00, 0x00, 0x00 }; static const uint8_t DATA_4_BYTES_ERASED[] = { 0x00, 0x00, 0x00, 0x00 };
class DriverTest : public NFCEEPROMDriver::Delegate class DriverTest : public NFCEEPROMDriver::Delegate {
{
public: public:
DriverTest(NFCEEPROMDriver* _driver) DriverTest(NFCEEPROMDriver *_driver)
: _operation_data(NULL), : _operation_data(NULL),
_driver(_driver), _driver(_driver),
_sequence(SEQUENCE_MAX), _sequence(SEQUENCE_MAX),
_step(0), _step(0),
_result_size(0), _result_size(0),
_address(0), _address(0),
_success(true) { }; _success(true) { };
virtual ~DriverTest() { }; virtual ~DriverTest() { };
/* Delegate events */ /* Delegate events */
virtual void on_session_started(bool success) { virtual void on_session_started(bool success)
{
if (success != _success) { if (success != _success) {
TEST_FAIL_MESSAGE("failed to start session"); TEST_FAIL_MESSAGE("failed to start session");
} }
@ -153,7 +167,8 @@ public:
evaluate_step(START_SESSION); evaluate_step(START_SESSION);
}; };
virtual void on_session_ended(bool success) { virtual void on_session_ended(bool success)
{
if (success != _success) { if (success != _success) {
TEST_FAIL_MESSAGE("failed to end session"); TEST_FAIL_MESSAGE("failed to end session");
} }
@ -161,7 +176,8 @@ public:
evaluate_step(END_SESSION); evaluate_step(END_SESSION);
}; };
virtual void on_bytes_read(size_t count) { virtual void on_bytes_read(size_t count)
{
if (count != _result_size) { if (count != _result_size) {
TEST_FAIL_MESSAGE("failed to read bytes"); TEST_FAIL_MESSAGE("failed to read bytes");
} }
@ -172,7 +188,8 @@ public:
evaluate_step(READ_BYTES); evaluate_step(READ_BYTES);
}; };
virtual void on_bytes_written(size_t count) { virtual void on_bytes_written(size_t count)
{
if (count != _result_size) { if (count != _result_size) {
TEST_FAIL_MESSAGE("failed to write bytes"); TEST_FAIL_MESSAGE("failed to write bytes");
} }
@ -180,7 +197,8 @@ public:
evaluate_step(WRITE_BYTES); evaluate_step(WRITE_BYTES);
}; };
virtual void on_size_written(bool success) { virtual void on_size_written(bool success)
{
if (success != _success) { if (success != _success) {
TEST_FAIL_MESSAGE("failed to write size"); TEST_FAIL_MESSAGE("failed to write size");
} }
@ -188,7 +206,8 @@ public:
evaluate_step(WRITE_SIZE); evaluate_step(WRITE_SIZE);
}; };
virtual void on_size_read(bool success, size_t size) { virtual void on_size_read(bool success, size_t size)
{
if (success != _success || size != _result_size) { if (success != _success || size != _result_size) {
TEST_FAIL_MESSAGE("failed to read size"); TEST_FAIL_MESSAGE("failed to read size");
} }
@ -196,7 +215,8 @@ public:
evaluate_step(READ_SIZE); evaluate_step(READ_SIZE);
}; };
virtual void on_bytes_erased(size_t count) { virtual void on_bytes_erased(size_t count)
{
if (count != _result_size) { if (count != _result_size) {
TEST_FAIL_MESSAGE("failed to erase bytes"); TEST_FAIL_MESSAGE("failed to erase bytes");
} }
@ -206,7 +226,8 @@ public:
/* Sequence running code */ /* Sequence running code */
void run_sequence(TestSequence_t sequence) { void run_sequence(TestSequence_t sequence)
{
_sequence = sequence; _sequence = sequence;
if (_sequence >= SEQUENCE_MAX) { if (_sequence >= SEQUENCE_MAX) {
@ -220,139 +241,141 @@ public:
TEST_ASSERT_EQUAL(TERMINATE, SEQUENCES[_sequence][_step]); TEST_ASSERT_EQUAL(TERMINATE, SEQUENCES[_sequence][_step]);
} }
void execute_next_step() { void execute_next_step()
{
TestCommand_t command = SEQUENCES[_sequence][_step]; TestCommand_t command = SEQUENCES[_sequence][_step];
/* setup data buffer */ /* setup data buffer */
switch(command) { switch (command) {
case READ_2_BYTES: case READ_2_BYTES:
case READ_2_BYTES_OFFSET_FAIL: case READ_2_BYTES_OFFSET_FAIL:
case WRITE_2_BYTES: case WRITE_2_BYTES:
case WRITE_2_BYTES_OFFSET: case WRITE_2_BYTES_OFFSET:
case WRITE_2_BYTES_OFFSET_FAIL: case WRITE_2_BYTES_OFFSET_FAIL:
_operation_data = DATA_2_BYTES; _operation_data = DATA_2_BYTES;
break; break;
case READ_4_BYTES: case READ_4_BYTES:
case READ_4_BYTES_FAIL: case READ_4_BYTES_FAIL:
case WRITE_4_BYTES: case WRITE_4_BYTES:
case WRITE_4_BYTES_FAIL: case WRITE_4_BYTES_FAIL:
_operation_data = DATA_4_BYTES; _operation_data = DATA_4_BYTES;
break; break;
case READ_4_BYTES_ERASED: case READ_4_BYTES_ERASED:
_operation_data = DATA_4_BYTES_ERASED; _operation_data = DATA_4_BYTES_ERASED;
break; break;
case READ_4_BYTES_MIXED: case READ_4_BYTES_MIXED:
_operation_data = DATA_4_BYTES_MIXED; _operation_data = DATA_4_BYTES_MIXED;
break; break;
case READ_4_BYTES_OFFSET: case READ_4_BYTES_OFFSET:
_operation_data = DATA_4_BYTES_OFFSET; _operation_data = DATA_4_BYTES_OFFSET;
break; break;
default: default:
_operation_data = NULL; _operation_data = NULL;
} }
/* setup result size */ /* setup result size */
switch(command) { switch (command) {
case READ_2_BYTES: case READ_2_BYTES:
case READ_4_BYTES_FAIL: case READ_4_BYTES_FAIL:
case WRITE_2_BYTES: case WRITE_2_BYTES:
case WRITE_4_BYTES_FAIL: case WRITE_4_BYTES_FAIL:
case WRITE_2_BYTES_OFFSET: case WRITE_2_BYTES_OFFSET:
case READ_SIZE_2: case READ_SIZE_2:
_result_size = 2; _result_size = 2;
break; break;
case READ_4_BYTES: case READ_4_BYTES:
case READ_4_BYTES_ERASED: case READ_4_BYTES_ERASED:
case READ_4_BYTES_MIXED: case READ_4_BYTES_MIXED:
case READ_4_BYTES_OFFSET: case READ_4_BYTES_OFFSET:
case WRITE_4_BYTES: case WRITE_4_BYTES:
case ERASE_4_BYTES: case ERASE_4_BYTES:
case READ_SIZE_4: case READ_SIZE_4:
_result_size = 4; _result_size = 4;
break; break;
default: default:
_result_size = 0; _result_size = 0;
} }
/* setup operation size */ /* setup operation size */
switch(command) { switch (command) {
case READ_2_BYTES: case READ_2_BYTES:
case READ_2_BYTES_OFFSET_FAIL: case READ_2_BYTES_OFFSET_FAIL:
case WRITE_2_BYTES: case WRITE_2_BYTES:
case WRITE_2_BYTES_OFFSET: case WRITE_2_BYTES_OFFSET:
case WRITE_2_BYTES_OFFSET_FAIL: case WRITE_2_BYTES_OFFSET_FAIL:
case WRITE_SIZE_2: case WRITE_SIZE_2:
_operation_size = 2; _operation_size = 2;
break; break;
case READ_4_BYTES: case READ_4_BYTES:
case READ_4_BYTES_ERASED: case READ_4_BYTES_ERASED:
case READ_4_BYTES_MIXED: case READ_4_BYTES_MIXED:
case READ_4_BYTES_OFFSET: case READ_4_BYTES_OFFSET:
case READ_4_BYTES_FAIL: case READ_4_BYTES_FAIL:
case WRITE_4_BYTES: case WRITE_4_BYTES:
case WRITE_4_BYTES_FAIL: case WRITE_4_BYTES_FAIL:
case ERASE_4_BYTES: case ERASE_4_BYTES:
case READ_SIZE_4: case READ_SIZE_4:
case WRITE_SIZE_4: case WRITE_SIZE_4:
_operation_size = 4; _operation_size = 4;
break; break;
default: default:
_operation_size = 0; _operation_size = 0;
} }
/* setup offset */ /* setup offset */
switch(command) { switch (command) {
case READ_2_BYTES_OFFSET_FAIL: case READ_2_BYTES_OFFSET_FAIL:
case WRITE_2_BYTES_OFFSET: case WRITE_2_BYTES_OFFSET:
case WRITE_2_BYTES_OFFSET_FAIL: case WRITE_2_BYTES_OFFSET_FAIL:
_address = 2; _address = 2;
break; break;
default: default:
_address = 0; _address = 0;
} }
/* setup command success */ /* setup command success */
switch(command) { switch (command) {
case READ_2_BYTES_OFFSET_FAIL: case READ_2_BYTES_OFFSET_FAIL:
case WRITE_2_BYTES_OFFSET_FAIL: case WRITE_2_BYTES_OFFSET_FAIL:
_success = false; _success = false;
break; break;
default: default:
_success = true; _success = true;
} }
/* call next command */ /* call next command */
switch(command&TEST_COMMAND_GROUP_MASK) { switch (command & TEST_COMMAND_GROUP_MASK) {
case START_SESSION: case START_SESSION:
_driver->start_session(true); _driver->start_session(true);
break; break;
case END_SESSION: case END_SESSION:
_driver->end_session(); _driver->end_session();
break; break;
case READ_BYTES: case READ_BYTES:
_driver->read_bytes(_address, _buffer, _operation_size); _driver->read_bytes(_address, _buffer, _operation_size);
break; break;
case WRITE_BYTES: case WRITE_BYTES:
_driver->write_bytes(_address, _operation_data, _operation_size); _driver->write_bytes(_address, _operation_data, _operation_size);
break; break;
case ERASE_BYTES: case ERASE_BYTES:
_driver->erase_bytes(_address, 4); _driver->erase_bytes(_address, 4);
break; break;
case READ_SIZE: case READ_SIZE:
_driver->read_size(); _driver->read_size();
break; break;
case WRITE_SIZE: case WRITE_SIZE:
_driver->write_size(_operation_size); _driver->write_size(_operation_size);
break; break;
case TERMINATE: case TERMINATE:
event_queue.break_dispatch(); event_queue.break_dispatch();
break; break;
default: default:
TEST_FAIL_MESSAGE("internal test failure - invalid command"); TEST_FAIL_MESSAGE("internal test failure - invalid command");
} }
} }
void evaluate_step(TestCommand_t command_completed) { void evaluate_step(TestCommand_t command_completed)
{
/* check last command succeeded */ /* check last command succeeded */
TEST_ASSERT_EQUAL(command_completed, SEQUENCES[_sequence][_step]&TEST_COMMAND_GROUP_MASK); TEST_ASSERT_EQUAL(command_completed, SEQUENCES[_sequence][_step]&TEST_COMMAND_GROUP_MASK);
@ -369,7 +392,7 @@ private:
uint8_t _buffer[BUFFER_MAX]; uint8_t _buffer[BUFFER_MAX];
const uint8_t *_operation_data; const uint8_t *_operation_data;
NFCEEPROMDriver* _driver; NFCEEPROMDriver *_driver;
TestSequence_t _sequence; TestSequence_t _sequence;
size_t _step; size_t _step;
@ -382,7 +405,7 @@ private:
/* test case running code */ /* test case running code */
static DriverTest *driver_test; static DriverTest *driver_test;
extern NFCEEPROMDriver* greentea_nfc_EEPROM_driver_get_instance(); extern NFCEEPROMDriver *greentea_nfc_EEPROM_driver_get_instance();
utest::v1::status_t test_setup(const Case *const source, const size_t index_of_case) utest::v1::status_t test_setup(const Case *const source, const size_t index_of_case)
{ {
@ -398,35 +421,43 @@ utest::v1::status_t test_setup(const Case *const source, const size_t index_of_c
return greentea_case_setup_handler(source, index_of_case); return greentea_case_setup_handler(source, index_of_case);
} }
void session() { void session()
{
driver_test->run_sequence(SESSION_TEST); driver_test->run_sequence(SESSION_TEST);
} }
void write_read() { void write_read()
{
driver_test->run_sequence(WRITE_READ_TEST); driver_test->run_sequence(WRITE_READ_TEST);
} }
void erase_bytes() { void erase_bytes()
{
driver_test->run_sequence(ERASE_TEST); driver_test->run_sequence(ERASE_TEST);
} }
void write_read_size() { void write_read_size()
{
driver_test->run_sequence(WRITE_READ_SIZE_TEST); driver_test->run_sequence(WRITE_READ_SIZE_TEST);
} }
void truncate_size() { void truncate_size()
{
driver_test->run_sequence(TRUNCATE_TEST); driver_test->run_sequence(TRUNCATE_TEST);
} }
void write_bytes_truncated() { void write_bytes_truncated()
{
driver_test->run_sequence(WRITE_TRUNCATE_TEST); driver_test->run_sequence(WRITE_TRUNCATE_TEST);
} }
void write_with_offset() { void write_with_offset()
{
driver_test->run_sequence(WRITE_WITH_OFFSET_TEST); driver_test->run_sequence(WRITE_WITH_OFFSET_TEST);
} }
void write_beyond_size() { void write_beyond_size()
{
driver_test->run_sequence(WRITE_BEYOND_SIZE_TEST); driver_test->run_sequence(WRITE_BEYOND_SIZE_TEST);
} }
@ -461,6 +492,7 @@ Case cases[] = {
Specification specification(test_init, cases); Specification specification(test_init, cases);
// Entry point into the tests // Entry point into the tests
int main() { int main()
{
return !Harness::run(specification); return !Harness::run(specification);
} }

14
features/nfc/nfc/ndef/MessageBuilder.h
View File

@ -54,7 +54,7 @@ public:
* *
* @param buffer The buffer used to construct the payload. * @param buffer The buffer used to construct the payload.
*/ */
virtual void build(const Span<uint8_t>& buffer) const = 0; virtual void build(const Span<uint8_t> &buffer) const = 0;
protected: protected:
/** /**
@ -140,7 +140,7 @@ public:
*/ */
static size_t compute_record_size( static size_t compute_record_size(
const Record &record, const Record &record,
const PayloadBuilder* builder = NULL const PayloadBuilder *builder = NULL
); );
/** /**
@ -170,17 +170,17 @@ public:
private: private:
// append fields // append fields
void append_header(const Record &record, const PayloadBuilder*); void append_header(const Record &record, const PayloadBuilder *);
void append_type_length(const Record &record); void append_type_length(const Record &record);
void append_payload_length(const Record &, const PayloadBuilder*); void append_payload_length(const Record &, const PayloadBuilder *);
void append_id_length(const Record &); void append_id_length(const Record &);
void append_type(const Record &); void append_type(const Record &);
void append_id(const Record &); void append_id(const Record &);
void append_payload(const Record &, const PayloadBuilder*); void append_payload(const Record &, const PayloadBuilder *);
// helpers // helpers
static bool is_short_payload(const Record &record, const PayloadBuilder*); static bool is_short_payload(const Record &record, const PayloadBuilder *);
static size_t get_payload_size(const Record &, const PayloadBuilder*); static size_t get_payload_size(const Record &, const PayloadBuilder *);
// builder state. // builder state.
Span<uint8_t> _message_buffer; Span<uint8_t> _message_buffer;

3
features/nfc/source/nfc/ndef/MessageBuilder.cpp
View File

@ -51,7 +51,8 @@ bool MessageBuilder::append_record(
const RecordType &type, const RecordType &type,
const PayloadBuilder &builder, const PayloadBuilder &builder,
bool is_last_record bool is_last_record
) { )
{
Record record( Record record(
type, type,
RecordPayload(), RecordPayload(),

36
features/nfc/source/nfc/ndef/common/Mime.cpp
View File

@ -99,29 +99,29 @@ bool Mime::append_as_record(
) const ) const
{ {
return message_builder.append_record( return message_builder.append_record(
RecordType( RecordType(
RecordType::media_type, RecordType::media_type,
get_mime_type() get_mime_type()
), ),
get_mime_content(), get_mime_content(),
is_last_record is_last_record
); );
} }
size_t Mime::get_record_size() const size_t Mime::get_record_size() const
{ {
return MessageBuilder::compute_record_size( return MessageBuilder::compute_record_size(
Record( Record(
RecordType( RecordType(
RecordType::media_type, RecordType::media_type,
get_mime_type() get_mime_type()
), ),
get_mime_content(), get_mime_content(),
RecordID(), RecordID(),
/* chunk */ false, /* chunk */ false,
/* last record */ false /* last record */ false
) )
); );
} }
void Mime::move_data( void Mime::move_data(

28
features/nfc/source/nfc/ndef/common/Text.cpp
View File

@ -125,9 +125,9 @@ Span<const uint8_t> Text::get_text() const
size_t language_code_size = get_language_code().size(); size_t language_code_size = get_language_code().size();
return make_const_Span( return make_const_Span(
_text_record + header_size + language_code_size, _text_record + header_size + language_code_size,
_text_record_size - header_size - language_code_size _text_record_size - header_size - language_code_size
); );
} }
void Text::move_data(uint8_t *text, size_t size) void Text::move_data(uint8_t *text, size_t size)
@ -164,17 +164,17 @@ size_t Text::get_record_size() const
} }
return MessageBuilder::compute_record_size( return MessageBuilder::compute_record_size(
Record( Record(
RecordType( RecordType(
RecordType::well_known_type, RecordType::well_known_type,
text_record_type_value text_record_type_value
), ),
RecordPayload(_text_record, _text_record_size), RecordPayload(_text_record, _text_record_size),
RecordID(), RecordID(),
/* chunk */ false, /* chunk */ false,
/* last record */ false /* last record */ false
) )
); );
} }
bool TextParser::do_parse(const Record &record, Text &text) bool TextParser::do_parse(const Record &record, Text &text)

22
features/nfc/source/nfc/ndef/common/URI.cpp
View File

@ -136,17 +136,17 @@ size_t URI::get_record_size() const
} }
return MessageBuilder::compute_record_size( return MessageBuilder::compute_record_size(
Record( Record(
RecordType( RecordType(
RecordType::well_known_type, RecordType::well_known_type,
uri_record_type_value uri_record_type_value
), ),
RecordPayload(_uri, _uri_size), RecordPayload(_uri, _uri_size),
RecordID(), RecordID(),
/* chunk */ false, /* chunk */ false,
/* last record */ false /* last record */ false
) )
); );
} }
void URI::move_data(uint8_t *new_uri, size_t new_uri_size) void URI::move_data(uint8_t *new_uri, size_t new_uri_size)