Function testRoundtripConsistency

packages/effect/test/Schema/SchemaTest.ts:113–145

* Verifies that the schema satisfies the roundtrip law: `decode(encode(a))` * is equal to `a`.

(schema: Schema.Schema<A, I, never>, options?: {
      readonly ignoreEncodingErrors?: ((issue: ParseResult.ParseIssue) => boolean) | undefined
      readonly params?: FastCheck.Parameters<[A]> | undefined
    })

     * is equal to `a`.
     */
    testRoundtripConsistency<A, I>(schema: Schema.Schema<A, I, never>, options?: {
      readonly ignoreEncodingErrors?: ((issue: ParseResult.ParseIssue) => boolean) | undefined
      readonly params?: FastCheck.Parameters<[A]> | undefined
    }) {
      if (config.testRoundtripConsistency?.skip === true) {
        return
      }
      const params = Predicate.isObject(config.testRoundtripConsistency?.params)
        ? { ...config.testRoundtripConsistency?.params, ...options?.params }
        : options?.params
      const arb = Arbitrary.make(schema)
      const is = Schema.is(schema)
      const encode = ParseResult.encode(schema)
      const decode = ParseResult.decode(schema)
      FastCheck.assert(
        FastCheck.property(arb, (a) => {
          const roundtrip = encode(a).pipe(
            Effect.mapError((issue) => ["encoding", issue] as const),
            Effect.flatMap((i) => decode(i).pipe(Effect.mapError((issue) => ["decoding", issue] as const))),
            Effect.either,
            Effect.runSync
          )
          if (Either.isLeft(roundtrip)) {
            if (roundtrip.left[0] === "encoding" && options?.ignoreEncodingErrors) {
              return options.ignoreEncodingErrors(roundtrip.left[1])
            }
            return false
          }
          return is(roundtrip.right)
        }),
        params
      )
    },

    decoding: {
      /**