A partial list of things that need testing, written with @michaelficarra . Stopped when we ran out of time, not when we ran out of things that need testing.

`zip`

empty iterable as argument produces iterator which is finished
cases for the iterable returned by padding:
- it returns { done: true } in fewer steps than there are things to be zipped
  - in this case next should not be called any more times
  - and .return should not be looked at or called
- it does not return { done: true } within the number of steps as there are things to be zipped
  - in this case its .return should be called
result objects are arrays

`zipKeyed`

object with no own-enumerable keys as argument produces iterator which is finished
confirm inherited keys are not used
confirm non-enumerable keys are not used
make sure that output objects have correct attributes for the properties
- output properties are writable/configurable, even if they were not on the input
output objects inherit from null
order of properties reported by Object.keys() is the same as they were on the first argument
tests with Symbol-named properties

both

throws if the first argument is not an object (including if it is a string)
throws if the second argument is not an object and not null/undefined
mode is read from second argument
mode is not coerced to a string
padding is read if and only if mode is "longest"
when mode is "longest", throws if padding is not undefined and not an object (including if it is a string)
mode is not read if the first argument is not an object
throws if any iterables are strings (after reading the padding)
order of side effects in general (there are lots of these, just make something that makes every single side-effect observable and assert on the totality)
- should assert immediately after calling .zip, and also after calling .next on the result
can zip exactly one thing
can zip exactly two things with the same number of elements
can zip two iterable things of different length with no options object (which behaves like shortest)
- need tests for first thing is longer, and second thing is longer
as above but with each of the three modes explicitly
when mode is strict, and the lengths are the same, once the first iterator completes .next on the rest, to check done-ness
when mode is longest, correct padding is used
- including with explicit padding for everything, with padding for some but not all things, and when padding is undefined
as above but with three things
output objects are "fresh", i.e., different identity for first vs second thing returned
tests for closing the correct iterators in the various cases:
- all the error cases (not going to enumerate these but there's a lot)
  - when the error is caused by one of the iterables breaking the iterator contract, that iterator is not closed
- with "shortest" or "strict", after the shortest thing is exhausted
  - including when the shortest thing is in the middle of the list
- when .return is called explicitly
- including when mode is "longest" and some iterators have already finished (in which case they are not closed)
- tests should assert that .return is invoked with the correct receiver
resulting iterator has [[Prototype]] of %IteratorHelperPrototype% (i.e., Object.getPrototypeOf(Iterator.from([]).take(0)))

Create testing plan for the Joint Iteration proposal. #4112

Description

ioannadopenedon Jun 19, 2024

Activity

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

ioannad
openedon Jun 19, 2024