FM / tests

/home/techb158/balavpn.abdallabala.com/node_modules/zod/src/v3/tests/

/home/techb158/balavpn.abdallabala.com/node_modules/zod/src/v3/tests

Name	Size	Mode	Actions
all-errors.test.ts	4753	0666	edit dl rm
anyunknown.test.ts	673	0666	edit dl rm
array.test.ts	1939	0666	edit dl rm
async-parsing.test.ts	12639	0666	edit dl rm
async-refinements.test.ts	1603	0666	edit dl rm
base.test.ts	782	0666	edit dl rm
bigint.test.ts	1977	0666	edit dl rm
branded.test.ts	1734	0666	edit dl rm
catch.test.ts	6550	0666	edit dl rm
coerce.test.ts	6650	0666	edit dl rm
complex.test.ts	1914	0666	edit dl rm
custom.test.ts	950	0666	edit dl rm
date.test.ts	983	0666	edit dl rm
deepmasking.test.ts	5215	0666	edit dl rm
default.test.ts	3527	0666	edit dl rm
description.test.ts	1323	0666	edit dl rm
discriminated-unions.test.ts	8537	0666	edit dl rm
enum.test.ts	2737	0666	edit dl rm
error.test.ts	16812	0666	edit dl rm
firstparty.test.ts	2391	0666	edit dl rm
firstpartyschematypes.test.ts	788	0666	edit dl rm
function.test.ts	6578	0666	edit dl rm
generics.test.ts	1523	0666	edit dl rm
instanceof.test.ts	1154	0666	edit dl rm
intersection.test.ts	3091	0666	edit dl rm
language-server.source.ts	1275	0666	edit dl rm
language-server.test.ts	8318	0666	edit dl rm
literal.test.ts	1063	0666	edit dl rm
map.test.ts	3545	0666	edit dl rm
masking.test.ts	85	0666	edit dl rm
mocker.test.ts	389	0666	edit dl rm
Mocker.ts	1341	0666	edit dl rm
nan.test.ts	587	0666	edit dl rm
nativeEnum.test.ts	2344	0666	edit dl rm
nullable.test.ts	1172	0666	edit dl rm
number.test.ts	6373	0666	edit dl rm
object-augmentation.test.ts	569	0666	edit dl rm
object-in-es5-env.test.ts	778	0666	edit dl rm
object.test.ts	11772	0666	edit dl rm
optional.test.ts	1222	0666	edit dl rm
parser.test.ts	1125	0666	edit dl rm
parseUtil.test.ts	869	0666	edit dl rm
partials.test.ts	6996	0666	edit dl rm
pickomit.test.ts	3622	0666	edit dl rm
pipeline.test.ts	823	0666	edit dl rm
preprocess.test.ts	4530	0666	edit dl rm
primitive.test.ts	12215	0666	edit dl rm
promise.test.ts	2490	0666	edit dl rm
readonly.test.ts	7339	0666	edit dl rm
record.test.ts	3735	0666	edit dl rm
recursive.test.ts	3946	0666	edit dl rm
refine.test.ts	8172	0666	edit dl rm
safeparse.test.ts	628	0666	edit dl rm
set.test.ts	4788	0666	edit dl rm
standard-schema.test.ts	2587	0666	edit dl rm
string.test.ts	65623	0666	edit dl rm
transformer.test.ts	5687	0666	edit dl rm
tuple.test.ts	2691	0666	edit dl rm
unions.test.ts	1540	0666	edit dl rm
validations.test.ts	3826	0666	edit dl rm
void.test.ts	349	0666	edit dl rm

Edit: /home/techb158/balavpn.abdallabala.com/node_modules/zod/src/v3/tests/primitive.test.ts (12215B)

// @ts-ignore TS6133
import { expect, test } from "vitest";

import * as z from "zod/v3";
import { util } from "../helpers/util.js";
import { Mocker } from "./Mocker.js";

const literalStringSchema = z.literal("asdf");
const literalNumberSchema = z.literal(12);
const literalBooleanSchema = z.literal(true);
const literalBigIntSchema = z.literal(BigInt(42));
const MySymbol = Symbol("stuff");
const literalSymbolSchema = z.literal(MySymbol);
const stringSchema = z.string();
const numberSchema = z.number();
const bigintSchema = z.bigint();
const booleanSchema = z.boolean();
const dateSchema = z.date();
const symbolSchema = z.symbol();

const nullSchema = z.null();
const undefinedSchema = z.undefined();
const stringSchemaOptional = z.string().optional();
const stringSchemaNullable = z.string().nullable();
const numberSchemaOptional = z.number().optional();
const numberSchemaNullable = z.number().nullable();
const bigintSchemaOptional = z.bigint().optional();
const bigintSchemaNullable = z.bigint().nullable();
const booleanSchemaOptional = z.boolean().optional();
const booleanSchemaNullable = z.boolean().nullable();
const dateSchemaOptional = z.date().optional();
const dateSchemaNullable = z.date().nullable();
const symbolSchemaOptional = z.symbol().optional();
const symbolSchemaNullable = z.symbol().nullable();

const val = new Mocker();

test("literal string correct", () => {
  expect(literalStringSchema.parse("asdf")).toBe("asdf");
});

test("literal string incorrect", () => {
  const f = () => literalStringSchema.parse("not_asdf");
  expect(f).toThrow();
});

test("literal string number", () => {
  const f = () => literalStringSchema.parse(123);
  expect(f).toThrow();
});

test("literal string boolean", () => {
  const f = () => literalStringSchema.parse(true);
  expect(f).toThrow();
});

test("literal string object", () => {
  const f = () => literalStringSchema.parse({});
  expect(f).toThrow();
});

test("literal number correct", () => {
  expect(literalNumberSchema.parse(12)).toBe(12);
});

test("literal number incorrect", () => {
  const f = () => literalNumberSchema.parse(13);
  expect(f).toThrow();
});

test("literal number number", () => {
  const f = () => literalNumberSchema.parse(val.string);
  expect(f).toThrow();
});

test("literal number boolean", () => {
  const f = () => literalNumberSchema.parse(val.boolean);
  expect(f).toThrow();
});

test("literal number object", () => {
  const f = () => literalStringSchema.parse({});
  expect(f).toThrow();
});

test("literal boolean correct", () => {
  expect(literalBooleanSchema.parse(true)).toBe(true);
});

test("literal boolean incorrect", () => {
  const f = () => literalBooleanSchema.parse(false);
  expect(f).toThrow();
});

test("literal boolean number", () => {
  const f = () => literalBooleanSchema.parse("asdf");
  expect(f).toThrow();
});

test("literal boolean boolean", () => {
  const f = () => literalBooleanSchema.parse(123);
  expect(f).toThrow();
});

test("literal boolean object", () => {
  const f = () => literalBooleanSchema.parse({});
  expect(f).toThrow();
});

test("literal bigint correct", () => {
  expect(literalBigIntSchema.parse(BigInt(42))).toBe(BigInt(42));
});

test("literal bigint incorrect", () => {
  const f = () => literalBigIntSchema.parse(BigInt(43));
  expect(f).toThrow();
});

test("literal bigint number", () => {
  const f = () => literalBigIntSchema.parse("asdf");
  expect(f).toThrow();
});

test("literal bigint boolean", () => {
  const f = () => literalBigIntSchema.parse(123);
  expect(f).toThrow();
});

test("literal bigint object", () => {
  const f = () => literalBigIntSchema.parse({});
  expect(f).toThrow();
});

test("literal symbol", () => {
  util.assertEqual<z.infer<typeof literalSymbolSchema>, typeof MySymbol>(true);
  literalSymbolSchema.parse(MySymbol);
  expect(() => literalSymbolSchema.parse(Symbol("asdf"))).toThrow();
});

test("parse stringSchema string", () => {
  stringSchema.parse(val.string);
});

test("parse stringSchema number", () => {
  const f = () => stringSchema.parse(val.number);
  expect(f).toThrow();
});

test("parse stringSchema boolean", () => {
  const f = () => stringSchema.parse(val.boolean);
  expect(f).toThrow();
});

test("parse stringSchema undefined", () => {
  const f = () => stringSchema.parse(val.undefined);
  expect(f).toThrow();
});

test("parse stringSchema null", () => {
  const f = () => stringSchema.parse(val.null);
  expect(f).toThrow();
});

test("parse numberSchema string", () => {
  const f = () => numberSchema.parse(val.string);
  expect(f).toThrow();
});

test("parse numberSchema number", () => {
  numberSchema.parse(val.number);
});

test("parse numberSchema bigint", () => {
  const f = () => numberSchema.parse(val.bigint);
  expect(f).toThrow();
});

test("parse numberSchema boolean", () => {
  const f = () => numberSchema.parse(val.boolean);
  expect(f).toThrow();
});

test("parse numberSchema undefined", () => {
  const f = () => numberSchema.parse(val.undefined);
  expect(f).toThrow();
});

test("parse numberSchema null", () => {
  const f = () => numberSchema.parse(val.null);
  expect(f).toThrow();
});

test("parse bigintSchema string", () => {
  const f = () => bigintSchema.parse(val.string);
  expect(f).toThrow();
});

test("parse bigintSchema number", () => {
  const f = () => bigintSchema.parse(val.number);
  expect(f).toThrow();
});

test("parse bigintSchema bigint", () => {
  bigintSchema.parse(val.bigint);
});

test("parse bigintSchema boolean", () => {
  const f = () => bigintSchema.parse(val.boolean);
  expect(f).toThrow();
});

test("parse bigintSchema undefined", () => {
  const f = () => bigintSchema.parse(val.undefined);
  expect(f).toThrow();
});

test("parse bigintSchema null", () => {
  const f = () => bigintSchema.parse(val.null);
  expect(f).toThrow();
});

test("parse booleanSchema string", () => {
  const f = () => booleanSchema.parse(val.string);
  expect(f).toThrow();
});

test("parse booleanSchema number", () => {
  const f = () => booleanSchema.parse(val.number);
  expect(f).toThrow();
});

test("parse booleanSchema boolean", () => {
  booleanSchema.parse(val.boolean);
});

test("parse booleanSchema undefined", () => {
  const f = () => booleanSchema.parse(val.undefined);
  expect(f).toThrow();
});

test("parse booleanSchema null", () => {
  const f = () => booleanSchema.parse(val.null);
  expect(f).toThrow();
});

// ==============

test("parse dateSchema string", () => {
  const f = () => dateSchema.parse(val.string);
  expect(f).toThrow();
});

test("parse dateSchema number", () => {
  const f = () => dateSchema.parse(val.number);
  expect(f).toThrow();
});

test("parse dateSchema boolean", () => {
  const f = () => dateSchema.parse(val.boolean);
  expect(f).toThrow();
});

test("parse dateSchema date", () => {
  dateSchema.parse(val.date);
});

test("parse dateSchema undefined", () => {
  const f = () => dateSchema.parse(val.undefined);
  expect(f).toThrow();
});

test("parse dateSchema null", () => {
  const f = () => dateSchema.parse(val.null);
  expect(f).toThrow();
});

test("parse dateSchema invalid date", async () => {
  try {
    await dateSchema.parseAsync(new Date("invalid"));
  } catch (err) {
    expect((err as z.ZodError).issues[0].code).toEqual(z.ZodIssueCode.invalid_date);
  }
});
// ==============

test("parse symbolSchema string", () => {
  const f = () => symbolSchema.parse(val.string);
  expect(f).toThrow();
});

test("parse symbolSchema number", () => {
  const f = () => symbolSchema.parse(val.number);
  expect(f).toThrow();
});

test("parse symbolSchema boolean", () => {
  const f = () => symbolSchema.parse(val.boolean);
  expect(f).toThrow();
});

test("parse symbolSchema date", () => {
  const f = () => symbolSchema.parse(val.date);
  expect(f).toThrow();
});

test("parse symbolSchema symbol", () => {
  symbolSchema.parse(val.symbol);
});

test("parse symbolSchema undefined", () => {
  const f = () => symbolSchema.parse(val.undefined);
  expect(f).toThrow();
});

