2229357644

Committed 26 Apr 2022 - 21:05 coverage increased (+0.01%) to 97.515%

Build Type

github

Committed by GitHub

Commit Message

Merge 8583e0e0b into 8f03e9e19

Pull Request Pull Request #820: Upgrade eslint-plugin-markdown to version 2.2.1

Run Details

1963 of 2081 branches covered (94.33%)

3571 of 3662 relevant lines covered (97.52%)

1962.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.83

/lib/assertions.js

const utils = require('./utils');
const arrayChanges = require('array-changes');
const arrayChangesAsync = require('array-changes-async');
const throwIfNonUnexpectedError = require('./throwIfNonUnexpectedError');
const objectIs = utils.objectIs;
const extend = utils.extend;

module.exports = (expect) => {
  expect.addAssertion('<any> [not] to be (ok|truthy)', (expect, subject) => {
    const not = !!expect.flags.not;
    const condition = !!subject;
    if (condition === not) {
      expect.fail();
    }
  });

  expect.addAssertion(
    '<any> [not] to be (ok|truthy) <string>',
    (expect, subject, message) => {
      const not = !!expect.flags.not;
      const condition = !!subject;
      if (condition === not) {
        expect.fail({
          errorMode: 'bubble',
          message,
        });
      }
    }
  );

  expect.addAssertion('<any> [not] to be <any>', (expect, subject, value) => {
    if (objectIs(subject, value) === expect.flags.not) {
      expect.fail({
        label: 'should be',
      });
    }
  });

  expect.addAssertion(
    '<string> [not] to be <string>',
    (expect, subject, value) => {
      expect(subject, '[not] to equal', value);
    }
  );

  expect.addAssertion('<boolean> [not] to be true', (expect, subject) => {
    expect(subject, '[not] to be', true);
  });

  expect.addAssertion('<boolean> [not] to be false', (expect, subject) => {
    expect(subject, '[not] to be', false);
  });

  expect.addAssertion('<any> [not] to be falsy', (expect, subject) => {
    expect(subject, '[!not] to be truthy');
  });

  expect.addAssertion(
    '<any> [not] to be falsy <string>',
    (expect, subject, message) => {
      const not = !!expect.flags.not;
      const condition = !!subject;
      if (condition !== not) {
        expect.fail({
          errorMode: 'bubble',
          message,
        });
      }
    }
  );

  expect.addAssertion('<any> [not] to be null', (expect, subject) => {
    expect(subject, '[not] to be', null);
  });

  expect.addAssertion('<any> [not] to be undefined', (expect, subject) => {
    expect(typeof subject === 'undefined', '[not] to be truthy');
  });

  expect.addAssertion('<any> [not] to be defined', (expect, subject) => {
    expect(subject, '[!not] to be undefined');
  });

  expect.addAssertion('<number|NaN> [not] to be NaN', (expect, subject) => {
    expect(isNaN(subject), '[not] to be truthy');
  });

  expect.addAssertion(
    '<number> [not] to be close to <number> <number?>',
    (expect, subject, value, epsilon) => {
      expect.errorMode = 'bubble';
      if (typeof epsilon !== 'number') {
        epsilon = 1e-9;
      }

      expect.withError(
        () => {
          expect(
            Math.abs(subject - value),
            '[not] to be less than or equal to',
            epsilon
          );
        },
        (e) => {
          expect.fail((output) => {
            output
              .error('expected ')
              .appendInspected(subject)
              .sp()
              .error(expect.testDescription)
              .sp()
              .appendInspected(value)
              .sp()
              .text('(epsilon: ')
              .jsNumber(epsilon.toExponential())
              .text(')');
          });
        }
      );
    }
  );

  expect.addAssertion(
    '<any> [not] to be (a|an) <type>',
    (expect, subject, type) => {
      expect.argsOutput[0] = (output) => {
        output.text(type.name);
      };
      expect(type.identify(subject), '[not] to be true');
    }
  );

  expect.addAssertion(
    '<any> [not] to be (a|an) <string>',
    (expect, subject, typeName) => {
      typeName = /^reg(?:exp?|ular expression)$/.test(typeName)
        ? 'regexp'
        : typeName;
      expect.argsOutput[0] = (output) => {
        output.jsString(typeName);
      };
      if (!expect.getType(typeName)) {
        expect.errorMode = 'nested';
        expect.fail((output) => {
          output.error('Unknown type:').sp().jsString(typeName);
        });
      }
      expect(expect.subjectType.is(typeName), '[not] to be truthy');
    }
  );

  expect.addAssertion(
    '<any> [not] to be (a|an) <function>',
    (expect, subject, Constructor) => {
      const className = utils.getFunctionName(Constructor);
      if (className) {
        expect.argsOutput[0] = (output) => {
          output.text(className);
        };
      }
      expect(subject instanceof Constructor, '[not] to be truthy');
    }
  );

  expect.addAssertion(
    '<any> [not] to be one of <array>',
    (expect, subject, superset) => {
      let found = false;

      for (let i = 0; i < superset.length; i += 1) {
        found = found || objectIs(subject, superset[i]);
      }

      if (found === expect.flags.not) {
        expect.fail();
      }
    }
  );

  // Alias for common '[not] to be (a|an)' assertions
  expect.addAssertion(
    '<any> [not] to be an (object|array)',
    (expect, subject) => {
      expect(subject, '[not] to be an', expect.alternations[0]);
    }
  );

  expect.addAssertion(
    '<any> [not] to be a (boolean|number|string|function|regexp|regex|regular expression|date)',
    (expect, subject) => {
      expect(subject, '[not] to be a', expect.alternations[0]);
    }
  );

  expect.addAssertion(
    '<string> to be (the empty|an empty|a non-empty) string',
    (expect, subject) => {
      expect(
        subject,
        expect.alternations[0] === 'a non-empty'
          ? 'not to be empty'
          : 'to be empty'
      );
    }
  );

  expect.addAssertion(
    '<array-like> to be (the empty|an empty|a non-empty) array',
    (expect, subject) => {
      expect(
        subject,
        expect.alternations[0] === 'a non-empty'
          ? 'not to be empty'
          : 'to be empty'
      );
    }
  );

  expect.addAssertion('<string> to match <regexp>', (expect, subject, regexp) =>
    expect.withError(
      () => {
        const captures = subject.match(regexp);
        expect(captures, 'to be truthy');
        return captures;
      },
      (e) => {
        e.label = 'should match';
        expect.fail(e);
      }
    )
  );

  expect.addAssertion(
    '<string> not to match <regexp>',
    (expect, subject, regexp) =>
      expect.withError(
        () => {
          expect(regexp.test(subject), 'to be false');
        },
        (e) => {
          expect.fail({
            label: 'should not match',
            diff(output) {
              output.inline = false;
              let lastIndex = 0;
              function flushUntilIndex(i) {
                if (i > lastIndex) {
                  output.text(subject.substring(lastIndex, i));
                  lastIndex = i;
                }
              }
              subject.replace(new RegExp(regexp.source, 'g'), ($0, index) => {
                flushUntilIndex(index);
                lastIndex += $0.length;
                output.removedHighlight($0);
              });
              flushUntilIndex(subject.length);
              return output;
            },
          });
        }
      )
  );

  expect.addAssertion(
    '<object> [not] to have own property <string|Symbol>',
    (expect, subject, key) => {
      expect(
        Object.prototype.hasOwnProperty.call(subject, key),
        '[not] to be truthy'
      );
      return subject[key];
    }
  );

  expect.addAssertion(
    '<object> to have (enumerable|unenumerable|configurable|unconfigurable|writable|unwritable|readonly) property <string|Symbol>',
    (expect, subject, key) => {
      let attribute = expect.alternations[0];
      let negated = false;
      if (attribute.indexOf('un') === 0) {
        attribute = attribute.substr(2);
        negated = true;
      } else if (attribute === 'readonly') {
        attribute = 'writable';
        negated = true;
      }
      const descriptor = Object.getOwnPropertyDescriptor(subject, key);
      expect(descriptor, 'to be defined');
      expect(descriptor[attribute] !== negated, 'to be true');
      return subject[key];
    }
  );

  expect.addAssertion(
    '<object> [not] to have property <string|Symbol>',
    (expect, subject, key) => {
      const subjectType = expect.findTypeOf(subject);
      const subjectKey = subjectType.is('function')
        ? subject[key]
        : subjectType.valueForKey(subject, key);
      expect(subjectKey, '[!not] to be undefined');
      return subjectKey;
    }
  );

  expect.addAssertion(
    '<object> to have [own] property <string|Symbol> <any>',
    (expect, subject, key, expectedPropertyValue) =>
      expect(subject, 'to have [own] property', key).then(
        (actualPropertyValue) => {
          expect.argsOutput = function () {
            this.appendInspected(key)
              .sp()
              .error('with a value of')
              .sp()
              .appendInspected(expectedPropertyValue);
          };
          expect(actualPropertyValue, 'to equal', expectedPropertyValue);
          return actualPropertyValue;
        }
      )
  );

  expect.addAssertion(
    '<object> [not] to [only] have [own] properties <array>',
    (expect, subject, propertyNames) => {
      const unsupportedPropertyNames = propertyNames.filter((propertyName) => {
        const type = typeof propertyName;
        return type !== 'string' && type !== 'number' && type !== 'symbol';
      });
      if (unsupportedPropertyNames.length > 0) {
        expect.errorMode = 'nested';
        expect.fail(function () {
          this.error(
            'All expected properties must be passed as strings, symbols, or numbers, but these are not:'
          ).indentLines();
          unsupportedPropertyNames.forEach(function (propertyName) {
            this.nl().i().appendInspected(propertyName);
          }, this);
          this.outdentLines();
        });
      }

      if (expect.flags.only) {
        if (expect.flags.not) {
          expect.errorMode = 'bubble';
          expect.fail(
            'The "not" flag cannot be used together with "to only have properties".'
          );
        }
        if (expect.flags.own) {
          expect.errorMode = 'bubble';
          expect.fail(
            'The "own" flag cannot be used together with "to only have properties".'
          );
        }
        const subjectType = expect.subjectType;
        const subjectKeys = subjectType.getKeys(subject).filter(
          (key) =>
            // include only those keys whose value is not undefined
            typeof subjectType.valueForKey(subject, key) !== 'undefined'
        );

        expect.withError(
          () => {
            expect(subjectKeys.length === propertyNames.length, 'to be true');
            // now catch differing property names
            const keyInValue = {};
            propertyNames.forEach((key) => {
              keyInValue[key] = true;
            });
            subjectKeys.forEach((key) =>
              expect(
                Object.prototype.hasOwnProperty.call(keyInValue, key),
                'to be true'
              )
            );
          },
          () => {
            expect.fail({
              diff: (output, diff, inspect, equal) => {
                output.inline = true;

                const keyInValue = {};
                propertyNames.forEach((key) => {
                  keyInValue[key] = true;
                });

                subjectType.prefix(output, subject);
                output.nl().indentLines();

                subjectKeys.forEach((key, index) => {
                  const propertyOutput = subjectType.property(
                    output.clone(),
                    key,
                    inspect(subjectType.valueForKey(subject, key))
                  );
                  const delimiterOutput = subjectType.delimiter(
                    output.clone(),
                    index,
                    subjectKeys.length
                  );

                  output
                    .i()
                    .block(function () {
                      this.append(propertyOutput).amend(delimiterOutput);
                      if (
                        !Object.prototype.hasOwnProperty.call(keyInValue, key)
                      ) {
                        this.sp().annotationBlock(function () {
                          this.error('should be removed');
                        });
                      } else {
                        delete keyInValue[key];
                      }
                    })
                    .nl();
                });

                // list any remaining value properties as missing
                Object.keys(keyInValue).forEach((valueKey) => {
                  output
                    .i()
                    .annotationBlock(function () {
                      this.error('missing').sp().append(inspect(valueKey));
                    })
                    .nl();
                });

                output.outdentLines();
                subjectType.suffix(output, subject);

                return output;
              },
            });
          }
        );
      } else {
        propertyNames.forEach((propertyName) => {
          expect(
            subject,
            '[not] to have [own] property',
            typeof propertyName === 'number'
              ? String(propertyName)
              : propertyName
          );
        });
      }
    }
  );

  expect.addAssertion(
    '<object> to have [own] properties <object>',
    (expect, subject, properties) => {
      expect.withError(
        () => {
          Object.keys(properties).forEach((property) => {
            const value = properties[property];
            if (typeof value === 'undefined') {
              expect(subject, 'not to have [own] property', property);
            } else {
              expect(subject, 'to have [own] property', property, value);
            }
          });
        },
        (e) => {
          expect.fail({
            diff(output, diff) {
              output.inline = false;
              const expected = extend({}, properties);
              const actual = {};
              const propertyNames = expect.findTypeOf(subject).getKeys(subject);
              // Might put duplicates into propertyNames, but that does not matter:
              for (const propertyName in subject) {
                if (
                  !Object.prototype.hasOwnProperty.call(subject, propertyName)
                ) {
                  propertyNames.push(propertyName);
                }
              }
              propertyNames.forEach((propertyName) => {
                if (
                  (!expect.flags.own ||
                    Object.prototype.hasOwnProperty.call(
                      subject,
                      propertyName
                    )) &&
                  !(propertyName in properties)
                ) {
                  expected[propertyName] = subject[propertyName];
                }
                if (
                  (!expect.flags.own ||
                    Object.prototype.hasOwnProperty.call(
                      subject,
                      propertyName
                    )) &&
                  !(propertyName in actual)
                ) {
                  actual[propertyName] = subject[propertyName];
                }
              });
              return utils.wrapConstructorNameAroundOutput(
                diff(actual, expected),
                subject
              );
            },
          });
        }
      );
    }
  );

  expect.addAssertion(
    '<string|array-like> [not] to have length <number>',
    (expect, subject, length) => {
      if (!expect.flags.not) {
        expect.errorMode = 'nested';
      }
      expect(subject.length, '[not] to be', length);
    }
  );

  expect.addAssertion(
    '<string|array-like> [not] to be empty',
    (expect, subject) => {
      expect(subject, '[not] to have length', 0);
    }
  );

  expect.addAssertion(
    '<string|array-like|object> to be non-empty',
    (expect, subject) => {
      expect(subject, 'not to be empty');
    }
  );

  expect.addAssertion(
    '<object> to [not] [only] have keys <array>',
    (expect, subject, keys) => {
      const keysInSubject = {};
      const subjectType = expect.findTypeOf(subject);
      const subjectKeys = subjectType.getKeys(subject);
      subjectKeys.forEach((key) => {
        keysInSubject[key] = true;
      });

      if (expect.flags.not && keys.length === 0) {
        return;
      }

      const hasKeys = keys.every((key) => keysInSubject[key]);

      if (expect.flags.only) {
        expect(hasKeys, 'to be truthy');
        expect.withError(
          () => {
            expect(subjectKeys.length === keys.length, '[not] to be truthy');
          },
          () => {
            expect.fail({
              diff:
                !expect.flags.not &&
                ((output, diff, inspect, equal) => {
                  output.inline = true;
                  const keyInValue = {};
                  keys.forEach((key) => {
                    keyInValue[key] = true;
                  });
                  const subjectIsArrayLike = subjectType.is('array-like');

                  subjectType.prefix(output, subject);
                  output.nl().indentLines();

                  subjectKeys.forEach((key, index) => {
                    const propertyOutput = subjectType.property(
                      output.clone(),
                      key,
                      inspect(subjectType.valueForKey(subject, key)),
                      subjectIsArrayLike
                    );
                    const delimiterOutput = subjectType.delimiter(
                      output.clone(),
                      index,
                      subjectKeys.length
                    );

                    output
                      .i()
                      .block(function () {
                        this.append(propertyOutput).amend(delimiterOutput);
                        if (!keyInValue[key]) {
                          this.sp().annotationBlock(function () {
                            this.error('should be removed');
                          });
                        }
                      })
                      .nl();
                  });

                  output.outdentLines();
                  subjectType.suffix(output, subject);

                  return output;
                }),
            });
          }
        );
      } else {
        expect(hasKeys, '[not] to be truthy');
      }
    }
  );

  expect.addAssertion('<object> [not] to be empty', (expect, subject) => {
    if (
      expect.flags.not &&
      !expect.findTypeOf(subject).getKeys(subject).length
    ) {
      return expect.fail();
    }
    expect(subject, 'to [not] only have keys', []);
  });

  expect.addAssertion(
    '<object> not to have keys <array>',
    (expect, subject, keys) => {
      expect(subject, 'to not have keys', keys);
    }
  );

  expect.addAssertion(
    '<object> not to have key <string>',
    (expect, subject, value) => {
      expect(subject, 'to not have keys', [value]);
    }
  );

  expect.addAssertion(
    '<object> not to have keys <string+>',
    function (expect, subject, value) {
      expect(
        subject,
        'to not have keys',
        Array.prototype.slice.call(arguments, 2)
      );
    }
  );

  expect.addAssertion(
    '<object> to [not] [only] have key <string>',
    (expect, subject, value) => {
      expect(subject, 'to [not] [only] have keys', [value]);
    }
  );

  expect.addAssertion(
    '<object> to [not] [only] have keys <string+>',
    function (expect, subject) {
      expect(
        subject,
        'to [not] [only] have keys',
        Array.prototype.slice.call(arguments, 2)
      );
    }
  );

  expect.addAssertion(
    '<string> [not] to contain <string+>',
    function (expect, subject) {
      const args = Array.prototype.slice.call(arguments, 2);
      args.forEach((arg) => {
        if (arg === '') {
          throw new Error(
            `The '${expect.testDescription}' assertion does not support the empty string`
          );
        }
      });
      expect.withError(
        () => {
          args.forEach((arg) => {
            expect(subject.indexOf(arg) !== -1, '[not] to be truthy');
          });
        },
        (e) => {
          expect.fail({
            diff(output) {
              output.inline = false;
              let lastIndex = 0;
              function flushUntilIndex(i) {
                if (i > lastIndex) {
                  output.text(subject.substring(lastIndex, i));
                  lastIndex = i;
                }
              }
              if (expect.flags.not) {
                subject.replace(
                  new RegExp(
                    args
                      .map((arg) => utils.escapeRegExpMetaChars(arg))
                      .join('|'),
                    'g'
                  ),
                  ($0, index) => {
                    flushUntilIndex(index);
                    lastIndex += $0.length;
                    output.removedHighlight($0);
                  }
                );
                flushUntilIndex(subject.length);
              } else {
                const ranges = [];
                args.forEach((arg) => {
                  let needle = arg;
                  let partial = false;
                  while (needle.length > 1) {
                    let found = false;
                    lastIndex = -1;
                    let index;
                    do {
                      index = subject.indexOf(needle, lastIndex + 1);
                      if (index !== -1) {
                        found = true;
                        ranges.push({
                          startIndex: index,
                          endIndex: index + needle.length,
                          partial,
                        });
                      }
                      lastIndex = index;
                    } while (lastIndex !== -1);
                    if (found) {
                      break;
                    }
                    needle = arg.substr(0, needle.length - 1);
                    partial = true;
                  }
                });
                lastIndex = 0;
                ranges
                  .sort((a, b) => a.startIndex - b.startIndex)
                  .forEach(({ startIndex, endIndex, partial }) => {
                    flushUntilIndex(startIndex);
                    const firstUncoveredIndex = Math.max(startIndex, lastIndex);
                    if (endIndex > firstUncoveredIndex) {
                      if (partial) {
                        output.partialMatch(
                          subject.substring(firstUncoveredIndex, endIndex)
                        );
                      } else {
                        output.match(
                          subject.substring(firstUncoveredIndex, endIndex)
                        );
                      }
                      lastIndex = endIndex;
                    }
                  });
                flushUntilIndex(subject.length);
              }
              return output;
            },
          });
        }
      );
    }
  );

  expect.addAssertion(
    [
      '<array-like> to [only] contain <any+>',
      '<array-like> [not] to contain <any+>',
    ],
    function (expect, subject) {
      const args = Array.prototype.slice.call(arguments, 2);

      expect.withError(
        () => {
          args.forEach((arg) => {
            expect(
              Array.prototype.some.call(subject, (item) =>
                expect.equal(item, arg)
              ),
              '[not] to be truthy'
            );
          });
          if (expect.flags.only) {
            expect(
              Array.prototype.every.call(subject, (item) =>
                Array.prototype.some.call(args, (arg) =>
                  expect.equal(item, arg)
                )
              ),
              'to be truthy'
            );
          }
        },
        (e) => {
          expect.fail({
            diff(output, diff, inspect, equal) {
              if (expect.flags.not) {
                return diff(
                  subject,
                  Array.prototype.filter.call(
                    subject,
                    (item) => !args.some((arg) => equal(item, arg))
                  )
                );
              } else if (expect.flags.only) {
                const excessItems = Array.prototype.filter.call(
                  subject,
                  (item) => args.some((arg) => equal(item, arg))
                );
                const missingItems = args.filter(
                  (arg) =>
                    !Array.prototype.some.call(subject, (item) =>
                      equal(arg, item)
                    )
                );

                return diff(subject, [...excessItems, ...missingItems]);
              }
            },
          });
        }
      );
    }
  );

  expect.addAssertion(
    [
      '<string> [not] to begin with <string>',
      '<string> [not] to start with <string>',
    ],
    (expect, subject, value) => {
      if (value === '') {
        throw new Error(
          `The '${expect.testDescription}' assertion does not support a prefix of the empty string`
        );
      }
      let isTruncated = false;
      let outputSubject = utils.truncateSubjectStringForBegin(subject, value);
      if (outputSubject === null) {
        outputSubject = subject;
      } else {
        isTruncated = true;
      }
      expect.subjectOutput = (output) => {
        output = output.jsString(
          "'" + outputSubject.replace(/\n/g, '\\n') + "'"
        );
        if (isTruncated) {
          output.jsComment('...');
        }
      };
      expect.withError(
        () => {
          expect(subject.substr(0, value.length), '[not] to equal', value);
        },
        () => {
          expect.fail({
            diff(output) {
              output.inline = false;
              if (expect.flags.not) {
                output
                  .removedHighlight(value)
                  .text(subject.substr(value.length));
              } else {
                let i = 0;
                while (subject[i] === value[i]) {
                  i += 1;
                }
                if (i === 0) {
                  // No common prefix, omit diff
                  return null;
                } else {
                  output
                    .partialMatch(subject.substr(0, i))
                    .text(outputSubject.substr(i))
                    .jsComment(isTruncated ? '...' : '');
                }
              }
              return output;
            },
          });
        }
      );
    }
  );

  expect.addAssertion(
    '<string> [not] to end with <string>',
    (expect, subject, value) => {
      if (value === '') {
        throw new Error(
          `The '${expect.testDescription}' assertion does not support a suffix of the empty string`
        );
      }
      let isTruncated = false;
      let outputSubject = utils.truncateSubjectStringForEnd(subject, value);
      if (outputSubject === null) {
        outputSubject = subject;
      } else {
        isTruncated = true;
      }
      expect.subjectOutput = (output) => {
        if (isTruncated) {
          output = output.jsComment('...');
        }
        output.jsString("'" + outputSubject.replace(/\n/g, '\\n') + "'");
      };
      expect.withError(
        () => {
          expect(subject.substr(-value.length), '[not] to equal', value);
        },
        () => {
          expect.fail({
            diff(output) {
              output.inline = false;
              if (expect.flags.not) {
                output
                  .text(subject.substr(0, subject.length - value.length))
                  .removedHighlight(value);
              } else {
                let i = 0;
                while (
                  outputSubject[outputSubject.length - 1 - i] ===
                  value[value.length - 1 - i]
                ) {
                  i += 1;
                }
                if (i === 0) {
                  // No common suffix, omit diff
                  return null;
                }
                output
                  .jsComment(isTruncated ? '...' : '')
                  .text(outputSubject.substr(0, outputSubject.length - i))
                  .partialMatch(
                    outputSubject.substr(
                      outputSubject.length - i,
                      outputSubject.length
                    )
                  );
              }
              return output;
            },
          });
        }
      );
    }
  );

  expect.addAssertion('<number> [not] to be finite', (expect, subject) => {
    expect(isFinite(subject), '[not] to be truthy');
  });

  expect.addAssertion('<number> [not] to be infinite', (expect, subject) => {
    expect(!isNaN(subject) && !isFinite(subject), '[not] to be truthy');
  });

  expect.addAssertion(
    [
      '<number> [not] to be within <number> <number>',
      '<BigInt> [not] to be within <BigInt> <BigInt>',
      '<string> [not] to be within <string> <string>',
    ],
    (expect, subject, start, finish) => {
      expect.argsOutput = (output) => {
        output.appendInspected(start).text('..').appendInspected(finish);
      };
      expect(subject >= start && subject <= finish, '[not] to be truthy');
    }
  );

  expect.addAssertion(
    [
      '<number> [not] to be (less than|below) <number>',
      '<BigInt> [not] to be (less than|below) <BigInt>',
      '<string> [not] to be (less than|below) <string>',
    ],
    (expect, subject, value) => {
      expect(subject < value, '[not] to be truthy');
    }
  );

  expect.addAssertion(
    '<string> [not] to be (less than|below) <string>',
    (expect, subject, value) => {
      expect(subject < value, '[not] to be truthy');
    }
  );

  expect.addAssertion(
    [
      '<number> [not] to be less than or equal to <number>',
      '<BigInt> [not] to be less than or equal to <BigInt>',
      '<string> [not] to be less than or equal to <string>',
    ],
    (expect, subject, value) => {
      expect(subject <= value, '[not] to be truthy');
    }
  );

  expect.addAssertion(
    [
      '<number> [not] to be (greater than|above) <number>',
      '<BigInt> [not] to be (greater than|above) <BigInt>',
      '<string> [not] to be (greater than|above) <string>',
    ],
    (expect, subject, value) => {
      expect(subject > value, '[not] to be truthy');
    }
  );

  expect.addAssertion(
    [
      '<number> [not] to be greater than or equal to <number>',
      '<BigInt> [not] to be greater than or equal to <BigInt>',
      '<string> [not] to be greater than or equal to <string>',
    ],
    (expect, subject, value) => {
      expect(subject >= value, '[not] to be truthy');
    }
  );

  expect.addAssertion('<number> [not] to be positive', (expect, subject) => {
    expect(subject, '[not] to be greater than', 0);
  });

  expect.addAssertion('<BigInt> [not] to be positive', (expect, subject) => {
    expect(subject > 0, '[not] to be true');
  });

  expect.addAssertion('<number> [not] to be negative', (expect, subject) => {
    expect(subject, '[not] to be less than', 0);
  });

  expect.addAssertion('<BigInt> [not] to be negative', (expect, subject) => {
    expect(subject < 0, '[not] to be true');
  });

  expect.addAssertion('<any> to equal <any>', (expect, subject, value) => {
    expect.withError(
      () => {
        expect(expect.equal(value, subject), 'to be truthy');
      },
      (e) => {
        expect.fail({
          label: 'should equal',
          diff(output, diff) {
            return diff(subject, value);
          },
        });
      }
    );
  });

  expect.addAssertion('<any> not to equal <any>', (expect, subject, value) => {
    expect(expect.equal(value, subject), 'to be falsy');
  });

  expect.addAssertion('<function> to error', (expect, subject) =>
    expect
      .promise(() => subject())
      .then(
        () => {
          expect.fail();
        },
        (error) => error
      )
  );

  expect.addAssertion(
    '<function> to error [with] <any>',
    (expect, subject, arg) =>
      expect(subject, 'to error').then((error) => {
        expect.errorMode = 'nested';
        return expect.withError(
          () => {
            return expect(error, 'to satisfy', arg);
          },
          (e) => {
            e.originalError = error;
            throw e;
          }
        );
      })
  );

  expect.addAssertion('<function> not to error', (expect, subject) => {
    let threw = false;
    return expect
      .promise(() => {
        try {
          return subject();
        } catch (e) {
          threw = true;
          throw e;
        }
      })
      .caught((error) => {
        expect.errorMode = 'nested';
        expect.fail({
          output(output) {
            output
              .error(threw ? 'threw' : 'returned promise rejected with')
              .error(': ')
              .appendErrorMessage(error);
          },
          originalError: error,
        });
      });
  });

  expect.addAssertion('<function> not to throw', (expect, subject) => {
    let threw = false;
    let error;

    try {
      subject();
    } catch (e) {
      error = e;
      threw = true;
    }

    if (threw) {
      expect.errorMode = 'nested';
      expect.fail({
        output(output) {
          output.error('threw: ').appendErrorMessage(error);
        },
        originalError: error,
      });
    }
  });

  expect.addAssertion(
    '<function> to (throw|throw error|throw exception)',
    (expect, subject) => {
      try {
        subject();
      } catch (e) {
        return e;
      }
      expect.errorMode = 'nested';
      expect.fail('did not throw');
    }
  );

  expect.addAssertion('<object> to satisfy <function>', (expect) =>
    expect.fail()
  );

  expect.addAssertion(
    '<function> to throw (a|an) <function>',
    (expect, subject, value) => {
      const constructorName = utils.getFunctionName(value);
      if (constructorName) {
        expect.argsOutput[0] = (output) => {
          output.jsFunctionName(constructorName);
        };
      }
      expect.errorMode = 'nested';
      return expect(subject, 'to throw').tap((error) => {
        expect(error, 'to be a', value);
      });
    }
  );

  expect.addAssertion(
    '<function> to (throw|throw error|throw exception) <any>',
    (expect, subject, arg) => {
      expect.errorMode = 'nested';
      return expect(subject, 'to throw').then((error) => {
        // in the presence of a matcher an error must have been thrown.

        expect.errorMode = 'nested';
        return expect.withError(
          () => {
            return expect(error, 'to satisfy', arg);
          },
          (err) => {
            err.originalError = error;
            throw err;
          }
        );
      });
    }
  );

  expect.addAssertion(
    '<function> to have arity <number>',
    (expect, { length }, value) => {
      expect(length, 'to equal', value);
    }
  );

  expect.addAssertion(
    [
      '<object> to have values [exhaustively] satisfying <any>',
      '<object> to have values [exhaustively] satisfying <assertion>',
      '<object> to be (a map|a hash|an object) whose values [exhaustively] satisfy <any>',
      '<object> to be (a map|a hash|an object) whose values [exhaustively] satisfy <assertion>',
    ],
    (expect, subject, nextArg) => {
      expect.errorMode = 'nested';
      expect(subject, 'not to be empty');
      expect.errorMode = 'bubble';

      const keys = expect.subjectType.getKeys(subject);
      const expected = {};
      keys.forEach((key) => {
        if (typeof nextArg === 'string') {
          expected[key] = expect.it((s) => expect.shift(s));
        } else {
          expected[key] = nextArg;
        }
      });
      return expect.withError(
        () => expect(subject, 'to [exhaustively] satisfy', expected),
        (err) => {
          expect.fail({
            message(output) {
              output.append(
                expect.standardErrorMessage(output.clone(), {
                  compact: err && err._isUnexpected && err.hasDiff(),
                })
              );
            },
            diff(output) {
              const diff = err.getDiff({ output });
              diff.inline = true;
              return diff;
            },
          });
        }
      );
    }
  );

  expect.addAssertion(
    [
      '<array-like> to have items [exhaustively] satisfying <any>',
      '<array-like> to have items [exhaustively] satisfying <assertion>',
      '<array-like> to be an array whose items [exhaustively] satisfy <any>',
      '<array-like> to be an array whose items [exhaustively] satisfy <assertion>',
    ],
    (expect, subject, ...rest) => {
      // ...
      expect.errorMode = 'nested';
      expect(subject, 'not to be empty');
      expect.errorMode = 'bubble';

      return expect.withError(
        () =>
          expect(subject, 'to have values [exhaustively] satisfying', ...rest),
        (err) => {
          expect.fail({
            message(output) {
              output.append(
                expect.standardErrorMessage(output.clone(), {
                  compact: err && err._isUnexpected && err.hasDiff(),
                })
              );
            },
            diff(output) {
              const diff = err.getDiff({ output });
              diff.inline = true;
              return diff;
            },
          });
        }
      );
    }
  );

  expect.addAssertion(
    [
      '<object> to have keys satisfying <any>',
      '<object> to have keys satisfying <assertion>',
      '<object> to be (a map|a hash|an object) whose (keys|properties) satisfy <any>',
      '<object> to be (a map|a hash|an object) whose (keys|properties) satisfy <assertion>',
    ],
    (expect, subject, ...rest) => {
      expect.errorMode = 'nested';
      expect(subject, 'not to be empty');
      expect.errorMode = 'default';

      const keys = expect.subjectType.getKeys(subject);
      return expect(keys, 'to have items satisfying', ...rest);
    }
  );

  expect.addAssertion(
    [
      '<object> [not] to have a value [exhaustively] satisfying <any>',
      '<object> [not] to have a value [exhaustively] satisfying <assertion>',
    ],
    (expect, subject, nextArg) => {
      expect.errorMode = 'nested';
      expect(subject, 'not to be empty');
      expect.errorMode = 'bubble';

      const subjectType = expect.findTypeOf(subject);
      const keys = subjectType.getKeys(subject);
      const not = !!expect.flags.not;

      const keyResults = new Array(keys.length);

      expect.withError(
        () =>
          expect.promise[not ? 'all' : 'any'](
            keys.map((key) => {
              let expected;
              if (typeof nextArg === 'string') {
                expected = expect.it((s) => expect.shift(s));
              } else {
                expected = nextArg;
              }

              keyResults[key] = expect.promise(() =>
                expect(
                  subjectType.valueForKey(subject, key),
                  '[not] to [exhaustively] satisfy',
                  expected
                )
              );
              return keyResults[key];
            })
          ),
        (err) => {
          expect.fail({
            message(output) {
              output.append(
                expect.standardErrorMessage(output.clone(), {
                  compact: err && err._isUnexpected && err.hasDiff(),
                })
              );
            },
            diff:
              expect.flags.not &&
              ((output, diff, inspect, equal) => {
                const expectedObject = subjectType.is('array-like') ? [] : {};
                keys.forEach((key) => {
                  if (keyResults[key].isFulfilled()) {
                    expectedObject[key] = subjectType.valueForKey(subject, key);
                  }
                });

                return diff(subject, expectedObject);
              }),
          });
        }
      );
    }
  );

  expect.addAssertion(
    [
      '<array-like> [not] to have an item [exhaustively] satisfying <any>',
      '<array-like> [not] to have an item [exhaustively] satisfying <assertion>',
    ],
    (expect, subject, ...rest) => {
      expect.errorMode = 'nested';
      expect(subject, 'not to be empty');
      expect.errorMode = 'default';

      return expect(
        subject,
        '[not] to have a value [exhaustively] satisfying',
        ...rest
      );
    }
  );

  expect.addAssertion('<object> to be canonical', (expect, subject) => {
    const stack = [];

    (function traverse(obj) {
      let i;
      for (i = 0; i < stack.length; i += 1) {
        if (stack[i] === obj) {
          return;
        }
      }
      if (obj && typeof obj === 'object') {
        const keys = Object.keys(obj);
        for (i = 0; i < keys.length - 1; i += 1) {
          expect(keys[i], 'to be less than', keys[i + 1]);
        }
        stack.push(obj);
        keys.forEach((key) => {
          traverse(obj[key]);
        });
        stack.pop();
      }
    })(subject);
  });

  expect.addAssertion(
    '<Error> to have message <any>',
    (expect, subject, value) => {
      expect.errorMode = 'nested';
      return expect(
        subject.isUnexpected
          ? subject.getErrorMessage('text').toString()
          : subject.message,
        'to satisfy',
        value
      );
    }
  );

  expect.addAssertion(
    '<Error> to [exhaustively] satisfy <Error>',
    (expect, subject, value) => {
      expect(subject.constructor, 'to be', value.constructor);

      const unwrappedValue = expect.argTypes[0].unwrap(value);
      return expect.withError(
        () => expect(subject, 'to [exhaustively] satisfy', unwrappedValue),
        (e) => {
          expect.fail({
            diff(output, diff) {
              output.inline = false;
              const unwrappedSubject = expect.subjectType.unwrap(subject);
              return utils.wrapConstructorNameAroundOutput(
                diff(unwrappedSubject, unwrappedValue),
                subject
              );
            },
          });
        }
      );
    }
  );

  expect.addAssertion(
    '<Error> to [exhaustively] satisfy <object>',
    (expect, subject, value) => {
      const valueType = expect.argTypes[0];
      const subjectKeys = expect.subjectType.getKeys(subject);
      const valueKeys = valueType.getKeys(value);
      const convertedSubject = {};
      subjectKeys.concat(valueKeys).forEach((key) => {
        convertedSubject[key] = subject[key];
      });
      return expect(convertedSubject, 'to [exhaustively] satisfy', value);
    }
  );

  expect.addAssertion(
    '<Error> to [exhaustively] satisfy <regexp|string|any>',
    (expect, { message }, value) =>
      expect(message, 'to [exhaustively] satisfy', value)
  );

  expect.addAssertion(
    '<UnexpectedError> to [exhaustively] satisfy <regexp|string>',
    (expect, error, value) => {
      expect.errorMode = 'bubble';
      return expect(error, 'to have message', value);
    }
  );

  expect.addAssertion(
    '<binaryArray> to [exhaustively] satisfy <expect.it>',
    (expect, subject, value) =>
      expect.withError(
        () => value(subject, expect.context),
        (e) => {
          expect.fail({
            diff(output, diff, inspect, equal) {
              output.inline = false;
              return output.appendErrorMessage(e);
            },
          });
        }
      )
  );

  expect.addAssertion(
    '<any|Error> to [exhaustively] satisfy <expect.it>',
    (expect, subject, value) => expect.promise(() => value(subject))
  );

  if (typeof Buffer !== 'undefined') {
    expect.addAssertion(
      '<Buffer> [when] decoded as <string> <assertion?>',
      (expect, subject, value) => expect.shift(subject.toString(value))
    );
  }

  expect.addAssertion(
    '<any> not to [exhaustively] satisfy [assertion] <any>',
    (expect, subject, value) =>
      expect.promise((resolve, reject) =>
        expect
          .promise(() =>
            expect(subject, 'to [exhaustively] satisfy [assertion]', value)
          )
          .then(() => {
            try {
              expect.fail();
            } catch (e) {
              reject(e);
            }
          })
          .caught((e) => {
            if (!e || !e._isUnexpected) {
              reject(e);
            } else {
              resolve();
            }
          })
      )
  );

  expect.addAssertion(
    '<any> to [exhaustively] satisfy assertion <any>',
    (expect, subject, value) => {
      expect.errorMode = 'bubble'; // to satisfy assertion 'to be a number' => to be a number
      return expect(subject, 'to [exhaustively] satisfy', value);
    }
  );

  expect.addAssertion(
    '<any> to [exhaustively] satisfy assertion <assertion>',
    (expect, subject) => {
      expect.errorMode = 'bubble'; // to satisfy assertion 'to be a number' => to be a number
      return expect.shift();
    }
  );

  expect.addAssertion(
    '<any|object> to [exhaustively] satisfy [assertion] <expect.it>',
    (expect, subject, value) =>
      expect.withError(
        () => value(subject, expect.context),
        (e) => {
          expect.fail({
            diff(output) {
              output.inline = false;
              return output.appendErrorMessage(e);
            },
          });
        }
      )
  );

  expect.addAssertion(
    '<regexp> to [exhaustively] satisfy <regexp>',
    (expect, subject, value) => {
      expect(subject, 'to equal', value);
    }
  );

  expect.addAssertion(
    '<string> to [exhaustively] satisfy <regexp>',
    (expect, subject, value) => {
      expect.errorMode = 'bubble';
      return expect(subject, 'to match', value);
    }
  );

  expect.addAssertion(
    '<function> to [exhaustively] satisfy <function>',
    (expect, subject, value) => {
      expect.errorMode = 'bubble';
      expect(subject, 'to be', value);
    }
  );

  expect.addAssertion(
    '<binaryArray> to [exhaustively] satisfy <binaryArray>',
    (expect, subject, value) => {
      expect.errorMode = 'bubble';
      expect(subject, 'to equal', value);
    }
  );

  expect.addAssertion(
    '<any> to [exhaustively] satisfy <any>',
    (expect, subject, value) => {
      expect.errorMode = 'bubble';
      expect(subject, 'to equal', value);
    }
  );

  expect.addAssertion(
    '<array-like> to [exhaustively] satisfy <array-like>',
    (expect, subject, value) => {
      expect.errorMode = 'bubble';
      const subjectType = expect.subjectType;
      const subjectKeys = subjectType.getKeys(subject);
      const valueType = expect.argTypes[0];
      const valueKeys = valueType.getKeys(value).filter(
        (key) =>
          utils.numericalRegExp.test(key) ||
          typeof key === 'symbol' ||
          // include keys whose value is not undefined on either LHS or RHS
          typeof valueType.valueForKey(value, key) !== 'undefined' ||
          typeof subjectType.valueForKey(subject, key) !== 'undefined'
      );
      const keyPromises = {};
      valueKeys.forEach(function (keyInValue) {
        keyPromises[keyInValue] = expect.promise(function () {
          const subjectKey = subjectType.valueForKey(subject, keyInValue);
          const valueKey = valueType.valueForKey(value, keyInValue);
          const valueKeyType = expect.findTypeOf(valueKey);

          if (valueKeyType.is('expect.it')) {
            expect.context.thisObject = subject;
            return valueKey(subjectKey, expect.context);
          } else {
            return expect(subjectKey, 'to [exhaustively] satisfy', valueKey);
          }
        });
      });
      return expect.promise
        .all([
          expect.promise(() => {
            // create subject key presence object
            const remainingKeysInSubject = {};
            subjectKeys.forEach((key) => {
              remainingKeysInSubject[key] = 1; // present in subject
            });
            // discard or mark missing each previously seen value key
            valueKeys.forEach((key) => {
              if (
                !remainingKeysInSubject[key] &&
                (utils.numericalRegExp.test(key) || expect.flags.exhaustively)
              ) {
                remainingKeysInSubject[key] = 2; // present in value
              } else {
                delete remainingKeysInSubject[key];
              }
            });
            // check whether there are any outstanding keys we cannot account for
            const outstandingKeys = Object.keys(remainingKeysInSubject).filter(
              (key) =>
                utils.numericalRegExp.test(key) ||
                typeof key === 'symbol' ||
                (typeof subjectType.valueForKey(subject, key) !== 'undefined' &&
                  // key was only in the value
                  remainingKeysInSubject[key] === 2)
            );
            // key checking succeeds with no outstanding keys
            expect(outstandingKeys.length === 0, 'to be truthy');
          }),
          expect.promise.all(keyPromises),
        ])
        .caught(() => {
          let i = 0;
          return expect.promise.settle(keyPromises).then(() => {
            const toSatisfyMatrix = new Array(subject.length);
            for (i = 0; i < subject.length; i += 1) {
              toSatisfyMatrix[i] = new Array(value.length);
              if (i < value.length) {
                toSatisfyMatrix[i][i] =
                  keyPromises[i].isFulfilled() || keyPromises[i].reason();
              }
            }
            if (subject.length > 10 || value.length > 10) {
              const indexByIndexChanges = [];
              for (i = 0; i < subject.length; i += 1) {
                const promise = keyPromises[i];
                if (i < value.length) {
                  indexByIndexChanges.push({
                    type: promise.isFulfilled() ? 'equal' : 'similar',
                    value: subject[i],
                    expected: value[i],
                    actualIndex: i,
                    expectedIndex: i,
                    last: i === Math.max(subject.length, value.length) - 1,
                  });
                } else {
                  indexByIndexChanges.push({
                    type: 'remove',
                    value: subject[i],
                    actualIndex: i,
                    last: i === subject.length - 1,
                  });
                }
              }
              for (i = subject.length; i < value.length; i += 1) {
                indexByIndexChanges.push({
                  type: 'insert',
                  value: value[i],
                  expectedIndex: i,
                });
              }
              return failWithChanges(indexByIndexChanges);
            }

            let isAsync = false;
            const subjectElements = utils.duplicateArrayLikeUsingType(
              subject,
              subjectType
            );
            const valueElements = utils.duplicateArrayLikeUsingType(
              value,
              valueType
            );
            const nonNumericalKeysAndSymbols =
              !subjectType.numericalPropertiesOnly &&
              utils.uniqueNonNumericalStringsAndSymbols(subjectKeys, valueKeys);

            const changes = arrayChanges(
              subjectElements,
              valueElements,
              function equal(a, b, aIndex, bIndex) {
                toSatisfyMatrix[aIndex] = toSatisfyMatrix[aIndex] || [];
                const existingResult = toSatisfyMatrix[aIndex][bIndex];
                if (typeof existingResult !== 'undefined') {
                  return existingResult === true;
                }
                let result;
                try {
                  result = expect(a, 'to [exhaustively] satisfy', b);
                } catch (err) {
                  throwIfNonUnexpectedError(err);
                  toSatisfyMatrix[aIndex][bIndex] = err;
                  return false;
                }
                result.then(
                  () => {},
                  () => {}
                );
                if (result.isPending()) {
                  isAsync = true;
                  return false;
                }
                toSatisfyMatrix[aIndex][bIndex] = true;
                return true;
              },
              (a, b) => subjectType.similar(a, b),
              {
                includeNonNumericalProperties: nonNumericalKeysAndSymbols,
              }
            );
            if (isAsync) {
              return expect
                .promise((resolve, reject) => {
                  arrayChangesAsync(
                    subject,
                    value,
                    function equal(a, b, aIndex, bIndex, fn) {
                      toSatisfyMatrix[aIndex] = toSatisfyMatrix[aIndex] || [];
                      const existingResult = toSatisfyMatrix[aIndex][bIndex];
                      if (typeof existingResult !== 'undefined') {
                        return fn(existingResult === true);
                      }
                      expect
                        .promise(() =>
                          expect(a, 'to [exhaustively] satisfy', b)
                        )
                        .then(
                          () => {
                            toSatisfyMatrix[aIndex][bIndex] = true;
                            fn(true);
                          },
                          (err) => {
                            toSatisfyMatrix[aIndex][bIndex] = err;
                            fn(false);
                          }
                        );
                    },
                    (a, b, aIndex, bIndex, fn) => {
                      fn(subjectType.similar(a, b));
                    },
                    nonNumericalKeysAndSymbols,
                    resolve
                  );
                })
                .then(failWithChanges);
            } else {
              return failWithChanges(changes);
            }

            function failWithChanges(changes) {
              expect.errorMode = 'default';
              expect.fail({
                diff(output, diff, inspect, equal) {
                  output.inline = true;
                  const indexOfLastNonInsert = changes.reduce(
                    (previousValue, { type }, index) =>
                      type === 'insert' ? previousValue : index,
                    -1
                  );
                  const prefixOutput = subjectType.prefix(
                    output.clone(),
                    subject
                  );
                  output
                    .append(prefixOutput)
                    .nl(prefixOutput.isEmpty() ? 0 : 1);

                  if (subjectType.indent) {
                    output.indentLines();
                  }
                  const packing = utils.packArrows(changes); // NOTE: Will have side effects in changes if the packing results in too many arrow lanes
                  output.arrowsAlongsideChangeOutputs(
                    packing,
                    changes.map((diffItem, index) => {
                      const delimiterOutput = subjectType.delimiter(
                        output.clone(),
                        index,
                        indexOfLastNonInsert + 1
                      );
                      const type = diffItem.type;
                      if (type === 'moveTarget') {
                        return output.clone();
                      } else {
                        return output.clone().block(function () {
                          if (type === 'moveSource') {
                            const propertyOutput = subjectType.property(
                              output.clone(),
                              diffItem.actualIndex,
                              inspect(diffItem.value),
                              true
                            );

                            this.append(propertyOutput)
                              .amend(delimiterOutput)
                              .sp()
                              .error('// should be moved');
                          } else if (type === 'insert') {
                            this.annotationBlock(function () {
                              if (
                                expect
                                  .findTypeOf(diffItem.value)
                                  .is('expect.it')
                              ) {
                                this.error('missing: ').block(function () {
                                  this.omitSubject = undefined;
                                  const promise =
                                    keyPromises[diffItem.expectedIndex];
                                  if (promise.isRejected()) {
                                    this.appendErrorMessage(promise.reason());
                                  } else {
                                    this.appendInspected(diffItem.value);
                                  }
                                });
                              } else {
                                const index =
                                  typeof diffItem.actualIndex !== 'undefined'
                                    ? diffItem.actualIndex
                                    : diffItem.expectedIndex;
                                const propertyOutput = subjectType.property(
                                  output.clone(),
                                  index,
                                  inspect(diffItem.value),
                                  true
                                );
                                this.error('missing ').append(propertyOutput);
                              }
                            });
                          } else {
                            const propertyOutput = subjectType.property(
                              output.clone(),
                              diffItem.actualIndex,
                              inspect(diffItem.value),
                              true
                            );

                            this.block(function () {
                              if (type === 'remove') {
                                this.append(propertyOutput)
                                  .amend(delimiterOutput)
                                  .sp()
                                  .error('// should be removed');
                              } else if (type === 'equal') {
                                this.append(propertyOutput).amend(
                                  delimiterOutput
                                );
                              } else {
                                const toSatisfyResult =
                                  toSatisfyMatrix[diffItem.actualIndex][
                                    diffItem.expectedIndex
                                  ];
                                const valueDiff =
                                  toSatisfyResult &&
                                  toSatisfyResult !== true &&
                                  toSatisfyResult.getDiff({
                                    output: output.clone(),
                                  });
                                if (valueDiff && valueDiff.inline) {
                                  this.append(valueDiff).amend(delimiterOutput);
                                } else {
                                  this.append(propertyOutput)
                                    .amend(delimiterOutput)
                                    .sp()
                                    .annotationBlock(function () {
                                      this.omitSubject = diffItem.value;
                                      const label = toSatisfyResult.getLabel();
                                      if (label) {
                                        this.error(label)
                                          .sp()
                                          .block(inspect(diffItem.expected));
                                        if (valueDiff) {
                                          this.nl(2).append(valueDiff);
                                        }
                                      } else {
                                        this.appendErrorMessage(
                                          toSatisfyResult
                                        );
                                      }
                                    });
                                }
                              }
                            });
                          }
                        });
                      }
                    })
                  );

                  if (subjectType.indent) {
                    output.outdentLines();
                  }
                  const suffixOutput = subjectType.suffix(
                    output.clone(),
                    subject
                  );
                  output
                    .nl(suffixOutput.isEmpty() ? 0 : 1)
                    .append(suffixOutput);

                  return output;
                },
              });
            }
          });
        });
    }
  );

  const disallowedConstructors = [];
  ['Set', 'WeakSet', 'Map', 'WeakMap'].forEach((constructorName) => {
    const Constructor = (typeof window !== 'undefined' ? window : global)[
      constructorName
    ];
    if (typeof Constructor === 'function') {
      disallowedConstructors.push(Constructor);
    }
  });

  expect.addAssertion(
    '<object> to [exhaustively] satisfy <object>',
    (expect, subject, value) => {
      const valueType = expect.argTypes[0];
      const subjectType = expect.subjectType;
      const subjectIsArrayLike = subjectType.is('array-like');
      if (subject === value) {
        return;
      }
      if (valueType.is('array-like') && !subjectIsArrayLike) {
        expect.fail();
      }
      disallowedConstructors.forEach(function (Constructor) {
        if (subject instanceof Constructor) {
          expect.fail({
            message: `A ${Constructor.name} instance is not allowed as a subject of "to satisfy"`,
            errorMode: 'bubbleThrough',
          });
        }
      });

      if (Object.getPrototypeOf(value) !== Object.prototype) {
        expect.fail({
          message: 'Can only satisfy against a plain object',
          errorMode: 'bubbleThrough',
        });
      }

      const subjectKeys = subjectType.getKeys(subject);
      const valueKeys = valueType.getKeys(value);
      // calculate the unique keys early given enumerability no
      // longer affects what is included in the list of keys
      const uniqueKeys = subjectType.uniqueKeys(subjectKeys, valueKeys);

      const promiseByKey = {};
      let forceExhaustivelyComparison = false;
      uniqueKeys.forEach((key, index) => {
        const subjectHasKey = subjectType.hasKey(subject, key);
        const valueKey = valueType.hasKey(value, key, true)
          ? valueType.valueForKey(value, key)
          : undefined;
        const valueKeyType = expect.findTypeOf(valueKey);
        if (expect.flags.exhaustively) {
          if (valueKeyType.is('expect.it') && !subjectHasKey) {
            // ensure value only expect.it key is marked missing
            forceExhaustivelyComparison = true;
          }
        } else if (subjectHasKey && typeof valueKey === 'undefined') {
          // ignore subject only keys unless we are being exhaustive
          return;
        }
        const subjectKey = subjectHasKey
          ? subjectType.valueForKey(subject, key)
          : undefined;

        promiseByKey[key] = expect.promise(() => {
          if (valueKeyType.is('expect.it')) {
            expect.context.thisObject = subject;
            return valueKey(subjectKey, expect.context);
          } else {
            return expect(subjectKey, 'to [exhaustively] satisfy', valueKey);
          }
        });
      });

      return expect.promise
        .all([
          expect.promise(() => {
            if (forceExhaustivelyComparison) {
              throw new Error('exhaustive comparison failure');
            }
          }),
          expect.promise.all(promiseByKey),
        ])
        .caught(() =>
          expect.promise.settle(promiseByKey).then(() => {
            expect.fail({
              diff(output, diff, inspect, equal) {
                output.inline = true;
                const subjectIsArrayLike = subjectType.is('array-like');
                // Skip missing keys expected to be missing so they don't get rendered in the diff
                const keys = uniqueKeys.filter((key) => {
                  return (
                    subjectType.hasKey(subject, key) ||
                    typeof valueType.valueForKey(value, key) !== 'undefined'
                  );
                });
                const prefixOutput = subjectType.prefix(
                  output.clone(),
                  subject
                );
                output.append(prefixOutput).nl(prefixOutput.isEmpty() ? 0 : 1);

                if (subjectType.indent) {
                  output.indentLines();
                }
                keys.forEach((key, index) => {
                  const subjectKey = subjectType.valueForKey(subject, key);
                  const valueKey = valueType.valueForKey(value, key);
                  output
                    .nl(index > 0 ? 1 : 0)
                    .i()
                    .block(function () {
                      let valueOutput;
                      const annotation = output.clone();
                      let conflicting;

                      if (
                        Object.prototype.hasOwnProperty.call(
                          promiseByKey,
                          key
                        ) &&
                        promiseByKey[key].isRejected()
                      ) {
                        conflicting = promiseByKey[key].reason();
                      }

                      const missingArrayIndex =
                        subjectType.is('array-like') &&
                        !subjectType.hasKey(subject, key);

                      let isInlineDiff = true;

                      output.omitSubject = subjectKey;
                      if (!valueType.hasKey(value, key)) {
                        if (expect.flags.exhaustively) {
                          annotation.error('should be removed');
                        } else {
                          conflicting = null;
                        }
                      } else if (!subjectType.hasKey(subject, key)) {
                        if (expect.findTypeOf(valueKey).is('expect.it')) {
                          if (promiseByKey[key].isRejected()) {
                            output.error('// missing:').sp();
                            valueOutput = output
                              .clone()
                              .appendErrorMessage(promiseByKey[key].reason());
                          } else {
                            output.error('// missing').sp();
                            valueOutput = output
                              .clone()
                              .error('should satisfy')
                              .sp()
                              .block(inspect(value[key]));
                          }
                        } else {
                          output.error('// missing').sp();
                          valueOutput = inspect(valueKey);
                        }
                      } else if (conflicting || missingArrayIndex) {
                        const keyDiff =
                          conflicting && conflicting.getDiff({ output });
                        isInlineDiff = !keyDiff || keyDiff.inline;
                        if (missingArrayIndex) {
                          output.error('// missing').sp();
                        }
                        if (keyDiff && keyDiff.inline) {
                          valueOutput = keyDiff;
                        } else if (
                          expect.findTypeOf(valueKey).is('expect.it')
                        ) {
                          isInlineDiff = false;
                          annotation.appendErrorMessage(conflicting);
                        } else if (!keyDiff || (keyDiff && !keyDiff.inline)) {
                          annotation
                            .error(
                              (conflicting && conflicting.getLabel()) ||
                                'should satisfy'
                            )
                            .sp()
                            .block(inspect(valueKey));

                          if (keyDiff) {
                            annotation.nl(2).append(keyDiff);
                          }
                        } else {
                          valueOutput = keyDiff;
                        }
                      }

                      if (!valueOutput) {
                        if (
                          missingArrayIndex ||
                          !subjectType.hasKey(subject, key)
                        ) {
                          valueOutput = output.clone();
                        } else {
                          valueOutput = inspect(subjectKey);
                        }
                      }

                      const omitDelimiter =
                        missingArrayIndex || index >= subjectKeys.length - 1;

                      if (!omitDelimiter) {
                        const delimiterOutput = subjectType.delimiter(
                          output.clone(),
                          index,
                          keys.length
                        );
                        valueOutput.amend(delimiterOutput);
                      }

                      const annotationOnNextLine =
                        !isInlineDiff &&
                        output.preferredWidth <
                          this.size().width +
                            valueOutput.size().width +
                            annotation.size().width;

                      if (!annotation.isEmpty()) {
                        if (!valueOutput.isEmpty()) {
                          if (annotationOnNextLine) {
                            valueOutput.nl();
                          } else {
                            valueOutput.sp();
                          }
                        }

                        valueOutput.annotationBlock(function () {
                          this.append(annotation);
                        });
                      }

                      if (!isInlineDiff) {
                        valueOutput = output.clone().block(valueOutput);
                      }

                      const propertyOutput = subjectType.property(
                        output.clone(),
                        key,
                        valueOutput,
                        subjectIsArrayLike
                      );

                      this.append(propertyOutput);
                    });
                });

                if (subjectType.indent) {
                  output.outdentLines();
                }
                const suffixOutput = subjectType.suffix(
                  output.clone(),
                  subject
                );
                return output
                  .nl(suffixOutput.isEmpty() ? 0 : 1)
                  .append(suffixOutput);
              },
            });
          })
        );
    }
  );

  function wrapDiffWithTypePrefixAndSuffix(e, type, subject) {
    const createDiff = e.getDiffMethod();
    if (createDiff) {
      return function (output, ...rest) {
        type.prefix(output, subject);
        const result = createDiff.call(this, output, ...rest);
        type.suffix(output, subject);
        return result;
      };
    }
  }

  expect.addAssertion(
    '<wrapperObject> to [exhaustively] satisfy <wrapperObject>',
    (expect, subject, value) => {
      const type = expect.findCommonType(subject, value);
      expect(type.is('wrapperObject'), 'to be truthy');
      return expect.withError(
        () =>
          expect(
            type.unwrap(subject),
            'to [exhaustively] satisfy',
            type.unwrap(value)
          ),
        (e) => {
          expect.fail({
            label: e.getLabel(),
            diff: wrapDiffWithTypePrefixAndSuffix(e, type, subject),
          });
        }
      );
    }
  );

  expect.addAssertion(
    '<wrapperObject> to [exhaustively] satisfy <any>',
    (expect, subject, value) => {
      const subjectType = expect.subjectType;

      return expect.withError(
        () =>
          expect(
            subjectType.unwrap(subject),
            'to [exhaustively] satisfy',
            value
          ),
        (e) => {
          expect.fail({
            label: e.getLabel(),
            diff: wrapDiffWithTypePrefixAndSuffix(e, subjectType, subject),
          });
        }
      );
    }
  );

  expect.addAssertion(
    '<function> [when] called with <array-like> <assertion?>',
    (expect, subject, args) => {
      // ...
      expect.errorMode = 'nested';
      expect.argsOutput[0] = (output) => {
        output.appendItems(args, ', ');
      };

      const thisObject = expect.context.thisObject || null;

      return expect.shift(subject.apply(thisObject, args));
    }
  );

  expect.addAssertion(
    '<function> [when] called <assertion?>',
    (expect, subject) => {
      expect.errorMode = 'nested';

      const thisObject = expect.context.thisObject || null;

      return expect.shift(subject.call(thisObject));
    }
  );

  function instantiate(Constructor, args) {
    function ProxyConstructor() {
      return Constructor.apply(this, args);
    }
    ProxyConstructor.prototype = Constructor.prototype;
    return new ProxyConstructor();
  }

  expect.addAssertion(
    [
      '<array-like> [when] passed as parameters to [async] <function> <assertion?>',
      '<array-like> [when] passed as parameters to [constructor] <function> <assertion?>',
    ],
    (expect, subject, fn) => {
      // ...
      expect.errorMode = 'nested';
      let args = subject;
      if (expect.flags.async) {
        return expect.promise((run) => {
          args = [
            ...args,
            run((err, result) => {
              expect(err, 'to be falsy');
              return expect.shift(result);
            }),
          ];
          fn(...args);
        });
      } else {
        return expect.shift(
          expect.flags.constructor ? instantiate(fn, args) : fn(...args)
        );
      }
    }
  );

  expect.addAssertion(
    [
      '<any> [when] passed as parameter to [async] <function> <assertion?>',
      '<any> [when] passed as parameter to [constructor] <function> <assertion?>',
    ],
    (expect, subject, fn) => {
      // ...
      expect.errorMode = 'nested';
      let args = [subject];
      if (expect.flags.async) {
        return expect.promise((run) => {
          args = [
            ...args,
            run((err, result) => {
              expect(err, 'to be falsy');
              return expect.shift(result);
            }),
          ];
          fn(...args);
        });
      } else {
        return expect.shift(
          expect.flags.constructor ? instantiate(fn, args) : fn(...args)
        );
      }
    }
  );

  expect.addAssertion(
    [
      '<array-like> [when] sorted [numerically] <assertion?>',
      '<array-like> [when] sorted by <function> <assertion?>',
    ],
    (expect, subject, compareFunction) => {
      if (expect.flags.numerically) {
        compareFunction = (a, b) => a - b;
      }
      return expect.shift(
        Array.prototype.slice
          .call(subject)
          .sort(
            typeof compareFunction === 'function' ? compareFunction : undefined
          )
      );
    }
  );

  expect.addAssertion('<Promise> to be rejected', (expect, subject) => {
    expect.errorMode = 'nested';
    return expect
      .promise(() => subject)
      .then(
        (obj) => {
          expect.fail((output) => {
            output.appendInspected(subject).sp().text('unexpectedly fulfilled');
            if (typeof obj !== 'undefined') {
              output.sp().text('with').sp().appendInspected(obj);
            }
          });
        },
        (err) => err
      );
  });

  expect.addAssertion('<function> to be rejected', (expect, subject) => {
    expect.errorMode = 'nested';
    return expect(
      expect.promise(() => subject()),
      'to be rejected'
    );
  });

  expect.addAssertion(
    [
      '<Promise> to be rejected with <any>',
      '<Promise> to be rejected with error [exhaustively] satisfying <any>',
    ],
    (expect, subject, value) => {
      expect.errorMode = 'nested';
      return expect(subject, 'to be rejected').tap((err) =>
        expect.withError(
          () => expect(err, 'to [exhaustively] satisfy', value),
          (e) => {
            e.originalError = err;
            throw e;
          }
        )
      );
    }
  );

  expect.addAssertion(
    [
      '<function> to be rejected with <any>',
      '<function> to be rejected with error [exhaustively] satisfying <any>',
    ],
    (expect, subject, value) => {
      expect.errorMode = 'nested';
      return expect(
        expect.promise(() => subject()),
        'to be rejected with error [exhaustively] satisfying',
        value
      );
    }
  );

  expect.addAssertion('<Promise> to be fulfilled', (expect, subject) => {
    expect.errorMode = 'nested';
    return expect
      .promise(() => subject)
      .caught((err) => {
        expect.fail({
          output(output) {
            output.appendInspected(subject).sp().text('unexpectedly rejected');
            if (typeof err !== 'undefined') {
              output.sp().text('with').sp().appendInspected(err);
            }
          },
          originalError: err,
        });
      });
  });

  expect.addAssertion('<function> to be fulfilled', (expect, subject) => {
    expect.errorMode = 'nested';
    return expect(
      expect.promise(() => subject()),
      'to be fulfilled'
    );
  });

  expect.addAssertion(
    [
      '<Promise> to be fulfilled with <any>',
      '<Promise> to be fulfilled with value [exhaustively] satisfying <any>',
    ],
    (expect, subject, value) => {
      expect.errorMode = 'nested';
      return expect(subject, 'to be fulfilled').tap((fulfillmentValue) =>
        expect(fulfillmentValue, 'to [exhaustively] satisfy', value)
      );
    }
  );

  expect.addAssertion(
    [
      '<function> to be fulfilled with <any>',
      '<function> to be fulfilled with value [exhaustively] satisfying <any>',
    ],
    (expect, subject, value) => {
      expect.errorMode = 'nested';
      return expect(
        expect.promise(() => subject()),
        'to be fulfilled with value [exhaustively] satisfying',
        value
      );
    }
  );

  expect.addAssertion(
    '<Promise> when rejected <assertion>',
    (expect, subject, nextAssertion) => {
      expect.errorMode = 'nested';
      return expect
        .promise(() => subject)
        .then(
          (fulfillmentValue) => {
            if (typeof nextAssertion === 'string') {
              expect.argsOutput = (output) => {
                output.error(nextAssertion);
                const rest = expect.args.slice(1);
                if (rest.length > 0) {
                  output.sp().appendItems(rest, ', ');
                }
              };
            }
            expect.fail((output) => {
              output
                .appendInspected(subject)
                .sp()
                .text('unexpectedly fulfilled');
              if (typeof fulfillmentValue !== 'undefined') {
                output.sp().text('with').sp().appendInspected(fulfillmentValue);
              }
            });
          },
          (err) => {
            if (
              err.isOperational &&
              !Object.prototype.propertyIsEnumerable.call(err, 'isOperational')
            ) {
              delete err.isOperational;
            }

            expect.withError(
              () => expect.shift(err),
              (e) => {
                e.originalError = err;
                throw e;
              }
            );
          }
        );
    }
  );

  expect.addAssertion(
    '<function> when rejected <assertion>',
    (expect, subject, ...rest) => {
      expect.errorMode = 'nested';
      return expect(
        expect.promise(() => subject()),
        'when rejected',
        ...rest
      );
    }
  );

  expect.addAssertion(
    '<Promise> when fulfilled <assertion>',
    (expect, subject, nextAssertion) => {
      expect.errorMode = 'nested';
      return expect
        .promise(() => subject)
        .then(
          (fulfillmentValue) => expect.shift(fulfillmentValue),
          (err) => {
            // typeof nextAssertion === 'string' because expect.it is handled by the above (and shift only supports those two):
            expect.argsOutput = (output) => {
              output.error(nextAssertion);
              const rest = expect.args.slice(1);
              if (rest.length > 0) {
                output.sp().appendItems(rest, ', ');
              }
            };
            expect.fail({
              output(output) {
                output
                  .appendInspected(subject)
                  .sp()
                  .text('unexpectedly rejected');
                if (typeof err !== 'undefined') {
                  output.sp().text('with').sp().appendInspected(err);
                }
              },
              originalError: err,
            });
          }
        );
    }
  );

  expect.addAssertion(
    '<function> when fulfilled <assertion>',
    (expect, subject, ...rest) => {
      expect.errorMode = 'nested';
      return expect(
        expect.promise(() => subject()),
        'when fulfilled',
        ...rest
      );
    }
  );

  expect.addAssertion('<function> to call the callback', (expect, subject) => {
    expect.errorMode = 'nested';
    return expect.promise((run) => {
      let async = false;
      let calledTwice = false;
      let callbackArgs;
      function cb(...args) {
        if (callbackArgs) {
          calledTwice = true;
        } else {
          callbackArgs = Array.prototype.slice.call(args);
        }
        if (async) {
          setTimeout(assert, 0);
        }
      }

      const assert = run(() => {
        if (calledTwice) {
          expect.fail(function () {
            this.error('The callback was called twice');
          });
        }
        return callbackArgs;
      });

      subject(cb);
      async = true;
      if (callbackArgs) {
        return assert();
      }
    });
  });

  expect.addAssertion(
    '<function> to call the callback without error',
    (expect, subject) =>
      expect(subject, 'to call the callback').then((callbackArgs) => {
        const err = callbackArgs[0];
        if (err) {
          expect.errorMode = 'nested';
          expect.fail({
            message(output) {
              output.error('called the callback with: ');
              if (err.getErrorMessage) {
                output.appendErrorMessage(err);
              } else {
                output.appendInspected(err);
              }
            },
          });
        } else {
          return callbackArgs.slice(1);
        }
      })
  );

  expect.addAssertion(
    '<function> to call the callback with error',
    (expect, subject) =>
      expect(subject, 'to call the callback').spread((err) => {
        expect(err, 'to be truthy');
        return err;
      })
  );

  expect.addAssertion(
    '<function> to call the callback with error <any>',
    (expect, subject, value) =>
      expect(subject, 'to call the callback with error').tap((err) => {
        expect.errorMode = 'nested';
        expect(err, 'to satisfy', value);
      })
  );

  expect.addAssertion(
    '<Set> [not] to contain <any+>',
    (expect, subject, ...values) => {
      const subjectElements = [];
      subject.forEach((element) => {
        subjectElements.push(element);
      });

      expect.withError(
        () => {
          values.forEach((value) => {
            expect(
              subject.has(value) ||
                subjectElements.some((element) => expect.equal(element, value)),
              '[not] to be true'
            );
          });
        },
        () => {
          expect.fail({
            diff(output, diff, inspect, equal) {
              output.inline = true;
              expect.subjectType.prefix(output, subject);
              output.nl().indentLines();

              subjectElements.forEach((subjectElement, subjectIndex) => {
                output
                  .i()
                  .block(function () {
                    this.appendInspected(subjectElement);
                    expect.subjectType.delimiter(
                      this,
                      subjectIndex,
                      subjectElements.length
                    );
                    if (
                      expect.flags.not &&
                      values.some((value) => equal(subjectElement, value))
                    ) {
                      this.sp().annotationBlock(function () {
                        this.error('should be removed');
                      });
                    }
                  })
                  .nl();
              });
              if (!expect.flags.not) {
                values.forEach((value) => {
                  if (
                    !subject.has(value) &&
                    !subjectElements.some((element) => equal(element, value))
                  ) {
                    output
                      .i()
                      .block(function () {
                        this.annotationBlock(function () {
                          this.error('missing').sp().appendInspected(value);
                        });
                      })
                      .nl();
                  }
                });
              }

              output.outdentLines();
              expect.subjectType.suffix(output, subject);

              return output;
            },
          });
        }
      );
    }
  );

  expect.addAssertion('<Set> [not] to be empty', (expect, subject) => {
    expect(subject.size, '[not] to equal', 0);
  });

  expect.addAssertion(
    [
      '<Set> to have items [exhaustively] satisfying <any>',
      '<Set> to have items [exhaustively] satisfying <assertion>',
    ],
    (expect, subject, nextArg) => {
      expect.errorMode = 'nested';
      expect(subject, 'not to be empty');
      expect.errorMode = 'bubble';

      const subjectElements = [];
      subject.forEach((element) => {
        subjectElements.push(element);
      });

      const expected = [];
      subjectElements.forEach((subjectElement) => {
        if (typeof nextArg === 'string') {
          expected.push(expect.it((s) => expect.shift(s, 0)));
        } else {
          expected.push(nextArg);
        }
      });

      return expect.withError(
        () => expect(subjectElements, 'to [exhaustively] satisfy', expected),
        (err) => {
          expect.fail({
            message(output) {
              output.append(
                expect.standardErrorMessage(output.clone(), { compact: true })
              );
            },
            diff(output) {
              output.inline = true;
              return output
                .jsKeyword('new')
                .sp()
                .jsKeyword('Set')
                .text('(')
                .append(err.getDiff({ output }))
                .text(')');
            },
          });
        }
      );
    }
  );

  expect.addAssertion(
    [
      '<Set> to have an item [exhaustively] satisfying <any>',
      '<Set> to have an item [exhaustively] satisfying <assertion>',
    ],
    (expect, subject, nextArg) => {
      expect.errorMode = 'nested';
      expect(subject, 'not to be empty');
      expect.errorMode = 'bubble';

      const subjectElements = [];
      subject.forEach((element) => {
        subjectElements.push(element);
      });

      const expected =
        typeof nextArg === 'string'
          ? expect.it((s) => expect.shift(s, 0))
          : nextArg;
      const expectedType = expect.findTypeOf(expected);
      const results = new Array(subjectElements.length);
      subjectElements.forEach((subjectElement, subjectIndex) => {
        results[subjectIndex] = expect.promise(() => {
          if (expectedType.is('expect.it')) {
            expect.context.thisObject = subject;
            return expected(subjectElement, expect.context);
          } else {
            return expect(subjectElement, 'to [exhaustively] satisfy', nextArg);
          }
        });
      });

      return expect.promise.settle(results).then(function () {
        if (results.every((result) => !result.isFulfilled())) {
          expect.fail({
            message(output) {
              output.append(
                expect.standardErrorMessage(output.clone(), { compact: true })
              );
            },
            diff(output, diff, inspect, equal) {
              output.inline = true;
              const prefixOutput = expect.subjectType.prefix(
                output.clone(),
                subject
              );
              const suffixOutput = expect.subjectType.suffix(
                output.clone(),
                subject
              );

              output.append(prefixOutput);
              if (!prefixOutput.isEmpty()) {
                output.nl();
              }
              if (expect.subjectType.indent) {
                output.indentLines();
              }

              let index = 0;
              subjectElements.forEach((subjectElement, subjectIndex) => {
                output.omitSubject = subject;
                output
                  .nl(index > 0 ? 1 : 0)
                  .i()
                  .block(function () {
                    const delimiterOutput = expect.subjectType.delimiter(
                      output.clone(),
                      subjectIndex,
                      subjectElements.length
                    );

                    const err = results[subjectIndex].reason();
                    const diff = err.getDiff({ output: output.clone() });

                    if (diff && diff.inline) {
                      this.append(diff).amend(delimiterOutput);
                    } else {
                      this.appendInspected(subjectElement)
                        .amend(delimiterOutput)
                        .sp()
                        .annotationBlock(function () {
                          this.omitSubject = subjectElement;
                          this.appendErrorMessage(err);
                        });
                    }
                  });
                index += 1;
              });

              if (expect.subjectType.indent) {
                output.outdentLines();
              }
              if (!suffixOutput.isEmpty()) {
                output.nl();
              }
              output.append(suffixOutput);

              return output;
            },
          });
        }
      });
    }
  );

  expect.addAssertion(
    '<Set> to [exhaustively] satisfy <Set>',
    (expect, subject, value) => {
      const subjectElements = [];
      subject.forEach((element) => {
        subjectElements.push(element);
      });
      const valueElements = [];
      value.forEach((element) => {
        valueElements.push(element);
      });

      const promiseBySubjectIndexAndValueIndex = subjectElements.map(
        () => new Array(valueElements.length)
      );

      const promiseByValueIndexAndSubjectIndex = valueElements.map(
        (valueElement, valueIndex) =>
          subjectElements.map((subjectElement, subjectIndex) => {
            const promise = expect.promise(() => {
              const valueElementType = expect.findTypeOf(valueElement);
              if (valueElementType.is('function')) {
                return valueElement(subjectElement);
              } else {
                return expect(
                  subjectElement,
                  'to [exhaustively] satisfy',
                  valueElement
                );
              }
            });
            promiseBySubjectIndexAndValueIndex[subjectIndex][valueIndex] =
              promise;
            return promise;
          })
      );

      return expect.promise
        .settle(promiseByValueIndexAndSubjectIndex)
        .then(() => {
          if (
            !promiseByValueIndexAndSubjectIndex.every((row) =>
              row.some((promise) => promise.isFulfilled())
            ) ||
            !subjectElements.every((subjectElement, i) =>
              promiseByValueIndexAndSubjectIndex.some((row) =>
                row[i].isFulfilled()
              )
            )
          ) {
            expect.fail({
              diff(output, diff, inspect, equal) {
                output.inline = true;
                const prefixOutput = expect.subjectType.prefix(
                  output.clone(),
                  subject
                );
                const suffixOutput = expect.subjectType.suffix(
                  output.clone(),
                  subject
                );

                output.append(prefixOutput);
                if (!prefixOutput.isEmpty()) {
                  output.nl();
                }
                if (expect.subjectType.indent) {
                  output.indentLines();
                }

                let index = 0;
                subjectElements.forEach((subjectElement, subjectIndex) => {
                  output
                    .nl(index > 0 ? 1 : 0)
                    .i()
                    .block(function () {
                      this.appendInspected(subjectElement);
                      expect.subjectType.delimiter(
                        this,
                        subjectIndex,
                        subjectElements.length
                      );
                      if (
                        !promiseBySubjectIndexAndValueIndex[subjectIndex].some(
                          (promise, valueIndex) =>
                            promiseBySubjectIndexAndValueIndex[subjectIndex][
                              valueIndex
                            ].isFulfilled()
                        )
                      ) {
                        this.sp().annotationBlock(function () {
                          this.error('should be removed');
                        });
                      }
                    });
                  index += 1;
                });
                valueElements.forEach((valueElement, valueIndex) => {
                  if (
                    promiseByValueIndexAndSubjectIndex[valueIndex].every(
                      (promise) => promise.isRejected()
                    )
                  ) {
                    output
                      .nl(index > 0 ? 1 : 0)
                      .i()
                      .annotationBlock(function () {
                        if (expect.findTypeOf(valueElement).is('function')) {
                          this.omitSubject = subjectElements[0];
                          this.error('missing:')
                            .sp()
                            .appendErrorMessage(
                              promiseByValueIndexAndSubjectIndex[
                                valueIndex
                              ][0].reason()
                            );
                        } else {
                          this.error('missing')
                            .sp()
                            .appendInspected(valueElement);
                        }
                      });
                    index += 1;
                  }
                });

                if (expect.subjectType.indent) {
                  output.outdentLines();
                }
                if (!suffixOutput.isEmpty()) {
                  output.nl();
                }
                output.append(suffixOutput);

                return output;
              },
            });
          }
        });
    }
  );

  expect.addAssertion(
    '<Set> [not] to have size <number>',
    (expect, subject, value) => {
      expect(subject.size, '[not] to equal', value);
    }
  );
};

unexpectedjs / unexpected / 2229357644

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous