NDEFRecord_constructor.https.window.js

// META: script=resources/nfc-helpers.js

// NDEFRecord constructor

// https://w3c.github.io/web-nfc/#dom-ndefrecord

test(() => {

  assert_equals(NDEFRecord.length, 1);

  assert_throws_js(TypeError, () => new NDEFRecord());

}, 'NDEFRecord constructor without init dict');

test(() => {

  assert_throws_js(

      TypeError, () => new NDEFRecord(null),

      'NDEFRecordInit#recordType is a required field.');

}, 'NDEFRecord constructor with null init dict');

test(() => {

  assert_throws_js(

      TypeError,

      () => new NDEFRecord({id: test_record_id, data: test_text_data}),

      'NDEFRecordInit#recordType is a required field.');

}, 'NDEFRecord constructor without NDEFRecordInit#recordType field');

test(() => {

  assert_throws_js(

      TypeError,

      () =>

          new NDEFRecord(createRecord('empty', test_text_data, test_record_id)),

      'id does not apply for empty record type.');

}, 'NDEFRecord constructor with empty record type and id');

test(() => {

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(

          createRecord('empty', test_text_data, test_record_id, 'text/plain')),

      'mediaType does not apply for empty record type.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(

          createRecord('text', test_text_data, test_record_id, 'text/plain')),

      'mediaType does not apply for text record type.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(

          createRecord('url', test_url_data, test_record_id, 'text/plain')),

      'mediaType does not apply for url record type.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord(

          'absolute-url', test_url_data, test_record_id, 'text/plain')),

      'mediaType does not apply for absolute-url record type.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord(

          'unknown', test_buffer_data, test_record_id,

          'application/octet-stream')),

      'mediaType does not apply for unknown record type.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord(

          'foo.example.com:bar', test_buffer_data, test_record_id,

          'application/octet-stream')),

      'mediaType does not apply for external record type.');

}, 'NDEFRecord constructor should only accept mediaType for mime record type');

test(

    () => {

        const record = new NDEFRecord(createRecord('text', test_text_data));

        assert_equals(record.id, null, 'id');

      } {const record =

             new NDEFRecord(createRecord('text', test_text_data, ''));

         assert_equals(record.id, '', 'id');} {

        const dummy_id = 'https://dummy_host/mypath/myid';

        const record =

            new NDEFRecord(createRecord('text', test_text_data, dummy_id));

        assert_equals(record.id, dummy_id, 'id');

      } {const dummy_id = 'http://dummy_host/mypath/myid';

         const record =

             new NDEFRecord(createRecord('text', test_text_data, dummy_id));

         assert_equals(record.id, dummy_id, 'id');} {

        const dummy_id = 'mypath/myid';

        const record =

            new NDEFRecord(createRecord('text', test_text_data, dummy_id));

        assert_equals(record.id, dummy_id, 'id');

},

    'NDEFRecord constructor with custom record ids');

test(() => {

  const record = new NDEFRecord(createRecord('empty'));

  assert_equals(record.recordType, 'empty', 'recordType');

  assert_equals(record.mediaType, null, 'mediaType');

  assert_equals(record.id, null, 'id');

  assert_equals(record.encoding, null, 'encoding');

  assert_equals(record.lang, null, 'lang');

  assert_equals(record.data, null, 'data');

  assert_throws_dom(

      'NotSupportedError', () => record.toRecords(),

      'Only smart-poster, external type and local type records could have embedded records.');

}, 'NDEFRecord constructor with empty record type');

test(() => {

  const record = new NDEFRecord(createTextRecord(test_text_data));

  assert_equals(record.recordType, 'text', 'recordType');

  assert_equals(record.mediaType, null, 'mediaType');

  assert_equals(record.id, test_record_id, 'id');

  assert_equals(record.encoding, 'utf-8', 'encoding');

  assert_equals(record.lang, 'en', 'lang');

  const decoder = new TextDecoder();

  assert_equals(

      decoder.decode(record.data), test_text_data,

      'data has the same content with the original dictionary');

  assert_throws_dom(

      'NotSupportedError', () => record.toRecords(),

      'Only smart-poster, external type and local type records could have embedded records.');

}, 'NDEFRecord constructor with text record type and string data');

