How to use the @aurelia/testing.assert.instanceOf function in @aurelia/testing

it(`singleton registration is reused by the instance parent`, function () {
      @inject(ISingleton)
      class InstanceParent implements IInstanceParent { constructor(public dep: ISingleton) {} }
      register(InstanceParent);

      const actual1 = container.get(IInstanceParent);
      assert.instanceOf(actual1, InstanceParent, `actual1`);
      assert.instanceOf(actual1.dep, Singleton, `actual1.dep`);

      const actual2 = container.get(IInstanceParent);
      assert.instanceOf(actual2, InstanceParent, `actual2`);
      assert.instanceOf(actual2.dep, Singleton, `actual2.dep`);

      assert.strictEqual(actual1, actual2, `actual1`);

      assert.strictEqual(actual1.dep, actual2.dep, `actual1.dep`);

      assert.deepStrictEqual(
        get.calls,
        [
          [IInstanceParent],
          [IInstanceParent],
        ],
        `get.calls`,
      );
    });

it(_`getObserver() - Map.size - returns MapObserver`, function () {
    const { sut } = setup();
    const obj = new Map();
    const actual = sut.getObserver(LF.none, obj, 'size');
    assert.strictEqual(actual.constructor.name, CollectionSizeObserver.name, `actual.constructor.name`);
    assert.instanceOf(actual, CollectionSizeObserver, `actual`);
  });

it(`should define the binding behavior`, function () {
    assert.strictEqual(FooBindingBehavior['kind'], BindingBehavior, `FooBindingBehavior['kind']`);
    assert.strictEqual(FooBindingBehavior['description'].name, 'foo', `FooBindingBehavior['description'].name`);
    FooBindingBehavior['register'](container);
    const instance = container.get(BindingBehavior.keyFrom('foo'));
    assert.instanceOf(instance, FooBindingBehavior, `instance`);
  });

it(`InterfaceSymbol alias to transient registration returns a new instance each time`, function () {
      interface IAlias {}
      const IAlias = DI.createInterface('IAlias').withDefault(x => x.aliasTo(ITransient));

      const actual1 = container.get(IAlias);
      assert.instanceOf(actual1, Transient, `actual1`);

      const actual2 = container.get(IAlias);
      assert.instanceOf(actual2, Transient, `actual2`);

      assert.notStrictEqual(actual1, actual2, `actual1`);

      assert.deepStrictEqual(
        get.calls,
        [
          [IAlias],
          [ITransient],
          [IAlias],
          [ITransient],
        ],
        `get.calls`,
      );
    });

it(`works as a plain decorator`, function () {
    @singleton
    class Foo {}

    assert.instanceOf(Foo['register'], Function, `Foo['register']`);

    const container = DI.createContainer();

    const foo1 = container.get(Foo);
    const foo2 = container.get(Foo);

    assert.strictEqual(foo1, foo2, `foo1`);
  });

it(`hasSlots=true yields ShadowDOMProjector`, function () {
    const host = ctx.createElement('div');
    const Foo = CustomElement.define(
      {
        name: 'foo',
        hasSlots: true
      },
      class {}
    );
    const definition = CustomElement.getDefinition(Foo);
    const component = new Foo();
    const controller = Controller.forCustomElement(component, ctx.container, host);
    const projector = locator.getElementProjector(dom, controller, host, definition);

    assert.instanceOf(projector, ShadowDOMProjector, `projector`);
    assert.instanceOf(projector['shadowRoot'], ctx.Node, `projector['shadowRoot']`);
    assert.strictEqual(CustomElement.for(projector['shadowRoot']), component, `CustomElement.for(projector['shadowRoot'])`);
    assert.strictEqual(CustomElement.for(host), component, `CustomElement.for(host)`);
    assert.strictEqual(projector.children.length, projector['shadowRoot']['childNodes'].length, `projector.children.length`);
    if (projector.children.length > 0) {
      assert.deepStrictEqual(projector.children, projector['shadowRoot']['childNodes'], `projector.children`);
    }
    assert.strictEqual(projector.provideEncapsulationSource(), projector['shadowRoot'], `projector.provideEncapsulationSource()`);
  });

const [required, equalRule, ...rangeRules] = validationRules as [RequiredRule, EqualsRule, RangeRule, RangeRule, RangeRule, RangeRule];

    assert.instanceOf(required, RequiredRule);
    assert.instanceOf(equalRule, EqualsRule);
    assert.equal(equalRule['expectedValue'], 40);

    const expected = [
      [2, Number.POSITIVE_INFINITY, true],
      [Number.NEGATIVE_INFINITY, 42, true],
      [3, 41, true],
      [4, 40, false],
    ];
    for (let i = 0, ii = expected.length; i < ii; i++) {
      const [min, max, isInclusive] = expected[i];
      const rule = rangeRules[i];
      assert.instanceOf(rule, RangeRule);
      assert.equal(rule['min'], min);
      assert.equal(rule['max'], max);
      assert.equal(rule['isInclusive'], isInclusive);
    }
  });

.required()

      .ensure('age')
      .range(24, 42)

      .ensure('name')
      .matches(/foo/)

      .rules;

    assert.equal(rules.length, 2);
    const [rule1, rule2] = rules;
    assert.instanceOf(rule1, PropertyRule);
    assert.equal((rule1 as PropertyRule).property.name, 'name');
    assert.instanceOf(rule1.$rules[0][0], RequiredRule, 'exprected required rule');
    assert.instanceOf(rule1.$rules[0][1], RegexRule, 'exprected regex rule');

    assert.instanceOf(rule2, PropertyRule);
    assert.equal((rule2 as PropertyRule).property.name, 'age');
    assert.instanceOf(rule2.$rules[0][0], RangeRule, 'expected range rule');
  });

assert.instanceOf(minLength, LengthRule);
    assert.equal(minLength['isMax'], false);
    assert.equal(minLength['length'], 2);

    assert.instanceOf(maxLength, LengthRule);
    assert.equal(maxLength['isMax'], true);
    assert.equal(maxLength['length'], 42);

    assert.instanceOf(matches, RegexRule);
    assert.equal(matches['pattern'].source, 'foo');

    assert.equal(phase2Rules.length, 2);
    const [emailRule, equalRule] = phase2Rules as [RegexRule, EqualsRule];

    assert.instanceOf(emailRule, RegexRule);
    assert.notEqual(emailRule['pattern'], void 0);
    assert.equal(emailRule.canExecute(void 0), false);

    assert.instanceOf(equalRule, EqualsRule);
    assert.equal(equalRule['expectedValue'], 'foo@bar.com');
  });

ctx,
                      wrapper,
                      parentEl,
                      childEl,
                      parentSubscription,
                      childSubscription,
                      parentHandlerPath,
                      childHandlerPath,
                      event
                    } = createFixture(eventName, listenerObj, bubbles, stopPropagation, returnValue, strategy, shadow);

                    switch (strategy) {
                      case DelegationStrategy.bubbling:
                      case DelegationStrategy.capturing:
                        assert.instanceOf(parentSubscription, DelegateOrCaptureSubscription, `parentSubscription`);
                        assert.instanceOf(childSubscription, DelegateOrCaptureSubscription, `childSubscription`);
                        break;
                      case DelegationStrategy.none:
                        assert.instanceOf(parentSubscription, TriggerSubscription, `parentSubscription`);
                        assert.instanceOf(childSubscription, TriggerSubscription, `childSubscription`);
                    }

                    childEl.dispatchEvent(event);

                    switch (strategy) {
                      case DelegationStrategy.bubbling:
                        if (bubbles && shadow == null) {
                          assert.strictEqual(childHandlerPath.length, 1, 'childHandlerPath.length');
                          assert.strictEqual(childHandlerPath[0].eventPhase, BUBBLING_PHASE, 'eventPhase');
                          assert.strictEqual(childHandlerPath[0].target.nodeName, 'CHILD-DIV', `childHandlerPath[0].target.nodeName`);
                          assert.strictEqual(childHandlerPath[0].currentTarget, ctx.doc, `childHandlerPath[0].currentTarget`);
                          if (stopPropagation) {