test("parse symbolSchema null", () => {
  const f = () => symbolSchema.parse(val.null);
  expect(f).toThrow();
});

// ==============

test("parse undefinedSchema string", () => {
  const f = () => undefinedSchema.parse(val.string);
  expect(f).toThrow();
});

test("parse undefinedSchema number", () => {
  const f = () => undefinedSchema.parse(val.number);
  expect(f).toThrow();
});

test("parse undefinedSchema boolean", () => {
  const f = () => undefinedSchema.parse(val.boolean);
  expect(f).toThrow();
});

test("parse undefinedSchema undefined", () => {
  undefinedSchema.parse(val.undefined);
});

test("parse undefinedSchema null", () => {
  const f = () => undefinedSchema.parse(val.null);
  expect(f).toThrow();
});

test("parse nullSchema string", () => {
  const f = () => nullSchema.parse(val.string);
  expect(f).toThrow();
});

test("parse nullSchema number", () => {
  const f = () => nullSchema.parse(val.number);
  expect(f).toThrow();
});

test("parse nullSchema boolean", () => {
  const f = () => nullSchema.parse(val.boolean);
  expect(f).toThrow();
});

test("parse nullSchema undefined", () => {
  const f = () => nullSchema.parse(val.undefined);
  expect(f).toThrow();
});

test("parse nullSchema null", () => {
  nullSchema.parse(val.null);
});

test("primitive inference", () => {
  util.assertEqual<z.TypeOf<typeof literalStringSchema>, "asdf">(true);
  util.assertEqual<z.TypeOf<typeof literalNumberSchema>, 12>(true);
  util.assertEqual<z.TypeOf<typeof literalBooleanSchema>, true>(true);
  util.assertEqual<z.TypeOf<typeof literalBigIntSchema>, bigint>(true);
  util.assertEqual<z.TypeOf<typeof stringSchema>, string>(true);
  util.assertEqual<z.TypeOf<typeof numberSchema>, number>(true);
  util.assertEqual<z.TypeOf<typeof bigintSchema>, bigint>(true);
  util.assertEqual<z.TypeOf<typeof booleanSchema>, boolean>(true);
  util.assertEqual<z.TypeOf<typeof dateSchema>, Date>(true);
  util.assertEqual<z.TypeOf<typeof symbolSchema>, symbol>(true);

util.assertEqual<z.TypeOf<typeof nullSchema>, null>(true);
  util.assertEqual<z.TypeOf<typeof undefinedSchema>, undefined>(true);
  util.assertEqual<z.TypeOf<typeof stringSchemaOptional>, string | undefined>(true);
  util.assertEqual<z.TypeOf<typeof stringSchemaNullable>, string | null>(true);
  util.assertEqual<z.TypeOf<typeof numberSchemaOptional>, number | undefined>(true);
  util.assertEqual<z.TypeOf<typeof numberSchemaNullable>, number | null>(true);
  util.assertEqual<z.TypeOf<typeof bigintSchemaOptional>, bigint | undefined>(true);
  util.assertEqual<z.TypeOf<typeof bigintSchemaNullable>, bigint | null>(true);
  util.assertEqual<z.TypeOf<typeof booleanSchemaOptional>, boolean | undefined>(true);
  util.assertEqual<z.TypeOf<typeof booleanSchemaNullable>, boolean | null>(true);
  util.assertEqual<z.TypeOf<typeof dateSchemaOptional>, Date | undefined>(true);
  util.assertEqual<z.TypeOf<typeof dateSchemaNullable>, Date | null>(true);
  util.assertEqual<z.TypeOf<typeof symbolSchemaOptional>, symbol | undefined>(true);
  util.assertEqual<z.TypeOf<typeof symbolSchemaNullable>, symbol | null>(true);

// [
  //   literalStringSchemaTest,
  //   literalNumberSchemaTest,
  //   literalBooleanSchemaTest,
  //   literalBigIntSchemaTest,
  //   stringSchemaTest,
  //   numberSchemaTest,
  //   bigintSchemaTest,
  //   booleanSchemaTest,
  //   dateSchemaTest,
  //   symbolSchemaTest,

//   nullSchemaTest,
  //   undefinedSchemaTest,
  //   stringSchemaOptionalTest,
  //   stringSchemaNullableTest,
  //   numberSchemaOptionalTest,
  //   numberSchemaNullableTest,
  //   bigintSchemaOptionalTest,
  //   bigintSchemaNullableTest,
  //   booleanSchemaOptionalTest,
  //   booleanSchemaNullableTest,
  //   dateSchemaOptionalTest,
  //   dateSchemaNullableTest,
  //   symbolSchemaOptionalTest,
  //   symbolSchemaNullableTest,

// ];
});