test(() => {

  const encoder = new TextEncoder();

  const uint8Array = encoder.encode(test_text_data);

  const record = new NDEFRecord(createTextRecord(uint8Array.buffer));

  assert_equals(record.recordType, 'text', 'recordType');

  assert_equals(record.mediaType, null, 'mediaType');

  assert_equals(record.id, test_record_id, 'id');

  // By default, 'utf-8'.

  assert_equals(record.encoding, 'utf-8', 'encoding');

  assert_equals(record.lang, 'en', 'lang');

  const decoder = new TextDecoder();

  assert_equals(

      decoder.decode(record.data), test_text_data,

      'data has the same content with the original dictionary');

  assert_throws_dom(

      'NotSupportedError', () => record.toRecords(),

      'Only smart-poster, external type and local type records could have embedded records.');

}, 'NDEFRecord constructor with text record type and arrayBuffer data');

test(() => {

  const encoder = new TextEncoder();

  const uint8Array = encoder.encode(test_text_data);

  const record = new NDEFRecord(createTextRecord(uint8Array));

  assert_equals(record.recordType, 'text', 'recordType');

  assert_equals(record.mediaType, null, 'mediaType');

  assert_equals(record.id, test_record_id, 'id');

  // By default, 'utf-8'.

  assert_equals(record.encoding, 'utf-8', 'encoding');

  assert_equals(record.lang, 'en', 'lang');

  const decoder = new TextDecoder();

  assert_equals(

      decoder.decode(record.data), test_text_data,

      'data has the same content with the original dictionary');

  assert_throws_dom(

      'NotSupportedError', () => record.toRecords(),

      'Only smart-poster, external type and local type records could have embedded records.');

}, 'NDEFRecord constructor with text record type and arrayBufferView data');

test(() => {

  assert_throws_js(

      TypeError,

      () =>

          new NDEFRecord(createTextRecord(test_text_data, 'random-encoding')));

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createTextRecord(test_text_data, 'utf-16')));

  // Only 'utf-8' is OK for a DOMString data source.

  const record =

      new NDEFRecord(createTextRecord(test_text_data, 'utf-8', 'fr'));

  assert_equals(record.recordType, 'text', 'recordType');

  assert_equals(record.encoding, 'utf-8', 'encoding');

  assert_equals(record.lang, 'fr', 'lang');

  const decoder = new TextDecoder();

  assert_equals(

      decoder.decode(record.data), test_text_data,

      'data has the same content with the original text');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createTextRecord(

          encodeTextToArrayBuffer(test_text_data, 'utf-8'),

          'random-encoding')));

  // The encoding list valid for a BufferSource data source.

  const encodings = ['utf-8', 'utf-16', 'utf-16be', 'utf-16le'];

  for (const encoding of encodings) {

    const record = new NDEFRecord(createTextRecord(

        encodeTextToArrayBuffer(test_text_data, encoding), encoding, 'fr'));

    assert_equals(record.recordType, 'text', 'recordType');

    assert_equals(record.encoding, encoding, 'encoding');

    assert_equals(record.lang, 'fr', 'lang');

    const decoder = new TextDecoder(record.encoding);

    assert_equals(

        decoder.decode(record.data), test_text_data,

        'data has the same content with the original text. encoding: ' +

            encoding);

}, 'NDEFRecord constructor with text record type, encoding, and lang');

test(t => {

  const previous_lang = document.querySelector('html').getAttribute('lang');

  const test_lang = 'fr';

  document.querySelector('html').setAttribute('lang', test_lang);

  t.add_cleanup(() => {

    document.querySelector('html').setAttribute('lang', previous_lang);

});

  const record = new NDEFRecord(createTextRecord(test_text_data));

  assert_equals(record.recordType, 'text', 'recordType');

  assert_equals(record.mediaType, null, 'mediaType');

  assert_equals(record.id, test_record_id, 'id');

  assert_equals(record.encoding, 'utf-8', 'encoding');

  assert_equals(record.lang, test_lang, 'lang');

  const decoder = new TextDecoder();

  assert_equals(

      decoder.decode(record.data), test_text_data,

      'data has the same content with the original dictionary');

}, 'NDEFRecord constructor with text record type and custom document language');

test(() => {

  const record = new NDEFRecord(createUrlRecord(test_url_data));

  assert_equals(record.recordType, 'url', 'recordType');

  assert_equals(record.mediaType, null, 'mediaType');

  assert_equals(record.id, test_record_id, 'id');

  const decoder = new TextDecoder();

  assert_equals(

      decoder.decode(record.data), test_url_data,

      'data has the same content with the original dictionary');

  assert_throws_dom(

      'NotSupportedError', () => record.toRecords(),

      'Only smart-poster, external type and local type records could have embedded records.');

}, 'NDEFRecord constructor with url record type');

test(() => {

  const record = new NDEFRecord(createUrlRecord(test_url_data, true));

  assert_equals(record.recordType, 'absolute-url', 'recordType');

  assert_equals(record.mediaType, null, 'mediaType');

  assert_equals(record.id, test_record_id, 'id');

  const decoder = new TextDecoder();

  assert_equals(

      decoder.decode(record.data), test_url_data,

      'data has the same content with the original dictionary');

  assert_throws_dom(

      'NotSupportedError', () => record.toRecords(),

      'Only smart-poster, external type and local type records could have embedded records.');

}, 'NDEFRecord constructor with absolute-url record type');

test(() => {

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createMimeRecord('A string is not a BufferSource')),

      'Only BufferSource is allowed to be the record data.');

  let buffer = new ArrayBuffer(4);

  new Uint8Array(buffer).set([1, 2, 3, 4]);

  // Feed ArrayBuffer.

    const record = new NDEFRecord(createMimeRecord(buffer));

    assert_equals(record.recordType, 'mime', 'recordType');

    assert_equals(record.mediaType, 'application/octet-stream', 'mediaType');

    assert_equals(record.id, test_record_id, 'id');

    assert_array_equals(

        new Uint8Array(record.data.buffer), [1, 2, 3, 4],

        'data has the same content with the original buffer');

    assert_throws_dom(

        'NotSupportedError', () => record.toRecords(),

        'Only smart-poster, external type and local type records could have embedded records.');

  // Feed ArrayBufferView.

    let buffer_view = new Uint8Array(buffer, 1);

    const record = new NDEFRecord(createMimeRecord(buffer_view));

    assert_equals(record.recordType, 'mime', 'recordType');

    assert_equals(record.id, test_record_id, 'id');

    assert_array_equals(

        new Uint8Array(record.data.buffer), [2, 3, 4],

        'data has the same content with the original buffer view');

    assert_throws_dom(

        'NotSupportedError', () => record.toRecords(),

        'Only smart-poster, external type and local type records could have embedded records.');

}, 'NDEFRecord constructor with mime record type and stream data');

test(() => {

  const record = new NDEFRecord(createMimeRecordFromJson(test_json_data));

  assert_equals(record.recordType, 'mime', 'recordType');

  assert_equals(record.mediaType, 'application/json', 'mediaType');

  assert_equals(record.id, test_record_id, 'id');

  assert_object_equals(

      JSON.parse(new TextDecoder().decode(record.data)), test_json_data,

      'data has the same content with the original json');

  assert_throws_dom(

      'NotSupportedError', () => record.toRecords(),

      'Only smart-poster, external type and local type records could have embedded records.');

}, 'NDEFRecord constructor with mime record type and json data');

test(() => {

  assert_throws_js(

      TypeError,

      () =>

          new NDEFRecord(createUnknownRecord('A string is not a BufferSource')),

      'Only BufferSource is allowed to be the record data.');

  let buffer = new ArrayBuffer(4);

  new Uint8Array(buffer).set([1, 2, 3, 4]);

  // Feed ArrayBuffer.

    const record = new NDEFRecord(createUnknownRecord(buffer));

    assert_equals(record.recordType, 'unknown', 'recordType');

    assert_equals(record.id, test_record_id, 'id');

    assert_array_equals(

        new Uint8Array(record.data.buffer), [1, 2, 3, 4],

        'data has the same content with the original buffer');

    assert_throws_dom(

        'NotSupportedError', () => record.toRecords(),

        'Only smart-poster, external type and local type records could have embedded records.');

  // Feed ArrayBufferView.

    let buffer_view = new Uint8Array(buffer, 1);

    const record = new NDEFRecord(createUnknownRecord(buffer_view));

    assert_equals(record.recordType, 'unknown', 'recordType');

    assert_equals(record.id, test_record_id, 'id');

    assert_array_equals(

        new Uint8Array(record.data.buffer), [2, 3, 4],

        'data has the same content with the original buffer view');

    assert_throws_dom(

        'NotSupportedError', () => record.toRecords(),

        'Only smart-poster, external type and local type records could have embedded records.');

}, 'NDEFRecord constructor with unknown record type');

