Branch data     Line data    Source code

       1            [ + ]:          1 : import assert from 'node:assert/strict';
       2                 :          1 : import { FormData } from '../../../../lib/whatwg-xhr.js';
       3                 :          1 : 
       4            [ + ]:          1 : export default (activeURL) => {
       5                 :          1 : 
       6                 :          1 :     const fd = new FormData();
       7                 :          1 : 
       8                 :          1 :         fd.append('n1', 'v1');
       9                 :          1 :         fd.append('n2', 'v2');
      10                 :          1 :         fd.append('n3', 'v3');
      11                 :          1 :         fd.append('n1', 'v4');
      12                 :          1 :         fd.append('n2', 'v5');
      13                 :          1 :         fd.append('n3', 'v6');
      14                 :          1 :         fd.delete('n2');
      15                 :          1 : 
      16                 :          1 :         const file = new File(['hello'], "hello.txt");
      17                 :          1 :         fd.append('f1', file);
      18                 :          1 : 
      19                 :          1 :         let expected_keys = ['n1', 'n3', 'n1', 'n3', 'f1'];
      20                 :          1 :         let expected_values = ['v1', 'v3', 'v4', 'v6', file];
      21                 :          1 : 
      22            [ + ]:          1 :         (() => {
      23                 :          1 :                 var mykeys = [], myvalues = [];
      24            [ + ]:          1 :                 for(var entry of fd) {
      25                 :          5 :                         assert.strictEqual(entry.length, 2,
      26                 :          5 :                                                   'Default iterator should yield key/value pairs');
      27                 :          5 :                         mykeys.push(entry[0]);
      28                 :          5 :                         myvalues.push(entry[1]);
      29                 :          5 :                 }
      30                 :          1 :                 assert.deepStrictEqual(mykeys, expected_keys,
      31                 :          1 :                                                         'Default iterator should see duplicate keys');
      32                 :          1 :                 assert.deepStrictEqual(myvalues, expected_values,
      33                 :          1 :                                                         'Default iterator should see non-deleted values');
      34                 :          1 :         })('Iterator should return duplicate keys and non-deleted values');
      35                 :          1 : 
      36            [ + ]:          1 :         (() => {
      37                 :          1 :                 var mykeys = [], myvalues = [];
      38            [ + ]:          1 :                 for(var entry of fd.entries()) {
      39                 :          5 :                         assert.strictEqual(entry.length, 2,
      40                 :          5 :                                                   'entries() iterator should yield key/value pairs');
      41                 :          5 :                         mykeys.push(entry[0]);
      42                 :          5 :                         myvalues.push(entry[1]);
      43                 :          5 :                 }
      44                 :          1 :                 assert.deepStrictEqual(mykeys, expected_keys,
      45                 :          1 :                                                         'entries() iterator should see duplicate keys');
      46                 :          1 :                 assert.deepStrictEqual(myvalues, expected_values,
      47                 :          1 :                                                         'entries() iterator should see non-deleted values');
      48                 :          1 :         })('Entries iterator should return duplicate keys and non-deleted values');
      49                 :          1 : 
      50            [ + ]:          1 :         (() => {
      51                 :          1 :                 var mykeys = [];
      52                 :          1 :                 for(var entry of fd.keys())
      53            [ + ]:          1 :                         mykeys.push(entry);
      54                 :          1 :                 assert.deepStrictEqual(mykeys, expected_keys,
      55                 :          1 :                                                         'keys() iterator should see duplicate keys');
      56                 :          1 :         })('Keys iterator should return duplicates');
      57                 :          1 : 
      58            [ + ]:          1 :         (() => {
      59                 :          1 :                 var myvalues = [];
      60                 :          1 :                 for(var entry of fd.values())
      61            [ + ]:          1 :                         myvalues.push(entry);
      62                 :          1 :                 assert.deepStrictEqual(myvalues, expected_values,
      63                 :          1 :                                                         'values() iterator should see non-deleted values');
      64                 :          1 :         })('Values iterator should return non-deleted values');
      65                 :          1 : }
      66                 :          1 : 
      67                 :          1 : /*
      68                 :          1 :  * foreach.any.js
      69                 :          1 :  *
      70                 :          1 : 
      71                 :          1 : // META: title=FormData: foreach
      72                 :          1 : 
      73                 :          1 :     var fd = new FormData();
      74                 :          1 :     fd.append('n1', 'v1');
      75                 :          1 :     fd.append('n2', 'v2');
      76                 :          1 :     fd.append('n3', 'v3');
      77                 :          1 :     fd.append('n1', 'v4');
      78                 :          1 :     fd.append('n2', 'v5');
      79                 :          1 :     fd.append('n3', 'v6');
      80                 :          1 :     fd.delete('n2');
      81                 :          1 : 
      82                 :          1 :     var file = new File(['hello'], "hello.txt");
      83                 :          1 :     fd.append('f1', file);
      84                 :          1 : 
      85                 :          1 :     var expected_keys = ['n1', 'n3', 'n1', 'n3', 'f1'];
      86                 :          1 :     var expected_values = ['v1', 'v3', 'v4', 'v6', file];
      87                 :          1 :     test(function() {
      88                 :          1 :         var mykeys = [], myvalues = [];
      89                 :          1 :         for(var entry of fd) {
      90                 :          1 :             assert_equals(entry.length, 2,
      91                 :          1 :                           'Default iterator should yield key/value pairs');
      92                 :          1 :             mykeys.push(entry[0]);
      93                 :          1 :             myvalues.push(entry[1]);
      94                 :          1 :         }
      95                 :          1 :         assert_array_equals(mykeys, expected_keys,
      96                 :          1 :                             'Default iterator should see duplicate keys');
      97                 :          1 :         assert_array_equals(myvalues, expected_values,
      98                 :          1 :                             'Default iterator should see non-deleted values');
      99                 :          1 :     }, 'Iterator should return duplicate keys and non-deleted values');
     100                 :          1 :     test(function() {
     101                 :          1 :         var mykeys = [], myvalues = [];
     102                 :          1 :         for(var entry of fd.entries()) {
     103                 :          1 :             assert_equals(entry.length, 2,
     104                 :          1 :                           'entries() iterator should yield key/value pairs');
     105                 :          1 :             mykeys.push(entry[0]);
     106                 :          1 :             myvalues.push(entry[1]);
     107                 :          1 :         }
     108                 :          1 :         assert_array_equals(mykeys, expected_keys,
     109                 :          1 :                             'entries() iterator should see duplicate keys');
     110                 :          1 :         assert_array_equals(myvalues, expected_values,
     111                 :          1 :                             'entries() iterator should see non-deleted values');
     112                 :          1 :     }, 'Entries iterator should return duplicate keys and non-deleted values');
     113                 :          1 :     test(function() {
     114                 :          1 :         var mykeys = [];
     115                 :          1 :         for(var entry of fd.keys())
     116                 :          1 :             mykeys.push(entry);
     117                 :          1 :         assert_array_equals(mykeys, expected_keys,
     118                 :          1 :                             'keys() iterator should see duplicate keys');
     119                 :          1 :     }, 'Keys iterator should return duplicates');
     120                 :          1 :     test(function() {
     121                 :          1 :         var myvalues = [];
     122                 :          1 :         for(var entry of fd.values())
     123                 :          1 :             myvalues.push(entry);
     124                 :          1 :         assert_array_equals(myvalues, expected_values,
     125                 :          1 :                             'values() iterator should see non-deleted values');
     126                 :          1 :     }, 'Values iterator should return non-deleted values');
     127                 :          1 : 
     128                 :          1 :  *
     129                 :          1 :  *
     130                 :          1 :  */