test("get literal value", () => {
  expect(literalStringSchema.value).toEqual("asdf");
});

test("optional convenience method", () => {
  z.ostring().parse(undefined);
  z.onumber().parse(undefined);
  z.oboolean().parse(undefined);
});

// @ts-ignore TS6133 import { expect, test } from "vitest"; import * as z from "zod/v3"; import { util } from "../helpers/util.js"; import { Mocker } from "./Mocker.js"; const literalStringSchema = z.literal("asdf"); const literalNumberSchema = z.literal(12); const literalBooleanSchema = z.literal(true); const literalBigIntSchema = z.literal(BigInt(42)); const MySymbol = Symbol("stuff"); const literalSymbolSchema = z.literal(MySymbol); const stringSchema = z.string(); const numberSchema = z.number(); const bigintSchema = z.bigint(); const booleanSchema = z.boolean(); const dateSchema = z.date(); const symbolSchema = z.symbol(); const nullSchema = z.null(); const undefinedSchema = z.undefined(); const stringSchemaOptional = z.string().optional(); const stringSchemaNullable = z.string().nullable(); const numberSchemaOptional = z.number().optional(); const numberSchemaNullable = z.number().nullable(); const bigintSchemaOptional = z.bigint().optional(); const bigintSchemaNullable = z.bigint().nullable(); const booleanSchemaOptional = z.boolean().optional(); const booleanSchemaNullable = z.boolean().nullable(); const dateSchemaOptional = z.date().optional(); const dateSchemaNullable = z.date().nullable(); const symbolSchemaOptional = z.symbol().optional(); const symbolSchemaNullable = z.symbol().nullable(); const val = new Mocker(); test("literal string correct", () => { expect(literalStringSchema.parse("asdf")).toBe("asdf"); }); test("literal string incorrect", () => { const f = () => literalStringSchema.parse("not_asdf"); expect(f).toThrow(); }); test("literal string number", () => { const f = () => literalStringSchema.parse(123); expect(f).toThrow(); }); test("literal string boolean", () => { const f = () => literalStringSchema.parse(true); expect(f).toThrow(); }); test("literal string boolean", () => { const f = () => literalStringSchema.parse(true); expect(f).toThrow(); }); test("literal string object", () => { const f = () => literalStringSchema.parse({}); expect(f).toThrow(); }); test("literal number correct", () => { expect(literalNumberSchema.parse(12)).toBe(12); }); test("literal number incorrect", () => { const f = () => literalNumberSchema.parse(13); expect(f).toThrow(); }); test("literal number number", () => { const f = () => literalNumberSchema.parse(val.string); expect(f).toThrow(); }); test("literal number boolean", () => { const f = () => literalNumberSchema.parse(val.boolean); expect(f).toThrow(); }); test("literal number object", () => { const f = () => literalStringSchema.parse({}); expect(f).toThrow(); }); test("literal boolean correct", () => { expect(literalBooleanSchema.parse(true)).toBe(true); }); test("literal boolean incorrect", () => { const f = () => literalBooleanSchema.parse(false); expect(f).toThrow(); }); test("literal boolean number", () => { const f = () => literalBooleanSchema.parse("asdf"); expect(f).toThrow(); }); test("literal boolean boolean", () => { const f = () => literalBooleanSchema.parse(123); expect(f).toThrow(); }); test("literal boolean object", () => { const f = () => literalBooleanSchema.parse({}); expect(f).toThrow(); }); test("literal bigint correct", () => { expect(literalBigIntSchema.parse(BigInt(42))).toBe(BigInt(42)); }); test("literal bigint incorrect", () => { const f = () => literalBigIntSchema.parse(BigInt(43)); expect(f).toThrow(); }); test("literal bigint number", () => { const f = () => literalBigIntSchema.parse("asdf"); expect(f).toThrow(); }); test("literal bigint boolean", () => { const f = () => literalBigIntSchema.parse(123); expect(f).toThrow(); }); test("literal bigint object", () => { const f = () => literalBigIntSchema.parse({}); expect(f).toThrow(); }); test("literal symbol", () => { util.assertEqual, typeof MySymbol>(true); literalSymbolSchema.parse(MySymbol); expect(() => literalSymbolSchema.parse(Symbol("asdf"))).toThrow(); }); test("parse stringSchema string", () => { stringSchema.parse(val.string); }); test("parse stringSchema number", () => { const f = () => stringSchema.parse(val.number); expect(f).toThrow(); }); test("parse stringSchema boolean", () => { const f = () => stringSchema.parse(val.boolean); expect(f).toThrow(); }); test("parse stringSchema undefined", () => { const f = () => stringSchema.parse(val.undefined); expect(f).toThrow(); }); test("parse stringSchema null", () => { const f = () => stringSchema.parse(val.null); expect(f).toThrow(); }); test("parse numberSchema string", () => { const f = () => numberSchema.parse(val.string); expect(f).toThrow(); }); test("parse numberSchema number", () => { numberSchema.parse(val.number); }); test("parse numberSchema bigint", () => { const f = () => numberSchema.parse(val.bigint); expect(f).toThrow(); }); test("parse numberSchema boolean", () => { const f = () => numberSchema.parse(val.boolean); expect(f).toThrow(); }); test("parse numberSchema undefined", () => { const f = () => numberSchema.parse(val.undefined); expect(f).toThrow(); }); test("parse numberSchema null", () => { const f = () => numberSchema.parse(val.null); expect(f).toThrow(); }); test("parse bigintSchema string", () => { const f = () => bigintSchema.parse(val.string); expect(f).toThrow(); }); test("parse bigintSchema number", () => { const f = () => bigintSchema.parse(val.number); expect(f).toThrow(); }); test("parse bigintSchema bigint", () => { bigintSchema.parse(val.bigint); }); test("parse bigintSchema boolean", () => { const f = () => bigintSchema.parse(val.boolean); expect(f).toThrow(); }); test("parse bigintSchema undefined", () => { const f = () => bigintSchema.parse(val.undefined); expect(f).toThrow(); }); test("parse bigintSchema null", () => { const f = () => bigintSchema.parse(val.null); expect(f).toThrow(); }); test("parse booleanSchema string", () => { const f = () => booleanSchema.parse(val.string); expect(f).toThrow(); }); test("parse booleanSchema number", () => { const f = () => booleanSchema.parse(val.number); expect(f).toThrow(); }); test("parse booleanSchema boolean", () => { booleanSchema.parse(val.boolean); }); test("parse booleanSchema undefined", () => { const f = () => booleanSchema.parse(val.undefined); expect(f).toThrow(); }); test("parse booleanSchema null", () => { const f = () => booleanSchema.parse(val.null); expect(f).toThrow(); }); // ============== test("parse dateSchema string", () => { const f = () => dateSchema.parse(val.string); expect(f).toThrow(); }); test("parse dateSchema number", () => { const f = () => dateSchema.parse(val.number); expect(f).toThrow(); }); test("parse dateSchema boolean", () => { const f = () => dateSchema.parse(val.boolean); expect(f).toThrow(); }); test("parse dateSchema date", () => { dateSchema.parse(val.date); }); test("parse dateSchema undefined", () => { const f = () => dateSchema.parse(val.undefined); expect(f).toThrow(); }); test("parse dateSchema null", () => { const f = () => dateSchema.parse(val.null); expect(f).toThrow(); }); test("parse dateSchema invalid date", async () => { try { await dateSchema.parseAsync(new Date("invalid")); } catch (err) { expect((err as z.ZodError).issues[0].code).toEqual(z.ZodIssueCode.invalid_date); } }); // ============== test("parse symbolSchema string", () => { const f = () => symbolSchema.parse(val.string); expect(f).toThrow(); }); test("parse symbolSchema number", () => { const f = () => symbolSchema.parse(val.number); expect(f).toThrow(); }); test("parse symbolSchema boolean", () => { const f = () => symbolSchema.parse(val.boolean); expect(f).toThrow(); }); test("parse symbolSchema date", () => { const f = () => symbolSchema.parse(val.date); expect(f).toThrow(); }); test("parse symbolSchema symbol", () => { symbolSchema.parse(val.symbol); }); test("parse symbolSchema undefined", () => { const f = () => symbolSchema.parse(val.undefined); expect(f).toThrow(); }); test("parse symbolSchema null", () => { const f = () => symbolSchema.parse(val.null); expect(f).toThrow(); }); // ============== test("parse undefinedSchema string", () => { const f = () => undefinedSchema.parse(val.string); expect(f).toThrow(); }); test("parse undefinedSchema number", () => { const f = () => undefinedSchema.parse(val.number); expect(f).toThrow(); }); test("parse undefinedSchema boolean", () => { const f = () => undefinedSchema.parse(val.boolean); expect(f).toThrow(); }); test("parse undefinedSchema undefined", () => { undefinedSchema.parse(val.undefined); }); test("parse undefinedSchema null", () => { const f = () => undefinedSchema.parse(val.null); expect(f).toThrow(); }); test("parse nullSchema string", () => { const f = () => nullSchema.parse(val.string); expect(f).toThrow(); }); test("parse nullSchema number", () => { const f = () => nullSchema.parse(val.number); expect(f).toThrow(); }); test("parse nullSchema boolean", () => { const f = () => nullSchema.parse(val.boolean); expect(f).toThrow(); }); test("parse nullSchema undefined", () => { const f = () => nullSchema.parse(val.undefined); expect(f).toThrow(); }); test("parse nullSchema null", () => { nullSchema.parse(val.null); }); test("primitive inference", () => { util.assertEqual, "asdf">(true); util.assertEqual, 12>(true); util.assertEqual, true>(true); util.assertEqual, bigint>(true); util.assertEqual, string>(true); util.assertEqual, number>(true); util.assertEqual, bigint>(true); util.assertEqual, boolean>(true); util.assertEqual, Date>(true); util.assertEqual, symbol>(true); util.assertEqual, null>(true); util.assertEqual, undefined>(true); util.assertEqual, string | undefined>(true); util.assertEqual, string | null>(true); util.assertEqual, number | undefined>(true); util.assertEqual, number | null>(true); util.assertEqual, bigint | undefined>(true); util.assertEqual, bigint | null>(true); util.assertEqual, boolean | undefined>(true); util.assertEqual, boolean | null>(true); util.assertEqual, Date | undefined>(true); util.assertEqual, Date | null>(true); util.assertEqual, symbol | undefined>(true); util.assertEqual, symbol | null>(true); // [ // literalStringSchemaTest, // literalNumberSchemaTest, // literalBooleanSchemaTest, // literalBigIntSchemaTest, // stringSchemaTest, // numberSchemaTest, // bigintSchemaTest, // booleanSchemaTest, // dateSchemaTest, // symbolSchemaTest, // nullSchemaTest, // undefinedSchemaTest, // stringSchemaOptionalTest, // stringSchemaNullableTest, // numberSchemaOptionalTest, // numberSchemaNullableTest, // bigintSchemaOptionalTest, // bigintSchemaNullableTest, // booleanSchemaOptionalTest, // booleanSchemaNullableTest, // dateSchemaOptionalTest, // dateSchemaNullableTest, // symbolSchemaOptionalTest, // symbolSchemaNullableTest, // ]; }); test("get literal value", () => { expect(literalStringSchema.value).toEqual("asdf"); }); test("optional convenience method", () => { z.ostring().parse(undefined); z.onumber().parse(undefined); z.oboolean().parse(undefined); });