test(() => {

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord(

          'foo.eXamPle.com:bAr*-',

          'A string is not a BufferSource or NDEFMessageInit')),

      'Only BufferSource and NDEFMessageInit are allowed to be the record data.');

  let buffer = new ArrayBuffer(4);

  new Uint8Array(buffer).set([1, 2, 3, 4]);

  // Feed ArrayBuffer.

    const record = new NDEFRecord(

        createRecord('foo.eXamPle.com:bAr*-', buffer, test_record_id));

    assert_equals(record.recordType, 'foo.eXamPle.com:bAr*-', 'recordType');

    assert_equals(record.mediaType, null, 'mediaType');

    assert_equals(record.id, test_record_id, 'id');

    assert_array_equals(

        new Uint8Array(record.data.buffer), [1, 2, 3, 4],

        'data has the same content with the original buffer');

    assert_equals(

        record.toRecords(), null,

        'toRecords() returns null if the payload is not an NDEF message.');

  // Feed ArrayBufferView.

    let buffer_view = new Uint8Array(buffer, 1);

    const record = new NDEFRecord(

        createRecord('foo.eXamPle.com:bAr*-', buffer_view, test_record_id));

    assert_equals(record.recordType, 'foo.eXamPle.com:bAr*-', 'recordType');

    assert_equals(record.mediaType, null, 'mediaType');

    assert_equals(record.id, test_record_id, 'id');

    assert_array_equals(

        new Uint8Array(record.data.buffer), [2, 3, 4],

        'data has the same content with the original buffer view');

    assert_equals(

        record.toRecords(), null,

        'toRecords() returns null if the payload is not an NDEF message.');

  // Feed NDEFMessageInit.

    const payload_message = createMessage([createTextRecord(test_text_data)]);

    const record = new NDEFRecord(createRecord(

        'foo.eXamPle.com:bAr*-', payload_message, 'dummy_record_id'));

    assert_equals(record.recordType, 'foo.eXamPle.com:bAr*-', 'recordType');

    assert_equals(record.mediaType, null, 'mediaType');

    assert_equals(record.id, 'dummy_record_id', 'id');

    const embedded_records = record.toRecords();

    assert_equals(embedded_records.length, 1, 'Only one embedded record.');

    // The only one embedded record has correct content.

    assert_equals(embedded_records[0].recordType, 'text', 'recordType');

    assert_equals(embedded_records[0].mediaType, null, 'mediaType');

    assert_equals(embedded_records[0].id, test_record_id, 'id');

    const decoder = new TextDecoder();

    assert_equals(

        decoder.decode(embedded_records[0].data), test_text_data,

        'data has the same content with the original dictionary');

}, 'NDEFRecord constructor with external record type');

test(() => {

  assert_throws_js(

      TypeError, () => new NDEFRecord(createRecord(':xyz', test_buffer_data)),

      'The local type record must be embedded in the payload of another record (smart-poster, external, or local)');

  // The following test cases use an external type record embedding our target

  // local type record.

  const local_record =

      createRecord(':xyz', undefined /* data */, 'dummy_id_for_local_type');

  const payload_message = createMessage([local_record]);

  const external_record_embedding_local_record =

      createRecord('example.com:foo', payload_message);

  assert_throws_js(

      TypeError, () => new NDEFRecord(external_record_embedding_local_record),

      'Only BufferSource and NDEFMessageInit are allowed to be the record data.');

  let buffer = new ArrayBuffer(4);

  new Uint8Array(buffer).set([1, 2, 3, 4]);

  // Feed ArrayBuffer.

    const record = new NDEFRecord(external_record_embedding_local_record);

    const embedded_records = record.toRecords();

    assert_equals(

        embedded_records.length, 1, 'Only the one embedded local record.');

    // The embedded local record is actually from |local_record|.

    assert_equals(embedded_records[0].recordType, ':xyz', 'recordType');

    assert_equals(embedded_records[0].mediaType, null, 'mediaType');

    assert_equals(embedded_records[0].id, 'dummy_id_for_local_type', 'id');

    assert_array_equals(

        new Uint8Array(embedded_records[0].data.buffer), [1, 2, 3, 4],

        'data has the same content with the original buffer');

    assert_equals(

        embedded_records[0].toRecords(), null,

        'toRecords() returns null if the payload is not an NDEF message.');

  // Feed ArrayBufferView.

    let buffer_view = new Uint8Array(buffer, 1);

    const record = new NDEFRecord(external_record_embedding_local_record);

    const embedded_records = record.toRecords();

    assert_equals(

        embedded_records.length, 1, 'Only the one embedded local record.');

    // The embedded local record is actually from |local_record|.

    assert_equals(embedded_records[0].recordType, ':xyz', 'recordType');

    assert_equals(embedded_records[0].mediaType, null, 'mediaType');

    assert_equals(embedded_records[0].id, 'dummy_id_for_local_type', 'id');

    assert_array_equals(

        new Uint8Array(embedded_records[0].data.buffer), [2, 3, 4],

        'data has the same content with the original buffer view');

    assert_equals(

        embedded_records[0].toRecords(), null,

        'toRecords() returns null if the payload is not an NDEF message.');

  // Feed NDEFMessageInit.

    const payload_message = createMessage([createTextRecord(test_text_data)]);

    const record = new NDEFRecord(external_record_embedding_local_record);

    const embedded_records = record.toRecords();

    assert_equals(

        embedded_records.length, 1, 'Only the one embedded local record.');

    // The embedded local record is actually from |local_record|.

    assert_equals(embedded_records[0].recordType, ':xyz', 'recordType');

    assert_equals(embedded_records[0].mediaType, null, 'mediaType');

    assert_equals(embedded_records[0].id, 'dummy_id_for_local_type', 'id');

    // The embedded local record embeds another text record that's from

    // |payload_message|.

    const embedded_records_in_local_record = embedded_records[0].toRecords();

    assert_equals(

        embedded_records_in_local_record.length, 1,

        'Only one embedded record.');

    // The only one embedded record has correct content.

    assert_equals(

        embedded_records_in_local_record[0].recordType, 'text', 'recordType');

    assert_equals(

        embedded_records_in_local_record[0].mediaType, null, 'mediaType');

    assert_equals(embedded_records_in_local_record[0].id, test_record_id, 'id');

    const decoder = new TextDecoder();

    assert_equals(

        decoder.decode(embedded_records_in_local_record[0].data),

        test_text_data,

        'data has the same content with the original dictionary');

}, 'NDEFRecord constructor with local record type');

test(() => {

  let buffer = new ArrayBuffer(4);

  new Uint8Array(buffer).set([1, 2, 3, 4]);

  const encoder = new TextEncoder();

  const uri_record = createUrlRecord(test_url_data);

  const title_record = createTextRecord(test_text_data, 'utf-8', 'en');

  const type_record = createRecord(':t', encoder.encode('image/gif'));

  const size_record = createRecord(':s', new Uint32Array([4096]));

  const action_record = createRecord(':act', new Uint8Array([3]));

  const icon_record = createRecord('mime', buffer, test_record_id, 'image/gif');

  const payload_message = createMessage([

    uri_record, title_record, type_record, size_record, action_record,

    icon_record

]);

  const smart_poster_record =

      createRecord('smart-poster', payload_message, 'dummy_record_id');

  const record = new NDEFRecord(smart_poster_record);

  assert_equals(record.recordType, 'smart-poster', 'recordType');

  assert_equals(record.mediaType, null, 'mediaType');

  assert_equals(record.id, 'dummy_record_id', 'id');

  const embedded_records = record.toRecords();

  assert_equals(embedded_records.length, 6, 'length');

  const decoder = new TextDecoder();

  let embedded_record_types = [];

  for (let record of embedded_records) {

    embedded_record_types.push(record.recordType);

    switch (record.recordType) {

      case 'url':

        assert_equals(record.mediaType, null, 'uri record\'s mediaType');

        assert_equals(record.id, test_record_id, 'uri record\'s id');

        assert_equals(

            decoder.decode(record.data), test_url_data, 'uri record\'s data');

        break;

      case 'text':

        assert_equals(record.mediaType, null, 'title record\'s mediaType');

        assert_equals(record.id, test_record_id, 'title record\'s id');

        assert_equals(record.encoding, 'utf-8', 'title record\'s encoding');

        assert_equals(record.lang, 'en', 'title record\'s lang');

        assert_equals(

            decoder.decode(record.data), test_text_data,

            'title record\'s data');

        break;

      case ':t':

        assert_equals(record.mediaType, null, 'type record\'s mediaType');

        assert_equals(record.id, null, 'type record\'s id');

        assert_equals(

            decoder.decode(record.data), 'image/gif', 'type record\'s data');

        break;

      case ':s':

        assert_equals(record.mediaType, null, 'size record\'s mediaType');

        assert_equals(record.id, null, 'size record\'s id');

        assert_equals(

            record.data.byteLength, 4, 'byteLength of size record\'s data');

        assert_equals(

            new Uint32Array(record.data.buffer)[0], 4096,

            'value of size record\'s data');

        break;

      case ':act':

        assert_equals(record.mediaType, null, 'action record\'s mediaType');

        assert_equals(record.id, null, 'action record\'s id');

        assert_equals(

            record.data.byteLength, 1, 'byteLength of action record\'s data');

        assert_equals(

            new Uint8Array(record.data.buffer)[0], 3,

            'value of action record\'s data');

        break;

      case 'mime':

        assert_equals(

            record.mediaType, 'image/gif', 'icon record\'s mediaType');

        assert_equals(record.id, test_record_id, 'icon record\'s id');

        assert_array_equals(

            new Uint8Array(record.data.buffer), [1, 2, 3, 4],

            'icon record\'s mediaType');

        break;

      default:

        assert_unreached('Unknown recordType');

  assert_array_equals(

      embedded_record_types.sort(), [':act', ':s', ':t', 'mime', 'text', 'url'],

      'smart-poster record\'s contained record types');

}, 'NDEFRecord constructor with smart-poster record type');

test(() => {

  const uri_record = createUrlRecord(test_url_data);

  const smart_poster_record = createRecord(

      'smart-poster', createMessage([uri_record]), 'dummy_record_id');

  const record = new NDEFRecord(smart_poster_record);

  assert_equals(record.recordType, 'smart-poster', 'recordType');

  assert_equals(record.mediaType, null, 'mediaType');

  assert_equals(record.id, 'dummy_record_id', 'id');

  const embedded_records = record.toRecords();

  // smart-poster record only contains a uri record.

  assert_equals(embedded_records.length, 1, 'length');

  const decoder = new TextDecoder();

  assert_equals(

      embedded_records[0].recordType, 'url', 'uri record\'s recordType');

  assert_equals(embedded_records[0].mediaType, null, 'uri record\'s mediaType');

  assert_equals(embedded_records[0].id, test_record_id, 'uri record\'s id');

  assert_equals(

      decoder.decode(embedded_records[0].data), test_url_data,

      'uri record\'s data');

}, 'NDEFRecord constructor with smart-poster record type that contains only a mandatory uri record');

test(() => {

  assert_throws_js(

      TypeError, () => new NDEFRecord(createRecord('EMptY')),

      'Unknown record type.');

  assert_throws_js(

      TypeError, () => new NDEFRecord(createRecord('TeXt', test_text_data)),

      'Unknown record type.');

  assert_throws_js(

      TypeError, () => new NDEFRecord(createRecord('uRL', test_url_data)),

      'Unknown record type.');

  assert_throws_js(

      TypeError, () => new NDEFRecord(createRecord('Mime', test_buffer_data)),

      'Unknown record type.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord('sMart-PosTER', test_url_data)),

      'Unknown record type.');

}, 'NDEFRecord constructor with record type string being treated as case sensitive');

test(() => {

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord('example.com:hellö', test_buffer_data)),

      'The external type must be an ASCII string.');

  // Length of the external type is 255, OK.

  const record = new NDEFRecord(createRecord(

      [...Array(251)].map(_ => 'a').join('') + ':xyz', test_buffer_data));

  // Exceeding 255, Throws.

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord(

          [...Array(252)].map(_ => 'a').join('') + ':xyz', test_buffer_data)),

      'The external type should not be longer than 255.');

  assert_throws_js(

      TypeError, () => new NDEFRecord(createRecord('xyz', test_buffer_data)),

      'The external type must have a \':\'.');

  assert_throws_js(

      TypeError, () => new NDEFRecord(createRecord(':xyz', test_buffer_data)),

      'The domain should not be empty.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord('example.com:', test_buffer_data)),

      'The type should not be empty.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord('example.com:xyz[', test_buffer_data)),

      'The type should not contain \'[\'.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord('example.com:xyz~', test_buffer_data)),

      'The type should not contain \'~\'.');

  assert_throws_js(

      TypeError,

      () => new NDEFRecord(createRecord('example.com:xyz/', test_buffer_data)),

      'The type should not contain \'/\'.');

}, 'NDEFRecord constructor with invalid external record type');

test(() => {

  const encoder = new TextEncoder();

  const uri_record = createUrlRecord(test_url_data);

  const title_record = createTextRecord(test_text_data, 'utf-8', 'en');

  const type_record = createRecord(':t', encoder.encode('image/gif'));

  const size_record = createRecord(':s', new Uint32Array([4096]));

  const action_record = createRecord(':act', new Uint8Array([0]));

  const icon_record =

      createRecord('mime', test_buffer_data, test_record_id, 'image/gif');

  const invalid_data_list = [

      data: 'A string is not a NDEFMessageInit',

      message: 'A string is not allowed.'

},

    {data: test_buffer_data, message: 'An ArrayBuffer is not allowed.'}, {

      data: createMessage(

          [title_record, type_record, size_record, action_record, icon_record]),

      message: 'Must contain a URI record.'

},

      data: createMessage([

        uri_record, title_record, type_record, size_record, action_record,

        icon_record, uri_record

]),

      message: 'Must not contain more than one uri record.'

},

      data: createMessage([

        uri_record, title_record, type_record, size_record, action_record,

        icon_record, type_record

]),

      message: 'Must not contain more than one type record.'

},

      data: createMessage([

        uri_record, title_record, type_record, size_record, action_record,

        icon_record, size_record

]),

      message: 'Must not contain more than one size record.'

},

      data: createMessage([

        uri_record, title_record, type_record, size_record, action_record,

        icon_record, action_record

]),

      message: 'Must not contain more than one action record.'

},

      data: createMessage([

        uri_record, title_record, type_record, action_record, icon_record,

        createRecord(':s', new Uint8Array([1]))

]),

      message:

          'Size record must have payload as 4-byte 32 bit unsigned integer.'

},

      data: createMessage([

        uri_record, title_record, type_record, size_record, icon_record,

        createRecord(':act', new Uint32Array([0]))

]),

      message:

          'Action record must have payload as 1-byte 8 bit unsigned integer.'

];

  invalid_data_list.forEach(entry => {

    assert_throws_js(

        TypeError,

        () => new NDEFRecord(createRecord('smart-poster', entry.data)),

        entry.message);

});

}, 'NDEFRecord constructor for smart-poster record with invalid embedded records.');

test(() => {

  assert_throws_js(

      TypeError, () => new NDEFRecord(createRecord(':xyz', test_buffer_data)),

      'The local type record must be embedded in the payload of another record (smart-poster, external, or local)');

  // The following test cases use an external type record embedding our target

  // local type record.

  const local_record = createRecord(':xyz', test_buffer_data);

  const payload_message = createMessage([local_record]);

  const external_record_embedding_local_record =

      createRecord('example.com:foo', payload_message);

  // OK.

  new NDEFRecord(external_record_embedding_local_record);

  new NDEFRecord(external_record_embedding_local_record);

  new NDEFRecord(external_record_embedding_local_record);

  assert_throws_js(

      TypeError, () => new NDEFRecord(external_record_embedding_local_record),

      'The local type must be an ASCII string.');

  // Length of the local type excluding the prefix ':' is 255, OK.

  const record_255 = new NDEFRecord(external_record_embedding_local_record);

  // Exceeding 255, Throws.

  assert_throws_js(

      TypeError, () => new NDEFRecord(external_record_embedding_local_record),

      'The local type excluding the prefix \':\' should not be longer than 255.');

  assert_throws_js(

      TypeError, () => new NDEFRecord(external_record_embedding_local_record),

      'The local type must start with a \':\'.');

  assert_throws_js(

      TypeError, () => new NDEFRecord(external_record_embedding_local_record),

      'The local type must have a lower case letter or digit following the prefix \':\'.');

  assert_throws_js(

      TypeError, () => new NDEFRecord(external_record_embedding_local_record),

      'The local type must have a lower case letter or digit following the prefix \':\'.');

}, 'NDEFRecord constructor with various local record types');

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: