@serenity-js/assertions 3.0.0-rc.2 → 3.0.0-rc.22

package/src/expectations/and.ts

@@ -1,29 +1,30 @@
-import { AnswersQuestions, Expectation, ExpectationNotMet, ExpectationOutcome } from '@serenity-js/core';
+import { Answerable, AnswersQuestions, Expectation, ExpectationNotMet } from '@serenity-js/core';
 import { match } from 'tiny-types';
 
-export function and<Actual>(...expectations: Array<Expectation<any, Actual>>): Expectation<any, Actual> {
+export function and<Actual>(...expectations: Array<Expectation<Actual>>): Expectation<Actual> {
     return new And(expectations);
 }
 
 /**
  * @package
  */
-class And<Actual> extends Expectation<any, Actual> {
-    constructor(private readonly expectations: Array<Expectation<any, Actual>>) {
-        super(expectations.map(assertion => assertion.toString()).join(' and '));
-    }
-
-    answeredBy(actor: AnswersQuestions): (actual: Actual) => Promise<ExpectationOutcome<any, Actual>> {
+class And<Actual> extends Expectation<Actual> {
+    private static readonly Separator = ' and ';
 
-        return (actual: any) =>
-            this.expectations.reduce(
-                (previous, current) =>
-                    previous.then(outcome =>
-                        match(outcome)
-                            .when(ExpectationNotMet, o => o)
-                            .else(_ => current.answeredBy(actor)(actual)),
-                    ),
-                Promise.resolve(void 0),
-            );
+    constructor(private readonly expectations: Array<Expectation<Actual>>) {
+        super(
+            expectations.map(expectation => expectation.toString()).join(And.Separator),
+            (actor: AnswersQuestions, actual: Answerable<Actual>) => {
+                return expectations.reduce(
+                    (previous, current) =>
+                        previous.then(outcome =>
+                            match(outcome)
+                                .when(ExpectationNotMet, o => o)
+                                .else(_ => actor.answer(current.isMetFor(actual))),
+                        ),
+                    Promise.resolve(void 0),
+                );
+            }
+        );
     }
 }

package/src/expectations/contain.ts

@@ -1,7 +1,7 @@
 import { Answerable, Expectation } from '@serenity-js/core';
 import { equal } from 'tiny-types/lib/objects';
 
-export function contain<Item>(expected: Answerable<Item>): Expectation<Item, Item[]> {
+export function contain<Item>(expected: Answerable<Item>): Expectation<Item[]> {
     return Expectation.thatActualShould<Item, Item[]>('contain', expected)
         .soThat((actualValue, expectedValue) => !! ~ actualValue.findIndex(av => equal(av, expectedValue)));
 }

package/src/expectations/containAtLeastOneItemThat.ts

@@ -1,26 +1,50 @@
-import { AnswersQuestions, Expectation, ExpectationMet, ExpectationNotMet, ExpectationOutcome } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
+import { Answerable, AnswersQuestions, d, Expectation, ExpectationMet, ExpectationNotMet, ExpectationOutcome } from '@serenity-js/core';
 
-export function containAtLeastOneItemThat<Actual>(expectation: Expectation<any, Actual>): Expectation<any, Actual[]> {
+export function containAtLeastOneItemThat<Actual>(expectation: Expectation<Actual>): Expectation<Actual[]> {
     return new ContainAtLeastOneItemThatMeetsExpectation(expectation);
 }
 
 /**
  * @package
  */
-class ContainAtLeastOneItemThatMeetsExpectation<Expected, Actual> extends Expectation<Expected, Actual[]> {
-    constructor(private readonly expectation: Expectation<Expected, Actual>) {
-        super(formatted `contain at least one item that does ${ expectation }`);
+class ContainAtLeastOneItemThatMeetsExpectation<Actual> extends Expectation<Actual[]> {
+
+    private static descriptionFor(expectation: Expectation<any>) {
+        return d`contain at least one item that does ${ expectation }`;
     }
 
-    answeredBy(actor: AnswersQuestions): (actual: Actual[]) => Promise<ExpectationOutcome<Expected, Actual[]>> {
-        return (actual: Actual[]) =>
-            actual.length === 0
-                ? Promise.resolve(new ExpectationNotMet(this.toString(), undefined, actual))
-                : Promise.all(actual.map(item => this.expectation.answeredBy(actor)(item)))
-                    .then(results => results.some(result => result instanceof ExpectationMet)
-                        ? new ExpectationMet(this.toString(), results[0].expected, actual)
-                        : new ExpectationNotMet(this.toString(), results[0].expected, actual),
+    constructor(private readonly expectation: Expectation<Actual>) {
+        super(
+            ContainAtLeastOneItemThatMeetsExpectation.descriptionFor(expectation),
+            async (actor: AnswersQuestions, actual: Answerable<Actual[]>) => {
+
+                const items: Actual[] = await actor.answer(actual);
+
+                if (! items || items.length === 0) {
+                    return new ExpectationNotMet(
+                        ContainAtLeastOneItemThatMeetsExpectation.descriptionFor(expectation),
+                        undefined,
+                        items,
                     );
+                }
+
+                let outcome: ExpectationOutcome<unknown, Actual>;
+
+                for (const item of items) {
+
+                    outcome = await actor.answer(expectation.isMetFor(item))
+
+                    if (outcome instanceof ExpectationMet) {
+                        return new ExpectationMet(
+                            ContainAtLeastOneItemThatMeetsExpectation.descriptionFor(expectation),
+                            outcome.expected,
+                            items
+                        );
+                    }
+                }
+
+                return new ExpectationNotMet(ContainAtLeastOneItemThatMeetsExpectation.descriptionFor(expectation), outcome.expected, items);
+            }
+        );
     }
 }

package/src/expectations/containItemsWhereEachItem.ts

@@ -1,26 +1,50 @@
-import { AnswersQuestions, Expectation, ExpectationMet, ExpectationNotMet, ExpectationOutcome } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
+import { Answerable, AnswersQuestions, d, Expectation, ExpectationMet, ExpectationNotMet, ExpectationOutcome } from '@serenity-js/core';
 
-export function containItemsWhereEachItem<Actual>(expectation: Expectation<any, Actual>): Expectation<any, Actual[]> {
+export function containItemsWhereEachItem<Actual>(expectation: Expectation<Actual>): Expectation<Actual[]> {
     return new ContainItemsWhereEachItemMeetsExpectation(expectation);
 }
 
 /**
  * @package
  */
-class ContainItemsWhereEachItemMeetsExpectation<Expected, Actual> extends Expectation<Expected, Actual[]> {
-    constructor(private readonly expectation: Expectation<Expected, Actual>) {
-        super(formatted `contain items where each item does ${ expectation }`);
+class ContainItemsWhereEachItemMeetsExpectation<Actual> extends Expectation<Actual[]> {
+
+    private static descriptionFor(expectation: Expectation<any>) {
+        return d`contain items where each item does ${ expectation }`;
     }
 
-    answeredBy(actor: AnswersQuestions): (actual: Actual[]) => Promise<ExpectationOutcome<Expected, Actual[]>> {
-        return (actual: Actual[]) =>
-            actual.length === 0
-                ? Promise.resolve(new ExpectationNotMet(this.toString(), undefined, actual))
-                : Promise.all(actual.map(item => this.expectation.answeredBy(actor)(item)))
-                    .then(results => results.every(result => result instanceof ExpectationMet)
-                        ? new ExpectationMet(this.toString(), results[0].expected, actual)
-                        : new ExpectationNotMet(this.toString(), results[0].expected, actual),
+    constructor(private readonly expectation: Expectation<Actual>) {
+        super(
+            ContainItemsWhereEachItemMeetsExpectation.descriptionFor(expectation),
+            async (actor: AnswersQuestions, actual: Answerable<Actual[]>) => {
+
+                const items: Actual[] = await actor.answer(actual);
+
+                if (! items || items.length === 0) {
+                    return new ExpectationNotMet(
+                        ContainItemsWhereEachItemMeetsExpectation.descriptionFor(expectation),
+                        undefined,
+                        items,
                     );
+                }
+
+                let outcome: ExpectationOutcome<unknown, Actual>;
+
+                for (const item of items) {
+
+                    outcome = await actor.answer(expectation.isMetFor(item))
+
+                    if (outcome instanceof ExpectationNotMet) {
+                        return new ExpectationNotMet(
+                            ContainItemsWhereEachItemMeetsExpectation.descriptionFor(expectation),
+                            outcome.expected,
+                            items
+                        );
+                    }
+                }
+
+                return new ExpectationMet(ContainItemsWhereEachItemMeetsExpectation.descriptionFor(expectation), outcome.expected, items);
+            }
+        );
     }
 }

package/src/expectations/index.ts

@@ -7,12 +7,13 @@ export * from './equals';
 export * from './includes';
 export * from './isAfter';
 export * from './isBefore';
+export * from './isCloseTo';
 export * from './isFalse';
 export * from './isGreaterThan';
 export * from './isLessThan';
+export * from './isPresent';
 export * from './isTrue';
 export * from './matches';
 export * from './not';
 export * from './or';
-export * from './property';
 export * from './startsWith';

package/src/expectations/isCloseTo.ts

@@ -0,0 +1,60 @@
+import { Answerable, AnswersQuestions, d, Expectation, ExpectationMet, ExpectationNotMet } from '@serenity-js/core';
+
+/**
+ * @desc
+ *  Expectation that the actual value is within a given ± absolute tolerance range of the expected value.
+ *
+ * @example
+ *  import { actorCalled } from '@serenity-js/core'
+ *  import { Ensure, isCloseTo } from '@serenity-js/assertions'
+ *
+ *  await actorCalled('Iris').attemptsTo(
+ *      Ensure.that(10.123, isCloseTo(10, 0.2))
+ *  )
+ *
+ * @param {Answerable<number>} expected
+ * @param {Answerable<number>} [absoluteTolerance=1e-9]
+ */
+export function isCloseTo(expected: Answerable<number>, absoluteTolerance: Answerable<number> = 1e-9): Expectation<number> {
+    return new IsCloseTo(expected, absoluteTolerance);
+}
+
+/**
+ * @package
+ */
+class IsCloseTo extends Expectation<number> {
+
+    constructor(
+        private readonly expected: Answerable<number>,
+        private readonly absoluteTolerance: Answerable<number>,
+    ) {
+        super(
+            d`have value close to ${ expected } ±${ absoluteTolerance }`,
+            async (actor: AnswersQuestions, actual: Answerable<number>) => {
+
+                const actualValue: number   = await actor.answer(actual);
+                const expectedValue: number = await actor.answer(this.expected);
+                const tolerance: number     = await actor.answer(this.absoluteTolerance);
+
+                const description = `have value close to ${ expectedValue } ±${ tolerance }`
+
+                // short-circuit exact equality
+                if (actualValue === expectedValue) {
+                    return new ExpectationMet(description, expectedValue, actualValue);
+                }
+
+                if (! (Number.isFinite(actualValue) && Number.isFinite(expectedValue))) {
+                    return new ExpectationNotMet(description, expectedValue, actualValue);
+                }
+
+                const difference = Math.abs(actualValue - expectedValue)
+
+                const isClose = difference <= tolerance;
+
+                return isClose
+                    ? new ExpectationMet(description, expectedValue, actualValue)
+                    : new ExpectationNotMet(description, expectedValue, actualValue);
+            }
+        );
+    }
+}

package/src/expectations/isFalse.ts

@@ -3,5 +3,5 @@ import { Expectation } from '@serenity-js/core';
 import { equals } from './equals';
 
 export function isFalse(): Expectation<boolean> {
-    return Expectation.to<boolean>(`equal false`).soThatActual(equals(false));
+    return Expectation.to<never, boolean>(`equal false`).soThatActual(equals(false));
 }

package/src/expectations/isPresent.ts

@@ -0,0 +1,58 @@
+import { Answerable, AnswersQuestions, Expectation, ExpectationMet, ExpectationNotMet, Optional } from '@serenity-js/core';
+
+/**
+ * @desc
+ *  Expectation that the `actual` is not undefined or null.
+ *  Also, for `actual` implementing {@link @serenity-js/core/lib/screenplay~Optional}, that `Optional.isPresent()` returns an {@link @serenity-js/core/lib/screenplay~Answerable}
+ *  that resolves to `true`
+ *
+ * @returns {@serenity-js/core/lib/screenplay/questions~Expectation<Answerable<boolean>, Optional>}
+ *
+ * @see {@link @serenity-js/assertions~Ensure}
+ * @see {@link @serenity-js/core/lib/screenplay/questions~Check}
+ * @see {@link @serenity-js/core/lib/screenplay/interactions~Wait}
+ */
+export function isPresent<Actual>(): Expectation<Actual> {
+    return new IsPresent<Actual>();
+}
+
+class IsPresent<Actual> extends Expectation<Actual> {
+    private static isOptional(value: any): value is Optional {
+        return value !== undefined
+            && value !== null
+            && typeof value.isPresent === 'function';
+    }
+
+    private static valueToCheck<A>(actual: Answerable<A>, actor: AnswersQuestions): Answerable<A> {
+        if (IsPresent.isOptional(actual)) {
+            return actual;
+        }
+
+        return actor.answer(actual);
+    }
+
+    private static async isPresent<A>(value: Answerable<A>, actor: AnswersQuestions): Promise<boolean> {
+        if (IsPresent.isOptional(value)) {
+            return actor.answer(value.isPresent());
+        }
+
+        return value !== undefined
+            && value !== null;
+    }
+
+    constructor() {
+        super(
+            'become present',
+            async (actor: AnswersQuestions, actual: Answerable<Actual>) => {
+
+                const value = await IsPresent.valueToCheck(actual, actor);
+
+                const result = await IsPresent.isPresent(value, actor);
+
+                return result
+                    ? new ExpectationMet('become present', undefined, undefined)
+                    : new ExpectationNotMet('become present', undefined, undefined);
+            }
+        );
+    }
+}

package/src/expectations/isTrue.ts

@@ -3,5 +3,5 @@ import { Expectation } from '@serenity-js/core';
 import { equals } from './equals';
 
 export function isTrue(): Expectation<boolean> {
-    return Expectation.to<boolean>(`equal true`).soThatActual(equals(true));
+    return Expectation.to<never, boolean>(`equal true`).soThatActual(equals(true));
 }

package/src/expectations/matches.ts

@@ -1,6 +1,6 @@
 import { Answerable, Expectation } from '@serenity-js/core';
 
-export function matches(expected: Answerable<RegExp>): Expectation<RegExp, string> {
+export function matches(expected: Answerable<RegExp>): Expectation<string> {
     return Expectation.thatActualShould<RegExp, string>('match', expected)
         .soThat((actualValue, expectedValue) => expectedValue.test(actualValue));
 }

package/src/expectations/not.ts

@@ -1,31 +1,31 @@
-import { AnswersQuestions, Expectation, ExpectationMet, ExpectationNotMet, ExpectationOutcome } from '@serenity-js/core';
-import { match } from 'tiny-types';
+import { Answerable, AnswersQuestions, Expectation, ExpectationMet, ExpectationNotMet } from '@serenity-js/core';
 
-export function not<Expected, Actual>(assertion: Expectation<Expected, Actual>): Expectation<Expected, Actual> {
-    return new Not<Expected, Actual>(assertion);
+export function not<Actual>(assertion: Expectation<Actual>): Expectation<Actual> {
+    return new Not<Actual>(assertion);
 }
 
 /**
  * @package
  */
-class Not<Expected, Actual> extends Expectation<Expected, Actual> {
+class Not<Actual> extends Expectation<Actual> {
     private static flipped(message: string): string {
         return message.startsWith('not ')
             ? message.slice(4)
             : `not ${ message }`;
     }
 
-    constructor(private readonly expectation: Expectation<Expected, Actual>) {
-        super(Not.flipped(expectation.toString()));
-    }
+    constructor(private readonly expectation: Expectation<Actual>) {
+        super(
+            Not.flipped(expectation.toString()),
+            async (actor: AnswersQuestions, actual: Answerable<Actual>) => {
+                const subject = Not.flipped(expectation.toString());
 
-    answeredBy(actor: AnswersQuestions): (actual: Actual) => Promise<ExpectationOutcome<Expected, Actual>> {
+                const outcome = await actor.answer(expectation.isMetFor(actual));
 
-        return (actual: any) =>
-            this.expectation.answeredBy(actor)(actual)
-                .then((outcome: ExpectationOutcome<Expected, Actual>) =>
-                    match<ExpectationOutcome<Expected, Actual>, ExpectationOutcome<Expected, Actual>>(outcome)
-                        .when(ExpectationMet, o => new ExpectationNotMet(this.subject, o.expected, o.actual))
-                        .else(o => new ExpectationMet(this.subject, o.expected, o.actual)));
+                return outcome instanceof ExpectationNotMet
+                    ? new ExpectationMet(subject, outcome.expected, outcome.actual)
+                    : new ExpectationNotMet(subject, outcome.expected, outcome.actual);
+            }
+        );
     }
 }

package/src/expectations/or.ts

@@ -1,41 +1,44 @@
-import { AnswersQuestions, Expectation, ExpectationMet, ExpectationNotMet, ExpectationOutcome } from '@serenity-js/core';
+import { Answerable, AnswersQuestions, Expectation, ExpectationMet, ExpectationNotMet, ExpectationOutcome, LogicError } from '@serenity-js/core';
 
-export function or<Actual>(...assertions: Array<Expectation<any, Actual>>): Expectation<any, Actual> {
+export function or<Actual>(...assertions: Array<Expectation<Actual>>): Expectation<Actual> {
     return new Or(assertions);
 }
 
 /**
  * @package
  */
-class Or<Actual> extends Expectation<any, Actual> {
+class Or<Actual> extends Expectation<Actual> {
     private static readonly Separator = ' or ';
 
-    constructor(private readonly expectations: Array<Expectation<any, Actual>>) {
-        super(expectations
-            .map(assertion => assertion.toString())
-            .join(Or.Separator));
+    private static descriptionFor<A>(expectations: Array<Expectation<A>>): string {
+        return expectations
+            .map(expectation => expectation.toString())
+            .join(Or.Separator);
     }
 
-    answeredBy(actor: AnswersQuestions): (actual: Actual) => Promise<ExpectationOutcome<any, Actual>> {
+    constructor(private readonly expectations: Array<Expectation<Actual>>) {
+        super(
+            Or.descriptionFor(expectations),
+            async (actor: AnswersQuestions, actual: Answerable<Actual>) => {
+                if (! expectations || expectations.length === 0) {
+                    throw new LogicError(`No expectations provided to or()`);
+                }
 
-        return (actual: any) =>
-            this.expectations.reduce(
-                (previous, current) =>
-                    previous.then((outcomesSoFar: Array<ExpectationOutcome<any, Actual>>) =>
-                        current.answeredBy(actor)(actual)
-                            .then(outcome => outcomesSoFar.concat(outcome)),        // todo: should stop on the first met expectation
-                    ),
-                Promise.resolve([]),
-            ).
-            then((outcomes: Array<ExpectationOutcome<any, Actual>>) => {
+                let outcome: ExpectationOutcome<unknown, Actual>;
+                for (const expectation of expectations) {
+                    outcome = await actor.answer(expectation.isMetFor(actual));
 
-                const
-                    unmetExpectations = outcomes.filter(outcome => outcome instanceof ExpectationNotMet),
-                    message = outcomes.map(outcome => outcome.message).join(Or.Separator);
+                    if (outcome instanceof ExpectationMet) {
+                        return outcome;
+                    }
+                }
 
-                return unmetExpectations.length === this.expectations.length
-                    ? new ExpectationNotMet(message, outcomes[0].expected, outcomes[0].actual)
-                    : new ExpectationMet(message, outcomes[0].expected, outcomes[0].actual);
-            });
+                return new ExpectationNotMet(
+                    Or.descriptionFor(expectations),
+                    outcome.expected,
+                    outcome.actual,
+                );
+            }
+        );
     }
 }

package/lib/expectations/property.d.ts

@@ -1,2 +0,0 @@
-import { Expectation } from '@serenity-js/core';
-export declare function property<Actual, Property extends keyof Actual>(propertyName: Property, expectation: Expectation<any, Actual[Property]>): Expectation<Actual[Property], Actual>;

package/lib/expectations/property.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.property = void 0;
-const core_1 = require("@serenity-js/core");
-const io_1 = require("@serenity-js/core/lib/io");
-function property(propertyName, expectation) {
-    return new HasProperty(propertyName, expectation);
-}
-exports.property = property;
-/**
- * @package
- */
-class HasProperty extends core_1.Expectation {
-    constructor(propertyName, expectation) {
-        super((0, io_1.formatted) `have property ${propertyName} that does ${expectation}`);
-        this.propertyName = propertyName;
-        this.expectation = expectation;
-    }
-    answeredBy(actor) {
-        return (actual) => this.expectation.answeredBy(actor)(actual[this.propertyName])
-            .then((outcome) => {
-            return outcome instanceof core_1.ExpectationMet
-                ? new core_1.ExpectationMet(this.toString(), outcome.expected, actual[this.propertyName])
-                : new core_1.ExpectationNotMet(this.toString(), outcome.expected, actual[this.propertyName]);
-        });
-    }
-}
-//# sourceMappingURL=property.js.map

package/lib/expectations/property.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"property.js","sourceRoot":"","sources":["../../src/expectations/property.ts"],"names":[],"mappings":";;;AAAA,4CAAyH;AACzH,iDAAqD;AAErD,SAAgB,QAAQ,CACpB,YAAsB,EACtB,WAA+C;IAE/C,OAAO,IAAI,WAAW,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;AACtD,CAAC;AALD,4BAKC;AAED;;GAEG;AACH,MAAM,WAAmD,SAAQ,kBAAqC;IAClG,YACqB,YAAsB,EACtB,WAA+C;QAEhE,KAAK,CAAC,IAAA,cAAS,EAAC,iBAAkB,YAAa,cAAe,WAAY,EAAE,CAAC,CAAC;QAH7D,iBAAY,GAAZ,YAAY,CAAU;QACtB,gBAAW,GAAX,WAAW,CAAoC;IAGpE,CAAC;IAED,UAAU,CAAC,KAAuB;QAE9B,OAAO,CAAC,MAAc,EAAE,EAAE,CACtB,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;aACxD,IAAI,CAAC,CAAC,OAAkD,EAAE,EAAE;YAEzD,OAAO,OAAO,YAAY,qBAAc;gBACpC,CAAC,CAAC,IAAI,qBAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBAClF,CAAC,CAAC,IAAI,wBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;QAC9F,CAAC,CAAC,CAAC;IACf,CAAC;CACJ"}

package/src/expectations/property.ts

@@ -1,33 +0,0 @@
-import { AnswersQuestions, Expectation, ExpectationMet, ExpectationNotMet, ExpectationOutcome } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
-
-export function property<Actual, Property extends keyof Actual>(
-    propertyName: Property,
-    expectation: Expectation<any, Actual[Property]>,
-): Expectation<Actual[Property], Actual> {
-    return new HasProperty(propertyName, expectation);
-}
-
-/**
- * @package
- */
-class HasProperty<Property extends keyof Actual, Actual> extends Expectation<Actual[Property], Actual> {
-    constructor(
-        private readonly propertyName: Property,
-        private readonly expectation: Expectation<any, Actual[Property]>,
-    ) {
-        super(formatted `have property ${ propertyName } that does ${ expectation }`);
-    }
-
-    answeredBy(actor: AnswersQuestions): (actual: Actual) => Promise<ExpectationOutcome<Actual[Property], any>> {
-
-        return (actual: Actual) =>
-            this.expectation.answeredBy(actor)(actual[this.propertyName])
-                .then((outcome: ExpectationOutcome<any, Actual[Property]>) => {
-
-                    return outcome instanceof ExpectationMet
-                        ? new ExpectationMet(this.toString(), outcome.expected, actual[this.propertyName])
-                        : new ExpectationNotMet(this.toString(), outcome.expected, actual[this.propertyName]);
-                });
-    }
-}