@goast/kotlin 0.4.2 → 0.4.3

package/src/deps/jsr.io/@std/expect/{1.0.6/_assertion.ts → 1.0.7/_assertions.ts}

@@ -1,6 +1,6 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-import { getAssertionState } from "../../internal/1.0.4/assertion_state.js";
+import { getAssertionState } from "../../internal/1.0.5/assertion_state.js";
 
 const assertionState = getAssertionState();
 
@@ -8,6 +8,11 @@ export function hasAssertions() {
   assertionState.setAssertionCheck(true);
 }
 
+export function assertions(num: number) {
+  assertionState.setAssertionCount(num);
+}
+
 export function emitAssertionTrigger() {
   assertionState.setAssertionTriggered(true);
+  assertionState.updateAssertionTriggerCount();
 }

package/src/deps/jsr.io/@std/expect/{1.0.6 → 1.0.7}/_asymmetric_matchers.ts

@@ -6,6 +6,7 @@ import { equal } from "./_equal.js";
 export abstract class AsymmetricMatcher<T> {
   constructor(
     protected value: T,
+    protected inverse: boolean = false,
   ) {}
   abstract equals(other: unknown): boolean;
 }
@@ -69,12 +70,14 @@ export function any(c: unknown): Any {
 }
 
 export class ArrayContaining extends AsymmetricMatcher<any[]> {
-  constructor(arr: any[]) {
-    super(arr);
+  constructor(arr: any[], inverse = false) {
+    super(arr, inverse);
   }
 
   equals(other: any[]): boolean {
-    return Array.isArray(other) && this.value.every((e) => other.includes(e));
+    const res = Array.isArray(other) &&
+      this.value.every((e) => other.includes(e));
+    return this.inverse ? !res : res;
   }
 }
 
@@ -82,6 +85,10 @@ export function arrayContaining(c: any[]): ArrayContaining {
   return new ArrayContaining(c);
 }
 
+export function arrayNotContaining(c: any[]): ArrayContaining {
+  return new ArrayContaining(c, true);
+}
+
 export class CloseTo extends AsymmetricMatcher<number> {
   readonly #precision: number;
 
@@ -113,16 +120,13 @@ export function closeTo(num: number, numDigits?: number): CloseTo {
 }
 
 export class StringContaining extends AsymmetricMatcher<string> {
-  constructor(str: string) {
-    super(str);
+  constructor(str: string, inverse = false) {
+    super(str, inverse);
   }
 
   equals(other: string): boolean {
-    if (typeof other !== "string") {
-      return false;
-    }
-
-    return other.includes(this.value);
+    const res = typeof other !== "string" ? false : other.includes(this.value);
+    return this.inverse ? !res : res;
   }
 }
 
@@ -130,17 +134,18 @@ export function stringContaining(str: string): StringContaining {
   return new StringContaining(str);
 }
 
+export function stringNotContaining(str: string): StringContaining {
+  return new StringContaining(str, true);
+}
+
 export class StringMatching extends AsymmetricMatcher<RegExp> {
-  constructor(pattern: string | RegExp) {
-    super(new RegExp(pattern));
+  constructor(pattern: string | RegExp, inverse = false) {
+    super(new RegExp(pattern), inverse);
   }
 
   equals(other: string): boolean {
-    if (typeof other !== "string") {
-      return false;
-    }
-
-    return this.value.test(other);
+    const res = typeof other !== "string" ? false : this.value.test(other);
+    return this.inverse ? !res : res;
   }
 }
 
@@ -148,25 +153,30 @@ export function stringMatching(pattern: string | RegExp): StringMatching {
   return new StringMatching(pattern);
 }
 
+export function stringNotMatching(pattern: string | RegExp): StringMatching {
+  return new StringMatching(pattern, true);
+}
+
 export class ObjectContaining
   extends AsymmetricMatcher<Record<string, unknown>> {
-  constructor(obj: Record<string, unknown>) {
-    super(obj);
+  constructor(obj: Record<string, unknown>, inverse = false) {
+    super(obj, inverse);
   }
 
   equals(other: Record<string, unknown>): boolean {
     const keys = Object.keys(this.value);
+    let res = true;
 
     for (const key of keys) {
       if (
         !Object.hasOwn(other, key) ||
         !equal(this.value[key], other[key])
       ) {
-        return false;
+        res = false;
       }
     }
 
-    return true;
+    return this.inverse ? !res : res;
   }
 }
 
@@ -175,3 +185,9 @@ export function objectContaining(
 ): ObjectContaining {
   return new ObjectContaining(obj);
 }
+
+export function objectNotContaining(
+  obj: Record<string, unknown>,
+): ObjectContaining {
+  return new ObjectContaining(obj, true);
+}

package/src/deps/jsr.io/@std/expect/{1.0.6 → 1.0.7}/_build_message.ts

@@ -1,9 +1,9 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-import { buildMessage } from "../../internal/1.0.4/build_message.js";
-import { diff } from "../../internal/1.0.4/diff.js";
-import { diffStr } from "../../internal/1.0.4/diff_str.js";
-import { format } from "../../internal/1.0.4/format.js";
+import { buildMessage } from "../../internal/1.0.5/build_message.js";
+import { diff } from "../../internal/1.0.5/diff.js";
+import { diffStr } from "../../internal/1.0.5/diff_str.js";
+import { format } from "../../internal/1.0.5/format.js";
 import type { EqualOptions } from "./_types.js";
 
 type EqualErrorMessageOptions = Pick<

package/src/deps/jsr.io/@std/expect/{1.0.6 → 1.0.7}/_equal.ts

@@ -44,6 +44,11 @@ export function equal(c: unknown, d: unknown, options?: EqualOptions): boolean {
   const seen = new Map();
 
   return (function compare(a: unknown, b: unknown): boolean {
+    const asymmetric = asymmetricEqual(a, b);
+    if (asymmetric !== undefined) {
+      return asymmetric;
+    }
+
     if (customTesters?.length) {
       for (const customTester of customTesters) {
         const testContext = {
@@ -67,11 +72,6 @@ export function equal(c: unknown, d: unknown, options?: EqualOptions): boolean {
       return String(a) === String(b);
     }
 
-    const asymmetric = asymmetricEqual(a, b);
-    if (asymmetric !== undefined) {
-      return asymmetric;
-    }
-
     if (a instanceof Date && b instanceof Date) {
       const aTime = a.getTime();
       const bTime = b.getTime();
@@ -119,6 +119,10 @@ export function equal(c: unknown, d: unknown, options?: EqualOptions): boolean {
       let aLen = aKeys.length;
       let bLen = bKeys.length;
 
+      if (strictCheck && aLen !== bLen) {
+        return false;
+      }
+
       if (!strictCheck) {
         if (aLen > 0) {
           for (let i = 0; i < aKeys.length; i += 1) {
@@ -145,9 +149,6 @@ export function equal(c: unknown, d: unknown, options?: EqualOptions): boolean {
         }
       }
 
-      if (aLen !== bLen) {
-        return false;
-      }
       seen.set(a, b);
       if (isKeyedCollection(a) && isKeyedCollection(b)) {
         if (a.size !== b.size) {

package/src/deps/jsr.io/@std/expect/{1.0.6 → 1.0.7}/_matchers.ts

@@ -1,23 +1,26 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-import { assertNotStrictEquals } from "../../assert/1.0.6/not_strict_equals.js";
-import { assertStrictEquals } from "../../assert/1.0.6/strict_equals.js";
-import { assertInstanceOf } from "../../assert/1.0.6/instance_of.js";
-import { assertIsError } from "../../assert/1.0.6/is_error.js";
-import { assertNotInstanceOf } from "../../assert/1.0.6/not_instance_of.js";
-import { assertMatch } from "../../assert/1.0.6/match.js";
-import { assertObjectMatch } from "../../assert/1.0.6/object_match.js";
-import { assertNotMatch } from "../../assert/1.0.6/not_match.js";
-import { AssertionError } from "../../assert/1.0.6/assertion_error.js";
+import { assertNotStrictEquals } from "../../assert/1.0.7/not_strict_equals.js";
+import { assertStrictEquals } from "../../assert/1.0.7/strict_equals.js";
+import { assertInstanceOf } from "../../assert/1.0.7/instance_of.js";
+import { assertIsError } from "../../assert/1.0.7/is_error.js";
+import { assertNotInstanceOf } from "../../assert/1.0.7/not_instance_of.js";
+import { assertMatch } from "../../assert/1.0.7/match.js";
+import { assertNotMatch } from "../../assert/1.0.7/not_match.js";
+import { AssertionError } from "../../assert/1.0.7/assertion_error.js";
 
 import { assertEquals } from "./_assert_equals.js";
 import { assertNotEquals } from "./_assert_not_equals.js";
 import { equal } from "./_equal.js";
-import { format } from "../../internal/1.0.4/format.js";
+import { format } from "../../internal/1.0.5/format.js";
 import type { AnyConstructor, MatcherContext, MatchResult } from "./_types.js";
 import { getMockCalls } from "./_mock_util.js";
 import { inspectArg, inspectArgs } from "./_inspect_args.js";
-import { buildEqualOptions, iterableEquality } from "./_utils.js";
+import {
+  buildEqualOptions,
+  iterableEquality,
+  subsetEquality,
+} from "./_utils.js";
 
 export function toBe(context: MatcherContext, expect: unknown): MatchResult {
   if (context.isNot) {
@@ -462,34 +465,35 @@ export function toMatchObject(
   context: MatcherContext,
   expected: Record<PropertyKey, unknown> | Record<PropertyKey, unknown>[],
 ): MatchResult {
-  if (context.isNot) {
-    let objectMatch = false;
-    try {
-      assertObjectMatch(
-        // deno-lint-ignore no-explicit-any
-        context.value as Record<PropertyKey, any>,
-        expected as Record<PropertyKey, unknown>,
-        context.customMessage,
-      );
-      objectMatch = true;
-      const actualString = format(context.value);
-      const expectedString = format(expected);
-      throw new AssertionError(
-        `Expected ${actualString} to NOT match ${expectedString}`,
-      );
-    } catch (e) {
-      if (objectMatch) {
-        throw e;
-      }
-      return;
-    }
-  } else {
-    assertObjectMatch(
-      // deno-lint-ignore no-explicit-any
-      context.value as Record<PropertyKey, any>,
-      expected as Record<PropertyKey, unknown>,
-      context.customMessage,
+  const received = context.value;
+
+  if (typeof received !== "object" || received === null) {
+    throw new AssertionError("Received value must be an object");
+  }
+
+  if (typeof expected !== "object" || expected === null) {
+    throw new AssertionError("Received value must be an object");
+  }
+
+  const pass = equal(context.value, expected, {
+    strictCheck: false,
+    customTesters: [
+      ...context.customTesters,
+      iterableEquality,
+      subsetEquality,
+    ],
+  });
+
+  const triggerError = () => {
+    const actualString = format(context.value);
+    const expectedString = format(expected);
+    throw new AssertionError(
+      `Expected ${actualString} to NOT match ${expectedString}`,
     );
+  };
+
+  if (context.isNot && pass || !context.isNot && !pass) {
+    triggerError();
   }
 }
 

package/src/deps/jsr.io/@std/expect/{1.0.6 → 1.0.7}/_utils.ts

@@ -40,6 +40,40 @@ function isObject(a: unknown) {
   return a !== null && typeof a === "object";
 }
 
+function isObjectWithKeys(a: unknown) {
+  return (
+    isObject(a) &&
+    !(a instanceof Error) &&
+    !Array.isArray(a) &&
+    !(a instanceof Date) &&
+    !(a instanceof Set) &&
+    !(a instanceof Map)
+  );
+}
+
+function getObjectKeys(object: object): Array<string | symbol> {
+  return [
+    ...Object.keys(object),
+    ...Object.getOwnPropertySymbols(object).filter(
+      (s) => Object.getOwnPropertyDescriptor(object, s)?.enumerable,
+    ),
+  ];
+}
+
+function hasPropertyInObject(object: object, key: string | symbol): boolean {
+  const shouldTerminate = !object || typeof object !== "object" ||
+    object === Object.prototype;
+
+  if (shouldTerminate) {
+    return false;
+  }
+
+  return (
+    Object.prototype.hasOwnProperty.call(object, key) ||
+    hasPropertyInObject(Object.getPrototypeOf(object), key)
+  );
+}
+
 // deno-lint-ignore no-explicit-any
 function entries(obj: any) {
   if (!isObject(obj)) return [];
@@ -199,3 +233,51 @@ export function iterableEquality(
   bStack.pop();
   return true;
 }
+
+// Ported from https://github.com/jestjs/jest/blob/442c7f692e3a92f14a2fb56c1737b26fc663a0ef/packages/expect-utils/src/utils.ts#L341
+export function subsetEquality(
+  object: unknown,
+  subset: unknown,
+  customTesters: Tester[] = [],
+): boolean | undefined {
+  const filteredCustomTesters = customTesters.filter((t) =>
+    t !== subsetEquality
+  );
+
+  const subsetEqualityWithContext =
+    (seenReferences: WeakMap<object, boolean> = new WeakMap()) =>
+    // deno-lint-ignore no-explicit-any
+    (object: any, subset: any): boolean | undefined => {
+      if (!isObjectWithKeys(subset)) {
+        return undefined;
+      }
+
+      if (seenReferences.has(subset)) return undefined;
+      seenReferences.set(subset, true);
+
+      const matchResult = getObjectKeys(subset).every((key) => {
+        if (isObjectWithKeys(subset[key])) {
+          if (seenReferences.has(subset[key])) {
+            return equal(object[key], subset[key], {
+              customTesters: filteredCustomTesters,
+            });
+          }
+        }
+        const result = object != null &&
+          hasPropertyInObject(object, key) &&
+          equal(object[key], subset[key], {
+            customTesters: [
+              ...filteredCustomTesters,
+              subsetEqualityWithContext(seenReferences),
+            ],
+          });
+        seenReferences.delete(subset[key]);
+        return result;
+      });
+      seenReferences.delete(subset);
+
+      return matchResult;
+    };
+
+  return subsetEqualityWithContext()(object, subset);
+}

package/src/deps/jsr.io/@std/expect/{1.0.6 → 1.0.7}/expect.ts

@@ -13,8 +13,12 @@ import type {
   MatcherKey,
   Matchers,
 } from "./_types.js";
-import { AssertionError } from "../../assert/1.0.6/assertion_error.js";
-import { emitAssertionTrigger, hasAssertions } from "./_assertion.js";
+import { AssertionError } from "../../assert/1.0.7/assertion_error.js";
+import {
+  assertions,
+  emitAssertionTrigger,
+  hasAssertions,
+} from "./_assertions.js";
 import {
   addCustomEqualityTesters,
   getCustomEqualityTesters,
@@ -491,6 +495,7 @@ expect.stringContaining = asymmetricMatchers.stringContaining as (
 expect.stringMatching = asymmetricMatchers.stringMatching as (
   pattern: string | RegExp,
 ) => ReturnType<typeof asymmetricMatchers.stringMatching>;
+
 /**
  * `expect.hasAssertions` verifies that at least one assertion is called during a test.
  *
@@ -509,6 +514,26 @@ expect.stringMatching = asymmetricMatchers.stringMatching as (
  * ```
  */
 expect.hasAssertions = hasAssertions as () => void;
+
+/**
+ * `expect.assertions` verifies that a certain number of assertions are called during a test.
+ *
+ * Note: expect.assertions only can use in bdd function test suite, such as `test` or `it`.
+ *
+ * @example
+ * ```ts
+ *
+ * import { test } from "@std/testing/bdd";
+ * import { expect } from "@std/expect";
+ *
+ * test("it works", () => {
+ *   expect.assertions(1);
+ *   expect("a").not.toBe("b");
+ * });
+ * ```
+ */
+expect.assertions = assertions as (num: number) => void;
+
 /**
  * `expect.objectContaining(object)` matches any received object that recursively matches the expected properties.
  * That is, the expected object is not a subset of the received object. Therefore, it matches a received object
@@ -527,3 +552,50 @@ expect.hasAssertions = hasAssertions as () => void;
 expect.objectContaining = asymmetricMatchers.objectContaining as (
   obj: Record<string, unknown>,
 ) => ReturnType<typeof asymmetricMatchers.objectContaining>;
+/**
+ * `expect.not.arrayContaining` matches a received array which does not contain
+ * all of the elements in the expected array. That is, the expected array is not
+ * a subset of the received array.
+ *
+ * `expect.not.objectContaining` matches any received object that does not recursively
+ * match the expected properties. That is, the expected object is not a subset of the
+ * received object. Therefore, it matches a received object which contains properties
+ * that are not in the expected object.
+ *
+ * `expect.not.stringContaining` matches the received value if it is not a string
+ * or if it is a string that does not contain the exact expected string.
+ *
+ * `expect.not.stringMatching` matches the received value if it is not a string
+ * or if it is a string that does not match the expected string or regular expression.
+ *
+ * @example
+ * ```ts
+ * import { expect } from "@std/expect";
+ *
+ * Deno.test("expect.not.arrayContaining", () => {
+ *   const expected = ["Samantha"];
+ *   expect(["Alice", "Bob", "Eve"]).toEqual(expect.not.arrayContaining(expected));
+ * });
+ *
+ * Deno.test("expect.not.objectContaining", () => {
+ *   const expected = { foo: "bar" };
+ *   expect({ bar: "baz" }).toEqual(expect.not.objectContaining(expected));
+ * });
+ *
+ * Deno.test("expect.not.stringContaining", () => {
+ *   const expected = "Hello world!";
+ *   expect("How are you?").toEqual(expect.not.stringContaining(expected));
+ * });
+ *
+ * Deno.test("expect.not.stringMatching", () => {
+ *   const expected = /Hello world!/;
+ *   expect("How are you?").toEqual(expect.not.stringMatching(expected));
+ * });
+ * ```
+ */
+expect.not = {
+  arrayContaining: asymmetricMatchers.arrayNotContaining,
+  objectContaining: asymmetricMatchers.objectNotContaining,
+  stringContaining: asymmetricMatchers.stringNotContaining,
+  stringMatching: asymmetricMatchers.stringNotMatching,
+};