@@ -475,15 +475,85 @@ promise_test(async () => {
475475  const  rs  =  new  ReadableStream ( ) ; 
476476  const  it  =  rs . values ( ) ; 
477477
478-   const  iterResults  =  await  Promise . allSettled ( [ it . return ( 'return value' ) ,  it . next ( ) ] ) ; 
478+   const  resolveOrder  =  [ ] ; 
479+   const  iterResults  =  await  Promise . allSettled ( [ 
480+     it . return ( 'return value' ) . then ( result  =>  { 
481+       resolveOrder . push ( 'return' ) ; 
482+       return  result ; 
483+     } ) , 
484+     it . next ( ) . then ( result  =>  { 
485+       resolveOrder . push ( 'next' ) ; 
486+       return  result ; 
487+     } ) 
488+   ] ) ; 
479489
480490  assert_equals ( iterResults [ 0 ] . status ,  'fulfilled' ,  'return() promise status' ) ; 
481491  assert_iter_result ( iterResults [ 0 ] . value ,  'return value' ,  true ,  'return()' ) ; 
482492
483493  assert_equals ( iterResults [ 1 ] . status ,  'fulfilled' ,  'next() promise status' ) ; 
484494  assert_iter_result ( iterResults [ 1 ] . value ,  undefined ,  true ,  'next()' ) ; 
495+ 
496+   assert_array_equals ( resolveOrder ,  [ 'return' ,  'next' ] ,  'next() resolves after return()' ) ; 
485497} ,  'return(); next() [no awaiting]' ) ; 
486498
499+ promise_test ( async  ( )  =>  { 
500+   let  resolveCancelPromise ; 
501+   const  rs  =  recordingReadableStream ( { 
502+     cancel ( reason )  { 
503+       return  new  Promise ( r  =>  resolveCancelPromise  =  r ) ; 
504+     } 
505+   } ) ; 
506+   const  it  =  rs . values ( ) ; 
507+ 
508+   let  returnResolved  =  false ; 
509+   const  returnPromise  =  it . return ( 'return value' ) . then ( result  =>  { 
510+     returnResolved  =  true ; 
511+     return  result ; 
512+   } ) ; 
513+   await  flushAsyncEvents ( ) ; 
514+   assert_false ( returnResolved ,  'return() should not resolve while cancel() promise is pending' ) ; 
515+ 
516+   resolveCancelPromise ( ) ; 
517+   const  iterResult1  =  await  returnPromise ; 
518+   assert_iter_result ( iterResult1 ,  'return value' ,  true ,  'return()' ) ; 
519+ 
520+   const  iterResult2  =  await  it . next ( ) ; 
521+   assert_iter_result ( iterResult2 ,  undefined ,  true ,  'next()' ) ; 
522+ } ,  'return(); next() with delayed cancel()' ) ; 
523+ 
524+ promise_test ( async  ( )  =>  { 
525+   let  resolveCancelPromise ; 
526+   const  rs  =  recordingReadableStream ( { 
527+     cancel ( reason )  { 
528+       return  new  Promise ( r  =>  resolveCancelPromise  =  r ) ; 
529+     } 
530+   } ) ; 
531+   const  it  =  rs . values ( ) ; 
532+ 
533+   const  resolveOrder  =  [ ] ; 
534+   const  returnPromise  =  it . return ( 'return value' ) . then ( result  =>  { 
535+     resolveOrder . push ( 'return' ) ; 
536+     return  result ; 
537+   } ) ; 
538+   const  nextPromise  =  it . next ( ) . then ( result  =>  { 
539+     resolveOrder . push ( 'next' ) ; 
540+     return  result ; 
541+   } ) ; 
542+ 
543+   assert_array_equals ( rs . events ,  [ 'cancel' ,  'return value' ] ,  'return() should call cancel()' ) ; 
544+   assert_array_equals ( resolveOrder ,  [ ] ,  'return() should not resolve before cancel() resolves' ) ; 
545+ 
546+   resolveCancelPromise ( ) ; 
547+   const  iterResult1  =  await  returnPromise ; 
548+   assert_iter_result ( iterResult1 ,  'return value' ,  true ,  'return() should resolve with original reason' ) ; 
549+   const  iterResult2  =  await  nextPromise ; 
550+   assert_iter_result ( iterResult2 ,  undefined ,  true ,  'next() should resolve with done result' ) ; 
551+ 
552+   assert_array_equals ( rs . events ,  [ 'cancel' ,  'return value' ] ,  'no pull() after cancel()' ) ; 
553+   assert_array_equals ( resolveOrder ,  [ 'return' ,  'next' ] ,  'next() should resolve after return() resolves' ) ; 
554+ 
555+ } ,  'return(); next() with delayed cancel() [no awaiting]' ) ; 
556+ 
487557promise_test ( async  ( )  =>  { 
488558  const  rs  =  new  ReadableStream ( ) ; 
489559  const  it  =  rs . values ( ) ; 
@@ -499,13 +569,25 @@ promise_test(async () => {
499569  const  rs  =  new  ReadableStream ( ) ; 
500570  const  it  =  rs . values ( ) ; 
501571
502-   const  iterResults  =  await  Promise . allSettled ( [ it . return ( 'return value 1' ) ,  it . return ( 'return value 2' ) ] ) ; 
572+   const  resolveOrder  =  [ ] ; 
573+   const  iterResults  =  await  Promise . allSettled ( [ 
574+     it . return ( 'return value 1' ) . then ( result  =>  { 
575+       resolveOrder . push ( 'return 1' ) ; 
576+       return  result ; 
577+     } ) , 
578+     it . return ( 'return value 2' ) . then ( result  =>  { 
579+       resolveOrder . push ( 'return 2' ) ; 
580+       return  result ; 
581+     } ) 
582+   ] ) ; 
503583
504584  assert_equals ( iterResults [ 0 ] . status ,  'fulfilled' ,  '1st return() promise status' ) ; 
505585  assert_iter_result ( iterResults [ 0 ] . value ,  'return value 1' ,  true ,  '1st return()' ) ; 
506586
507587  assert_equals ( iterResults [ 1 ] . status ,  'fulfilled' ,  '2nd return() promise status' ) ; 
508588  assert_iter_result ( iterResults [ 1 ] . value ,  'return value 2' ,  true ,  '1st return()' ) ; 
589+ 
590+   assert_array_equals ( resolveOrder ,  [ 'return 1' ,  'return 2' ] ,  '2nd return() resolves after 1st return()' ) ; 
509591} ,  'return(); return() [no awaiting]' ) ; 
510592
511593test ( ( )  =>  { 
0 commit comments