diff --git a/src/compare.ts b/src/compare.ts new file mode 100644 index 0000000000..987262732d --- /dev/null +++ b/src/compare.ts @@ -0,0 +1,19 @@ +/** + * Comapre in deep A and B + */ +export function equals(a: T, b: T): boolean; +/** + * @internal + */ +export function equals(_a: T, _b: T): boolean { + halt("equals"); +} + +/** + * @internal + */ +function halt(name: string): never { + throw new Error( + `Error on typia.compare.${name}(): no transform has been configured. Read and follow https://typia.io/docs/setup please.`, + ); +} diff --git a/src/factories/MetadataCollection.ts b/src/factories/MetadataCollection.ts index 6feeb4b7d8..efc20807f6 100644 --- a/src/factories/MetadataCollection.ts +++ b/src/factories/MetadataCollection.ts @@ -76,6 +76,16 @@ export class MetadataCollection { return [...this.tuples_.values()]; } + public findObjectType(target: MetadataObjectType) { + // Add weakmap to index it and avoid finding O(n) + for (const [key, object] of this.objects_.entries()) { + if (object === target) { + return key; + } + } + return undefined; + } + private getName(checker: ts.TypeChecker, type: ts.Type): string { const name: string = (() => { const str: string = TypeFactory.getFullName({ diff --git a/src/factories/internal/metadata/iterate_metadata.ts b/src/factories/internal/metadata/iterate_metadata.ts index ae79625f7f..86a8c080e0 100644 --- a/src/factories/internal/metadata/iterate_metadata.ts +++ b/src/factories/internal/metadata/iterate_metadata.ts @@ -30,6 +30,9 @@ export const iterate_metadata = (props: IMetadataIteratorProps): void => { }); return; } + if (props.type.isClass()) { + props.metadata.class = true; + } // CHECK SPECIAL CASES if ( (props.explore.aliased !== true && iterate_metadata_alias(props)) || diff --git a/src/module.ts b/src/module.ts index 27a5d2e145..570dff9e7b 100644 --- a/src/module.ts +++ b/src/module.ts @@ -13,6 +13,7 @@ export * as notations from "./notations"; export * as protobuf from "./protobuf"; export * as reflect from "./reflect"; export * as tags from "./tags"; +export * as compare from "./compare"; export * from "./schemas/metadata/IJsDocTagInfo"; export * from "./schemas/json/IJsonApplication"; diff --git a/src/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts new file mode 100644 index 0000000000..0e23b815d4 --- /dev/null +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -0,0 +1,631 @@ +import ts from "typescript"; + +import { IdentifierFactory } from "../../factories/IdentifierFactory"; +import { MetadataCollection } from "../../factories/MetadataCollection"; +import { MetadataFactory } from "../../factories/MetadataFactory"; +import { StatementFactory } from "../../factories/StatementFactory"; + +import { Metadata } from "../../schemas/metadata/Metadata"; +import { MetadataArray } from "../../schemas/metadata/MetadataArray"; +import { MetadataNative } from "../../schemas/metadata/MetadataNative"; +import { MetadataObject } from "../../schemas/metadata/MetadataObject"; +import { MetadataTuple } from "../../schemas/metadata/MetadataTuple"; + +import { IProgrammerProps } from "../../transformers/IProgrammerProps"; +import { ITypiaContext } from "../../transformers/ITypiaContext"; +import { TransformerError } from "../../transformers/TransformerError"; + +import { FeatureProgrammer } from "../FeatureProgrammer"; +import { FunctionProgrammer } from "../helpers/FunctionProgrammer"; + +export namespace CompareEqualsProgrammer { + type Props = { + context: ITypiaContext; + functor: FunctionProgrammer; + metaCollection: MetadataCollection; + type: ts.Type; + name: string | undefined; + }; + + export function decompose(props: Props): FeatureProgrammer.IDecomposed { + const result = MetadataFactory.analyze({ + type: props.type, + checker: props.context.checker, + transformer: props.context.transformer, + collection: props.metaCollection, + options: { + escape: false, + constant: true, + absorb: true, + validate: (metadata) => { + const output: string[] = []; + if (metadata.natives.some((native) => native.name === "WeakSet")) { + output.push("unable to compare WeakSet"); + } else if ( + metadata.natives.some((native) => native.name === "WeakMap") + ) { + output.push("unable to compare WeakMap"); + } + return output; + }, + }, + }); + + if (!result.success) { + throw new Error( + `typia.${props.functor.method}: Failure to analyze type ${props.type.getSymbol()?.getName()}`, + ); + } + + const a = ts.factory.createIdentifier("a"); + const b = ts.factory.createIdentifier("b"); + const expression = transform(a, b, props, result.data); + const argType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword); + + return { + functions: {}, + statements: [], + arrow: ts.factory.createArrowFunction( + undefined, + undefined, + [ + IdentifierFactory.parameter(a.text, argType), + IdentifierFactory.parameter(b.text, argType), + ], + ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword), + undefined, + ts.factory.createBlock( + [ts.factory.createReturnStatement(expression)], + true, + ), + ), + }; + } + + export function write(props: IProgrammerProps) { + const functor = new FunctionProgrammer(props.modulo.getText()); + const result: FeatureProgrammer.IDecomposed = decompose({ + ...props, + metaCollection: new MetadataCollection(), + functor, + }); + + return FeatureProgrammer.writeDecomposed({ + modulo: props.modulo, + functor, + result, + }); + } + + function eqeqeq(a: ts.Expression, b: ts.Expression) { + return ts.factory.createExpressionStatement( + ts.factory.createBinaryExpression( + a, + ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), + b, + ), + ); + } + + function mergeWithAmp( + expressions: ts.Expression[], + withParenthesized = false, + ) { + if (expressions.length === 0) { + return ts.factory.createTrue(); + } + + const result = expressions.reduce((acc, current) => and(acc, current)); + if (withParenthesized) { + return ts.factory.createParenthesizedExpression(result); + } + return result; + } + + function mergeWithBar( + expressions: ts.Expression[], + withParenthesized = false, + ) { + if (expressions.length === 0) { + return ts.factory.createTrue(); + } + + const result = expressions.reduce((acc, current) => or(acc, current)); + if (withParenthesized) { + return ts.factory.createParenthesizedExpression(result); + } + return result; + } + + function or(a: ts.Expression, b: ts.Expression) { + return ts.factory.createBinaryExpression( + a, + ts.factory.createToken(ts.SyntaxKind.BarBarToken), + b, + ); + } + + function and(a: ts.Expression, b: ts.Expression) { + return ts.factory.createBinaryExpression( + a, + ts.factory.createToken(ts.SyntaxKind.AmpersandAmpersandToken), + b, + ); + } + + const params = { + item: IdentifierFactory.parameter("item"), + index: IdentifierFactory.parameter, + }; + const ids = { + Map: ts.factory.createIdentifier("Map"), + Set: ts.factory.createIdentifier("Set"), + Array: ts.factory.createIdentifier("Array"), + String: ts.factory.createIdentifier("String"), + + zero: ts.factory.createIdentifier("0"), + item: ts.factory.createIdentifier("item"), + size: ts.factory.createIdentifier("size"), + from: ts.factory.createIdentifier("from"), + every: ts.factory.createIdentifier("every"), + values: ts.factory.createIdentifier("values"), + length: ts.factory.createIdentifier("length"), + object: ts.factory.createIdentifier('"object"'), + isArray: ts.factory.createIdentifier("isArray"), + funtion: ts.factory.createIdentifier('"funtion"'), + toString: ts.factory.createIdentifier("toString"), + difference: ts.factory.createIdentifier("difference"), + + index: () => ts.factory.createUniqueName("index"), + }; + + function indexAccess( + arr: ts.Expression, + id: ts.Expression, + nonNullable = false, + ) { + const elementAccess = ts.factory.createElementAccessExpression(arr, id); + if (nonNullable) { + return ts.factory.createNonNullExpression(elementAccess); + } + return elementAccess; + } + + function access( + target: ts.Expression, + prop: string | ts.MemberName, + optinal = false, + ) { + if (typeof prop === "string") { + return IdentifierFactory.access(target, prop, optinal); + } + + return IdentifierFactory.access( + target, + prop.escapedText as string, + optinal, + ); + } + + function transformObject( + a: ts.Expression, + b: ts.Expression, + props: Props, + metadata: Metadata, + object: MetadataObject, + ) { + if (object.type.recursive) { + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `Detected recusion type ${props.type.getSymbol()?.getName()} -> ${object.type.name}.`, + }); + } + + if (metadata.class) { + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `Can't compare classes as static ${props.type.getSymbol()?.getName()} -> ${object.type.name}.`, + }); + } + + const statements = object.type.properties.map((prop) => { + if (!prop.key.getSoleLiteral()) { + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `Detected unknown property name ${props.type.getSymbol()?.getName()} -> ${object.type.name}. If it's dynamic it's doesn't support.`, + }); + } + + return transform( + access( + a, + ts.factory.createIdentifier(prop.key.getSoleLiteral()!), + prop.value.optional, + ), + access( + b, + ts.factory.createIdentifier(prop.key.getSoleLiteral()!), + prop.value.optional, + ), + props, + prop.value, + ); + }); + + const type = props.metaCollection.findObjectType(object.type); + if (type) { + for (const symbol of type.getApparentProperties()) { + const node = symbol.getDeclarations()?.[0] as + | ts.PropertyDeclaration + | undefined; + if (!node) { + continue; + } + if (ts.isMethodSignature(node)) { + statements.push( + eqeqeq(access(a, symbol.getName()), access(b, symbol.getName())) + .expression, + ); + } + } + } + + return or(eqeqeq(a, b).expression, mergeWithAmp(statements, true)); + } + + function compareItem(b: ts.Expression, props: Props, metadata?: Metadata) { + const index = ids.index(); + const compareExpression = metadata + ? transform( + ids.item, + indexAccess( + ts.factory.createAsExpression( + b, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword), + ), + index, + true, + ), + props, + metadata, + ) + : eqeqeq(index, b).expression; + return ts.factory.createArrowFunction( + undefined, + undefined, + [params.item, params.index(index)], + undefined, + undefined, + ts.factory.createBlock([ + ts.factory.createReturnStatement(compareExpression), + ]), + ); + } + + function iife(body: ts.Statement[]) { + const arrowFunction = ts.factory.createArrowFunction( + undefined, + undefined, + [], + undefined, + ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), + ts.factory.createBlock(body, true), + ); + return ts.factory.createCallExpression( + ts.factory.createParenthesizedExpression(arrowFunction), + undefined, + [], + ); + } + + function spreadClone(exp: ts.Expression) { + const spreadElement = ts.factory.createSpreadElement(exp); + return ts.factory.createArrayLiteralExpression( + [spreadElement], + /* multiLine */ false, + ); + } + + function transformIterable( + a: ts.Expression, + b: ts.Expression, + _props: Props, + _metadata: Metadata, + ) { + const a1 = ts.factory.createUniqueName("a1"); + const b1 = ts.factory.createUniqueName("b1"); + const iffeCompare = iife([ + StatementFactory.constant({ + name: a1.text, + value: spreadClone( + ts.factory.createCallExpression( + access(a, ids.values), + undefined, + undefined, + ), + ), + }), + StatementFactory.constant({ + name: b1.text, + value: spreadClone( + ts.factory.createCallExpression( + access(b, ids.values), + undefined, + undefined, + ), + ), + }), + + ts.factory.createReturnStatement( + compareEvery( + ts.factory.createIdentifier(a1.text), + ts.factory.createIdentifier(b1.text), + _props, + _metadata, + ), + ), + ]); + + return or( + eqeqeq(a, b).expression, + ts.factory.createParenthesizedExpression( + and( + eqeqeq(access(a, ids.size), access(b, ids.size)).expression, + iffeCompare, + ), + ), + ); + } + + function transformTuple( + a: ts.Expression, + b: ts.Expression, + props: Props, + _metadata: Metadata, + tuple: MetadataTuple, + ) { + const compares = tuple.type.elements.map((type, index) => + transform( + indexAccess(a, ts.factory.createIdentifier(index.toString())), + indexAccess(b, ts.factory.createIdentifier(index.toString())), + props, + type, + ), + ); + return or(eqeqeq(a, b).expression, mergeWithAmp(compares, true)); + } + + function compareEvery( + a: ts.Expression, + b: ts.Expression, + props: Props, + metadata?: Metadata, + ) { + return or( + eqeqeq(a, b).expression, + ts.factory.createParenthesizedExpression( + and( + eqeqeq(access(a, ids.length), access(b, ids.length)).expression, + ts.factory.createCallExpression(access(a, ids.every), undefined, [ + compareItem(b, props, metadata), + ]), + ), + ), + ); + } + + const natviesEququq = ["String", "Boolean", "Number", "Symbol", "BigInt"]; + function transformNatives( + a: ts.Expression, + b: ts.Expression, + props: Props, + native: MetadataNative, + ) { + if (natviesEququq.includes(native.name)) { + return eqeqeq(a, b).expression; + } + if (native.name === "Date") { + return eqeqeq( + ts.factory.createCallExpression(ids.String, undefined, [a]), + ts.factory.createCallExpression(ids.String, undefined, [b]), + ).expression; + } + + if (native.name === "ArrayBuffer" || native.name === "SharedArrayBuffer") { + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `SharedArrayBuffer and ArrayBuffer types are unsupported to compare ${props.type.getSymbol()?.getName()}.`, + }); + } + if (native.name.includes("Array")) { + return compareEvery(a, b, props); + } + + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `${native.name} type is unsupported to compare ${props.type.getSymbol()?.getName()}.`, + }); + } + function transformArray( + a: ts.Expression, + b: ts.Expression, + props: Props, + array: MetadataArray, + ) { + if (array.type.recursive) { + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `Detected recusion type ${props.type.getSymbol()?.getName()} -> ${array.type.name}.`, + }); + } + return compareEvery(a, b, props, array.type.value); + } + + // function instaceof(a: ts.Expression, b: ts.Expression) { + // return ts.factory.createBinaryExpression( + // a, + // ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword), + // b, + // ); + // } + + // function typeOf(a: ts.Expression, b: ts.Expression) { + // return eqeqeq(ts.factory.createTypeOfExpression(a), b).expression; + // } + + function isArray(a: ts.Expression) { + return ts.factory.createCallExpression( + access(ids.Array, ids.isArray), + undefined, + [a], + ); + } + + // function isFunctionProperty(node: ts.PropertyDeclaration): boolean { + // if (ts.isMethodSignature(node)) { + // return true; + // } + // if (node.initializer) { + // if ( + // ts.isArrowFunction(node.initializer) || + // ts.isFunctionExpression(node.initializer) + // ) { + // return true; + // } + // } + // + // if (node.type) { + // if (ts.isFunctionTypeNode(node.type)) { + // return true; + // } + // } + // return false; + // } + + function transform( + a: ts.Expression, + b: ts.Expression, + props: Props, + metadata: Metadata, + ): ts.Expression { + if (metadata.any) { + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `Detected any type ${props.type.getSymbol()?.getName()}. It can't be supported for static equals.`, + }); + } + if (metadata.size() > 1) { + const compares: ts.Expression[] = []; + + if ( + metadata.constants.length > 0 || + metadata.atomics.length > 0 || + metadata.functions.length > 0 + ) { + compares.push(eqeqeq(a, b).expression); + } + if (metadata.maps.length > 0) { + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `Union type for Set are unsupported to compare ${props.type.getSymbol()?.getName()}.`, + }); + // compares.push( + // and( + // instaceof(a, ids.Map), + // mergeWithBar( + // metadata.maps.map((element) => + // transformIterable(a, b, props, element.value), + // ), + // ), + // ), + // ); + } + + if (metadata.sets.length > 0) { + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `Union type for Set are unsupported to compare ${props.type.getSymbol()?.getName()}.`, + }); + // compares.push( + // and( + // instaceof(a, ids.Set), + // mergeWithBar( + // metadata.sets.map((element) => + // transformIterable(a, b, props, element.value), + // ), + // ), + // ), + // ); + } + if (metadata.objects.length > 0) { + throw new TransformerError({ + code: `typia.compare.equals()`, + message: `Union type for Objects are unsupported to compare ${props.type.getSymbol()?.getName()}.`, + }); + // compares.push( + // and( + // typeOf(a, ids.object), + // mergeWithBar( + // metadata.objects.map((element) => + // transformObject(a, b, props, metadata, element), + // ), + // ), + // ), + // ); + } + if (metadata.arrays.length > 0) { + compares.push( + and( + isArray(a), + mergeWithBar( + metadata.arrays.map((element) => + transformArray(a, b, props, element), + ), + ), + ), + ); + } + + // if (metadata.functions.length > 0) { + // compares.push( + // and( + // typeOf(a, ids.funtion), + // mergeWithBar( + // metadata.functions.map((element) => + // eqeqeq(a, a).expression + // ), + // ), + // ), + // ); + // } + + return mergeWithBar(compares); + } + + if (metadata.atomics[0] || metadata.constants[0] || metadata.functions[0]) { + return eqeqeq(a, b).expression; + } + + if (metadata.objects[0]) { + return transformObject(a, b, props, metadata, metadata.objects[0]); + } + + if (metadata.tuples[0]) { + return transformTuple(a, b, props, metadata, metadata.tuples[0]); + } + + if (metadata.arrays[0]) { + return transformArray(a, b, props, metadata.arrays[0]); + } else if (metadata.sets[0]) { + return transformIterable(a, b, props, metadata.sets[0].value); + } else if (metadata.maps[0]) { + return transformIterable(a, b, props, metadata.maps[0].value); + } + + if (metadata.natives[0]) { + return transformNatives(a, b, props, metadata.natives[0]); + } + + return eqeqeq(a, b).expression; + } +} diff --git a/src/schemas/metadata/IMetadata.ts b/src/schemas/metadata/IMetadata.ts index 4eb8486304..70c5c811a0 100644 --- a/src/schemas/metadata/IMetadata.ts +++ b/src/schemas/metadata/IMetadata.ts @@ -16,6 +16,7 @@ export interface IMetadata { required: boolean; optional: boolean; nullable: boolean; + class: boolean; functions: IMetadataFunction[]; atomics: IMetadataAtomic[]; diff --git a/src/schemas/metadata/Metadata.ts b/src/schemas/metadata/Metadata.ts index 4c78d8a0f6..e05cc38f1e 100644 --- a/src/schemas/metadata/Metadata.ts +++ b/src/schemas/metadata/Metadata.ts @@ -24,6 +24,7 @@ export class Metadata { public required: boolean; public optional: boolean; public nullable: boolean; + public class: boolean; public escaped: MetadataEscaped | null; public atomics: MetadataAtomic[]; @@ -60,6 +61,7 @@ export class Metadata { this.optional = props.optional; this.nullable = props.nullable; this.functions = props.functions; + this.class = props.class; this.escaped = props.escaped; this.atomics = props.atomics; @@ -93,6 +95,7 @@ export class Metadata { nullable: false, required: true, optional: false, + class: false, escaped: null, constants: [], @@ -119,6 +122,7 @@ export class Metadata { required: this.required, optional: this.optional, nullable: this.nullable, + class: this.class, functions: this.functions.map((f) => f.toJSON()), atomics: this.atomics.map((a) => a.toJSON()), @@ -144,6 +148,7 @@ export class Metadata { required: meta.required, optional: meta.optional, nullable: meta.nullable, + class: meta.class, functions: meta.functions.map((f) => MetadataFunction.from(f, dict)), constants: meta.constants.map(MetadataConstant.from), @@ -522,6 +527,7 @@ export namespace Metadata { nullable: x.nullable || y.nullable, required: x.required && y.required, optional: x.optional || y.optional, + class: x.class || y.class, functions: x.functions.length ? x.functions : y.functions, // @todo escaped: x.escaped !== null && y.escaped !== null diff --git a/src/transformers/CallExpressionTransformer.ts b/src/transformers/CallExpressionTransformer.ts index 27d6933b08..8389c7bea2 100644 --- a/src/transformers/CallExpressionTransformer.ts +++ b/src/transformers/CallExpressionTransformer.ts @@ -24,6 +24,7 @@ import { CreateValidateTransformer } from "./features/CreateValidateTransformer" import { IsTransformer } from "./features/IsTransformer"; import { RandomTransformer } from "./features/RandomTransformer"; import { ValidateTransformer } from "./features/ValidateTransformer"; +import { CompareEqualsTransformer } from "./features/compare/CompareEqualsTransformer"; import { CreateHttpAssertFormDataTransformer } from "./features/http/CreateHttpAssertFormDataTransformer"; import { CreateHttpAssertHeadersTransformer } from "./features/http/CreateHttpAssertHeadersTransformer"; import { CreateHttpAssertQueryTransformer } from "./features/http/CreateHttpAssertQueryTransformer"; @@ -427,6 +428,9 @@ const FUNCTORS: Record Task>> = { createValidateStringify: () => JsonCreateValidateStringifyTransformer.transform, }, + compare: { + equals: () => CompareEqualsTransformer.transform, + }, protobuf: { // SCHEMA message: () => ProtobufMessageTransformer.transform, diff --git a/src/transformers/features/compare/CompareEqualsTransformer.ts b/src/transformers/features/compare/CompareEqualsTransformer.ts new file mode 100644 index 0000000000..1115d54b6e --- /dev/null +++ b/src/transformers/features/compare/CompareEqualsTransformer.ts @@ -0,0 +1,13 @@ +import { CompareEqualsProgrammer } from "../../../programmers/compare/CompareEqualsProgrammer"; + +import { ITransformProps } from "../../ITransformProps"; +import { GenericTransformer } from "../../internal/GenericTransformer"; + +export namespace CompareEqualsTransformer { + export const transform = (props: ITransformProps) => + GenericTransformer.scalar({ + ...props, + method: "compare.equals", + write: CompareEqualsProgrammer.write, + }); +} diff --git a/test/build/internal/TestFeature.ts b/test/build/internal/TestFeature.ts index 43ddac1ca7..510173c23b 100644 --- a/test/build/internal/TestFeature.ts +++ b/test/build/internal/TestFeature.ts @@ -1,3 +1,4 @@ +import { write_compare } from "../writers/write_compare"; import { write_functional } from "../writers/write_functional"; import { write_functionalAsync } from "../writers/write_functionalAsync"; import { write_notation } from "../writers/write_notation"; @@ -411,6 +412,22 @@ export namespace TestFeature { .flat(), //---- + // COMPARES + //---- + ...["equals"] + .map((method) => [ + { + module: "compare", + method, + creatable: false, + spoilable: true, + programmer() { + return write_compare(this)(false); + }, + }, + ]) + .flat(), + //---- // MISCELLANEOUS //---- { diff --git a/test/build/template.ts b/test/build/template.ts index 4d6342cbc5..0e1eabc152 100644 --- a/test/build/template.ts +++ b/test/build/template.ts @@ -143,6 +143,10 @@ function script( async function main(): Promise { process.chdir(__dirname + "/.."); + const featureFilter = process.argv + .find((a) => a.startsWith("--features")) + ?.split("=")[1]; + // NORMAL FEATURES const structures: TestStructure[] = await load(); const featureList: TestFeature[] = [ @@ -154,7 +158,10 @@ async function main(): Promise { custom: true as const, })), ]; - for (const feature of featureList) { + for await (const feature of featureList) { + if (featureFilter && feature.module !== featureFilter) { + continue; + } await generate(feature, structures, false); if (feature.creatable) await generate(feature, structures, true); } diff --git a/test/build/writers/write_compare.ts b/test/build/writers/write_compare.ts new file mode 100644 index 0000000000..db4fb33135 --- /dev/null +++ b/test/build/writers/write_compare.ts @@ -0,0 +1,54 @@ +import { StringUtil } from "../utils/StringUtil"; + +// import typia from "typia"; +// +// import { _test_compare_equals } from "../../internal/_test_compare_equals"; +// import { AtomicSimple } from "../../structures/AtomicSimple"; +// +// export const test_compare_equals_AtomicSimple = _test_compare_equals( +// "AtomicSimple", +// )(AtomicSimple)((a, b) => +// typia.compare.equals(a, b), +// ); + +export const write_compare = + (p: IProps) => (create: boolean) => (structure: string) => + `import typia from "typia"; + +import { _${file({ + ...p, + method: p.method.startsWith("create") + ? StringUtil.localize(p.method.replace("create", "")) + : p.method, + })} } from "../../internal/_${file({ + ...p, + method: p.method.startsWith("create") + ? StringUtil.localize(p.method.replace("create", "")) + : p.method, + })}"; +import { ${structure} } from "../../structures/${structure}"; + +export const ${file(p)}_${structure} = _${file({ + ...p, + method: p.method.startsWith("create") + ? StringUtil.localize(p.method.replace("create", "")) + : p.method, + })}( + "${structure}", +)<${structure}>( + ${structure} +)(${functor(p)(create)(structure)}); +`; + +const file = (p: IProps) => "test_" + method(p).replace(".", "_"); +const method = (p: IProps) => + [p.module, p.method].filter((str) => !!str).join("."); +const functor = (p: IProps) => (create: boolean) => (structure: string) => + create + ? `typia.${method(p)}<${structure}>()` + : `(a, b) => typia.${method(p)}<${structure}>(a, b)`; + +interface IProps { + module: string | null; + method: string; +} diff --git a/test/generate/input/generate_comare.ts b/test/generate/input/generate_comare.ts new file mode 100644 index 0000000000..e3dd174cab --- /dev/null +++ b/test/generate/input/generate_comare.ts @@ -0,0 +1,136 @@ +import typia from "typia"; + +interface ISomething { + id: string; + age: number; +} + +export const objects = typia.compare.equals( + { id: "1", age: 2 }, + { id: "1", age: 2 }, +); + +console.assert( + typia.compare.equals(new Map([["foo", 1]]), new Map([["foo", 1]])), + "Map compares should be equal", +); +console.assert( + typia.compare.equals(new Set([["foo", 1]]), new Set([["foo", 1]])), + "Set compares should be equal", +); + +// export const matrix = typia.compare.equals( +// [[[1, 2, 3]]], +// [[[1, 2, 3]]], +// ); + +// export const matrix = typia.compare.equals( +// [[1, 2, 3]], +// [[1, 2, 3]], +// ); + +// interface ICategory { +// children: ICategory[]; +// id: number; +// code: string; +// sequence: number; +// } +// export const recurcive = typia.compare.equals(1 as any, 1 as any); + +// export const arrays = typia.compare.equals([1, 2, 3], [1, 2, 3]); + +// export const tuple = typia.compare.equals< +// [number, string, { foo: string; bar?: string }] +// >( +// [1, "foo", { foo: "bar", bar: "baz" }], +// [1, "foo", { foo: "bar", bar: "baz" }], +// ); +// +// export const nested = typia.compare.equals<{ +// id: number; +// items: Array<{ name: string }>; +// }>({ id: 1, items: [{ name: "foo" }] }, { id: 1, items: [{ name: "foo" }] }); +// +// export const union = typia.compare.equals>([1], [1]); +// export const unionNested = typia.compare.equals< +// Array<{ foo: string } | { bar: number }> +// >([{ foo: "1" }], [{ foo: "1" }]); + +// export type Union = false | 1 | 2 | "three" | "four" | { key: "key" }; +// export function union(): Union[] { +// return [false, 1, 2, "three", "four", { key: "key" }]; +// } +// export const arrayUnioun = typia.compare.equals(union(), union()); +// console.assert(arrayUnioun, union.name); +// +// typia.compare.equals([{ a: 1 }], [{ a: 1 }]); + +// export type MegaUnion = +// | number +// | Uint8Array +// | Map +// | [string, string] +// | [boolean, number, number] +// | number[] +// | boolean[] +// | []; +// +// export function megaUnion(): MegaUnion[] { +// return [ +// 3, +// // new Uint8Array(), +// new Map([["foo", 1]]), +// // ["one", "two"], +// // [false, 1, 2], +// // [1, 2, 3], +// // [true, false], +// // [], +// ]; +// } +// +// export const arrayMegaUnioun = typia.compare.equals(megaUnion(), megaUnion()); +// console.assert(arrayMegaUnioun, megaUnion.name); + +// type SpecificKeys = { +// "foo-bar-baz": number; +// }; +// export const specificKeys = typia.compare.equals( +// { "foo-bar-baz": 1 }, +// { "foo-bar-baz": 2 }, +// ); + +// class FooClass { +// foo: string = ""; +// method() {} +// } +// +// export const fooClass = typia.compare.equals(new FooClass(), new FooClass()); +// +// export const fooNestedClass = typia.compare.equals( +// { foo: new FooClass() }, +// { foo: new FooClass() }, +// ); + +// export const sets = typia.compare.equals( +// new Set([{ foo: 1 }]), +// new Set([{ foo: 1 }]), +// ); +// +// export enum LanguageCode { +// Arabic = "ar", +// ChineseSimp = "zh-Hans", +// ChineseTrad = "zh-Hant", +// English = "en", +// French = "fr", +// German = "de", +// Japanese = "ja", +// Korean = "ko", // <-- this line +// Portuguese = "pt", +// Russian = "ru", +// } +// +// export type DynamicEnumeration = { +// [P in LanguageCode]?: string; +// }; +// +// export const dyn = typia.compare.equals({}, {}); diff --git a/test/generate/output/generate_comare.ts b/test/generate/output/generate_comare.ts new file mode 100644 index 0000000000..9d5501098d --- /dev/null +++ b/test/generate/output/generate_comare.ts @@ -0,0 +1,66 @@ +import typia from "typia"; + +interface ISomething { + id: string; + age: number; +} +export const objects = (() => { + return (a: ISomething, b: ISomething): boolean => { + return a === b || (a.id === b.id && a.age === b.age); + }; +})()({ id: "1", age: 2 }, { id: "1", age: 2 }); +console.assert( + (() => { + return (a: Map, b: Map): boolean => { + return ( + a === b || + (a.size === b.size && + (() => { + const a1 = Array.from(a.values()); + const b1 = Array.from(b.values()); + return ( + a1 === b1 || + (a1.length === b1.length && + a1.every((item: any, index_1: any) => { + return item === (b1 as any)[index_1]!; + })) + ); + })()) + ); + }; + })()(new Map([["foo", 1]]), new Map([["foo", 1]])), + "Map compares should be equal", +); +console.assert( + (() => { + return ( + a: Set<(string | number)[]>, + b: Set<(string | number)[]>, + ): boolean => { + return ( + a === b || + (a.size === b.size && + (() => { + const a1 = Array.from(a.values()); + const b1 = Array.from(b.values()); + return ( + a1 === b1 || + (a1.length === b1.length && + a1.every((item: any, index_2: any) => { + return ( + item === (b1 as any)[index_2]! || + (item.length === (b1 as any)[index_2]!.length && + item.every((item: any, index_3: any) => { + return ( + item === ((b1 as any)[index_2]! as any)[index_3]! + ); + })) + ); + })) + ); + })()) + ); + }; + })()(new Set([["foo", 1]]), new Set([["foo", 1]])), + "Set compares should be equal", +); diff --git a/test/package.json b/test/package.json index 109e6587fb..6f2cc83172 100644 --- a/test/package.json +++ b/test/package.json @@ -17,6 +17,7 @@ "prettier": "prettier ./src/**/*.ts --write", "setup": "node build/setup.js", "start": "node bin", + "dev": "ts-node src", "debug": "ts-node debug", "issue": "ts-node issue", "template": "ts-node --project build/tsconfig.json build/template.ts" @@ -56,4 +57,4 @@ "uuid": "^9.0.1", "typia": "../" } -} \ No newline at end of file +} diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayAny.ts b/test/src/features/compare.equals/test_compare_equals_ArrayAny.ts new file mode 100644 index 0000000000..f15da6fe07 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayAny.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayAny } from "../../structures/ArrayAny"; + +export const test_compare_equals_ArrayAny = _test_compare_equals( + "ArrayAny", +)( + ArrayAny +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayAtomicAlias.ts b/test/src/features/compare.equals/test_compare_equals_ArrayAtomicAlias.ts new file mode 100644 index 0000000000..9af2fbd035 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayAtomicAlias.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayAtomicAlias } from "../../structures/ArrayAtomicAlias"; + +export const test_compare_equals_ArrayAtomicAlias = _test_compare_equals( + "ArrayAtomicAlias", +)( + ArrayAtomicAlias +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayAtomicSimple.ts b/test/src/features/compare.equals/test_compare_equals_ArrayAtomicSimple.ts new file mode 100644 index 0000000000..e437caa488 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayAtomicSimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayAtomicSimple } from "../../structures/ArrayAtomicSimple"; + +export const test_compare_equals_ArrayAtomicSimple = _test_compare_equals( + "ArrayAtomicSimple", +)( + ArrayAtomicSimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayHierarchical.ts b/test/src/features/compare.equals/test_compare_equals_ArrayHierarchical.ts new file mode 100644 index 0000000000..bf18642c6b --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayHierarchical.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayHierarchical } from "../../structures/ArrayHierarchical"; + +export const test_compare_equals_ArrayHierarchical = _test_compare_equals( + "ArrayHierarchical", +)( + ArrayHierarchical +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayHierarchicalPointer.ts b/test/src/features/compare.equals/test_compare_equals_ArrayHierarchicalPointer.ts new file mode 100644 index 0000000000..35ee696870 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayHierarchicalPointer.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayHierarchicalPointer } from "../../structures/ArrayHierarchicalPointer"; + +export const test_compare_equals_ArrayHierarchicalPointer = _test_compare_equals( + "ArrayHierarchicalPointer", +)( + ArrayHierarchicalPointer +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayMatrix.ts b/test/src/features/compare.equals/test_compare_equals_ArrayMatrix.ts new file mode 100644 index 0000000000..1c07abc33e --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayMatrix.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayMatrix } from "../../structures/ArrayMatrix"; + +export const test_compare_equals_ArrayMatrix = _test_compare_equals( + "ArrayMatrix", +)( + ArrayMatrix +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayRecursive.ts b/test/src/features/compare.equals/test_compare_equals_ArrayRecursive.ts new file mode 100644 index 0000000000..3bdd121bf3 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayRecursive.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayRecursive } from "../../structures/ArrayRecursive"; + +export const test_compare_equals_ArrayRecursive = _test_compare_equals( + "ArrayRecursive", +)( + ArrayRecursive +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionExplicit.ts b/test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionExplicit.ts new file mode 100644 index 0000000000..6f5f475a41 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionExplicit.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayRecursiveUnionExplicit } from "../../structures/ArrayRecursiveUnionExplicit"; + +export const test_compare_equals_ArrayRecursiveUnionExplicit = _test_compare_equals( + "ArrayRecursiveUnionExplicit", +)( + ArrayRecursiveUnionExplicit +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionExplicitPointer.ts b/test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionExplicitPointer.ts new file mode 100644 index 0000000000..f966d9b696 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionExplicitPointer.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayRecursiveUnionExplicitPointer } from "../../structures/ArrayRecursiveUnionExplicitPointer"; + +export const test_compare_equals_ArrayRecursiveUnionExplicitPointer = _test_compare_equals( + "ArrayRecursiveUnionExplicitPointer", +)( + ArrayRecursiveUnionExplicitPointer +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionImplicit.ts b/test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionImplicit.ts new file mode 100644 index 0000000000..28b3d81b97 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionImplicit.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayRecursiveUnionImplicit } from "../../structures/ArrayRecursiveUnionImplicit"; + +export const test_compare_equals_ArrayRecursiveUnionImplicit = _test_compare_equals( + "ArrayRecursiveUnionImplicit", +)( + ArrayRecursiveUnionImplicit +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedNullable.ts b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedNullable.ts new file mode 100644 index 0000000000..cd970f7390 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedNullable.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayRepeatedNullable } from "../../structures/ArrayRepeatedNullable"; + +export const test_compare_equals_ArrayRepeatedNullable = _test_compare_equals( + "ArrayRepeatedNullable", +)( + ArrayRepeatedNullable +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedOptional.ts b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedOptional.ts new file mode 100644 index 0000000000..3b331a26df --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedOptional.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayRepeatedOptional } from "../../structures/ArrayRepeatedOptional"; + +export const test_compare_equals_ArrayRepeatedOptional = _test_compare_equals( + "ArrayRepeatedOptional", +)( + ArrayRepeatedOptional +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedRequired.ts b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedRequired.ts new file mode 100644 index 0000000000..58a78babe5 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedRequired.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayRepeatedRequired } from "../../structures/ArrayRepeatedRequired"; + +export const test_compare_equals_ArrayRepeatedRequired = _test_compare_equals( + "ArrayRepeatedRequired", +)( + ArrayRepeatedRequired +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedUnion.ts b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedUnion.ts new file mode 100644 index 0000000000..a408e13f63 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayRepeatedUnion } from "../../structures/ArrayRepeatedUnion"; + +export const test_compare_equals_ArrayRepeatedUnion = _test_compare_equals( + "ArrayRepeatedUnion", +)( + ArrayRepeatedUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedUnionWithTuple.ts b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedUnionWithTuple.ts new file mode 100644 index 0000000000..81c43bcb8c --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayRepeatedUnionWithTuple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayRepeatedUnionWithTuple } from "../../structures/ArrayRepeatedUnionWithTuple"; + +export const test_compare_equals_ArrayRepeatedUnionWithTuple = _test_compare_equals( + "ArrayRepeatedUnionWithTuple", +)( + ArrayRepeatedUnionWithTuple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArraySimple.ts b/test/src/features/compare.equals/test_compare_equals_ArraySimple.ts new file mode 100644 index 0000000000..9c80dd58d2 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArraySimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArraySimple } from "../../structures/ArraySimple"; + +export const test_compare_equals_ArraySimple = _test_compare_equals( + "ArraySimple", +)( + ArraySimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobuf.ts b/test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobuf.ts new file mode 100644 index 0000000000..0bf3f2653a --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobuf.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArraySimpleProtobuf } from "../../structures/ArraySimpleProtobuf"; + +export const test_compare_equals_ArraySimpleProtobuf = _test_compare_equals( + "ArraySimpleProtobuf", +)( + ArraySimpleProtobuf +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobufNullable.ts b/test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobufNullable.ts new file mode 100644 index 0000000000..e3e7ebe370 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobufNullable.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArraySimpleProtobufNullable } from "../../structures/ArraySimpleProtobufNullable"; + +export const test_compare_equals_ArraySimpleProtobufNullable = _test_compare_equals( + "ArraySimpleProtobufNullable", +)( + ArraySimpleProtobufNullable +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobufOptional.ts b/test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobufOptional.ts new file mode 100644 index 0000000000..7f560b92fc --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobufOptional.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArraySimpleProtobufOptional } from "../../structures/ArraySimpleProtobufOptional"; + +export const test_compare_equals_ArraySimpleProtobufOptional = _test_compare_equals( + "ArraySimpleProtobufOptional", +)( + ArraySimpleProtobufOptional +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ArrayUnion.ts b/test/src/features/compare.equals/test_compare_equals_ArrayUnion.ts new file mode 100644 index 0000000000..c9c9148418 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ArrayUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ArrayUnion } from "../../structures/ArrayUnion"; + +export const test_compare_equals_ArrayUnion = _test_compare_equals( + "ArrayUnion", +)( + ArrayUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_AtomicAlias.ts b/test/src/features/compare.equals/test_compare_equals_AtomicAlias.ts new file mode 100644 index 0000000000..70e8b43816 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_AtomicAlias.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { AtomicAlias } from "../../structures/AtomicAlias"; + +export const test_compare_equals_AtomicAlias = _test_compare_equals( + "AtomicAlias", +)( + AtomicAlias +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_AtomicClass.ts b/test/src/features/compare.equals/test_compare_equals_AtomicClass.ts new file mode 100644 index 0000000000..d2a5a6b98a --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_AtomicClass.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { AtomicClass } from "../../structures/AtomicClass"; + +export const test_compare_equals_AtomicClass = _test_compare_equals( + "AtomicClass", +)( + AtomicClass +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_AtomicIntersection.ts b/test/src/features/compare.equals/test_compare_equals_AtomicIntersection.ts new file mode 100644 index 0000000000..aea1f394c1 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_AtomicIntersection.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { AtomicIntersection } from "../../structures/AtomicIntersection"; + +export const test_compare_equals_AtomicIntersection = _test_compare_equals( + "AtomicIntersection", +)( + AtomicIntersection +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_AtomicSimple.ts b/test/src/features/compare.equals/test_compare_equals_AtomicSimple.ts new file mode 100644 index 0000000000..3508159d4c --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_AtomicSimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { AtomicSimple } from "../../structures/AtomicSimple"; + +export const test_compare_equals_AtomicSimple = _test_compare_equals( + "AtomicSimple", +)( + AtomicSimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_AtomicUnion.ts b/test/src/features/compare.equals/test_compare_equals_AtomicUnion.ts new file mode 100644 index 0000000000..4fb44b326c --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_AtomicUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { AtomicUnion } from "../../structures/AtomicUnion"; + +export const test_compare_equals_AtomicUnion = _test_compare_equals( + "AtomicUnion", +)( + AtomicUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ClassClosure.ts b/test/src/features/compare.equals/test_compare_equals_ClassClosure.ts new file mode 100644 index 0000000000..dcc9c515e6 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ClassClosure.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ClassClosure } from "../../structures/ClassClosure"; + +export const test_compare_equals_ClassClosure = _test_compare_equals( + "ClassClosure", +)( + ClassClosure +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ClassGetter.ts b/test/src/features/compare.equals/test_compare_equals_ClassGetter.ts new file mode 100644 index 0000000000..c0158c71f5 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ClassGetter.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ClassGetter } from "../../structures/ClassGetter"; + +export const test_compare_equals_ClassGetter = _test_compare_equals( + "ClassGetter", +)( + ClassGetter +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ClassMethod.ts b/test/src/features/compare.equals/test_compare_equals_ClassMethod.ts new file mode 100644 index 0000000000..807fb87bdf --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ClassMethod.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ClassMethod } from "../../structures/ClassMethod"; + +export const test_compare_equals_ClassMethod = _test_compare_equals( + "ClassMethod", +)( + ClassMethod +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ClassNonPublic.ts b/test/src/features/compare.equals/test_compare_equals_ClassNonPublic.ts new file mode 100644 index 0000000000..6e637a2cd1 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ClassNonPublic.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ClassNonPublic } from "../../structures/ClassNonPublic"; + +export const test_compare_equals_ClassNonPublic = _test_compare_equals( + "ClassNonPublic", +)( + ClassNonPublic +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ClassPropertyAssignment.ts b/test/src/features/compare.equals/test_compare_equals_ClassPropertyAssignment.ts new file mode 100644 index 0000000000..d1bcf4ced8 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ClassPropertyAssignment.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ClassPropertyAssignment } from "../../structures/ClassPropertyAssignment"; + +export const test_compare_equals_ClassPropertyAssignment = _test_compare_equals( + "ClassPropertyAssignment", +)( + ClassPropertyAssignment +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagArray.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagArray.ts new file mode 100644 index 0000000000..f253830d7c --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagArray.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagArray } from "../../structures/CommentTagArray"; + +export const test_compare_equals_CommentTagArray = _test_compare_equals( + "CommentTagArray", +)( + CommentTagArray +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagArrayUnion.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagArrayUnion.ts new file mode 100644 index 0000000000..7afbf5b397 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagArrayUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagArrayUnion } from "../../structures/CommentTagArrayUnion"; + +export const test_compare_equals_CommentTagArrayUnion = _test_compare_equals( + "CommentTagArrayUnion", +)( + CommentTagArrayUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagAtomicUnion.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagAtomicUnion.ts new file mode 100644 index 0000000000..de21274781 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagAtomicUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagAtomicUnion } from "../../structures/CommentTagAtomicUnion"; + +export const test_compare_equals_CommentTagAtomicUnion = _test_compare_equals( + "CommentTagAtomicUnion", +)( + CommentTagAtomicUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagBigInt.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagBigInt.ts new file mode 100644 index 0000000000..37d42701a4 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagBigInt.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagBigInt } from "../../structures/CommentTagBigInt"; + +export const test_compare_equals_CommentTagBigInt = _test_compare_equals( + "CommentTagBigInt", +)( + CommentTagBigInt +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagDefault.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagDefault.ts new file mode 100644 index 0000000000..c36c728c79 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagDefault.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagDefault } from "../../structures/CommentTagDefault"; + +export const test_compare_equals_CommentTagDefault = _test_compare_equals( + "CommentTagDefault", +)( + CommentTagDefault +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagFormat.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagFormat.ts new file mode 100644 index 0000000000..c20388bc1f --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagFormat.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagFormat } from "../../structures/CommentTagFormat"; + +export const test_compare_equals_CommentTagFormat = _test_compare_equals( + "CommentTagFormat", +)( + CommentTagFormat +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagInfinite.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagInfinite.ts new file mode 100644 index 0000000000..2692dd289a --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagInfinite.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagInfinite } from "../../structures/CommentTagInfinite"; + +export const test_compare_equals_CommentTagInfinite = _test_compare_equals( + "CommentTagInfinite", +)( + CommentTagInfinite +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagLength.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagLength.ts new file mode 100644 index 0000000000..708e691d21 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagLength.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagLength } from "../../structures/CommentTagLength"; + +export const test_compare_equals_CommentTagLength = _test_compare_equals( + "CommentTagLength", +)( + CommentTagLength +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagNaN.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagNaN.ts new file mode 100644 index 0000000000..ad253585d6 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagNaN.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagNaN } from "../../structures/CommentTagNaN"; + +export const test_compare_equals_CommentTagNaN = _test_compare_equals( + "CommentTagNaN", +)( + CommentTagNaN +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagObjectUnion.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagObjectUnion.ts new file mode 100644 index 0000000000..2be7d9bc97 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagObjectUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagObjectUnion } from "../../structures/CommentTagObjectUnion"; + +export const test_compare_equals_CommentTagObjectUnion = _test_compare_equals( + "CommentTagObjectUnion", +)( + CommentTagObjectUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagPattern.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagPattern.ts new file mode 100644 index 0000000000..df8eae7777 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagPattern.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagPattern } from "../../structures/CommentTagPattern"; + +export const test_compare_equals_CommentTagPattern = _test_compare_equals( + "CommentTagPattern", +)( + CommentTagPattern +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagRange.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagRange.ts new file mode 100644 index 0000000000..a7b88c218b --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagRange.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagRange } from "../../structures/CommentTagRange"; + +export const test_compare_equals_CommentTagRange = _test_compare_equals( + "CommentTagRange", +)( + CommentTagRange +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagRangeBigInt.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagRangeBigInt.ts new file mode 100644 index 0000000000..b1a25cebe6 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagRangeBigInt.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagRangeBigInt } from "../../structures/CommentTagRangeBigInt"; + +export const test_compare_equals_CommentTagRangeBigInt = _test_compare_equals( + "CommentTagRangeBigInt", +)( + CommentTagRangeBigInt +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagType.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagType.ts new file mode 100644 index 0000000000..0e8d55a43f --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagType.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagType } from "../../structures/CommentTagType"; + +export const test_compare_equals_CommentTagType = _test_compare_equals( + "CommentTagType", +)( + CommentTagType +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_CommentTagTypeBigInt.ts b/test/src/features/compare.equals/test_compare_equals_CommentTagTypeBigInt.ts new file mode 100644 index 0000000000..e8d2e558d0 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_CommentTagTypeBigInt.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { CommentTagTypeBigInt } from "../../structures/CommentTagTypeBigInt"; + +export const test_compare_equals_CommentTagTypeBigInt = _test_compare_equals( + "CommentTagTypeBigInt", +)( + CommentTagTypeBigInt +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ConstantAtomicAbsorbed.ts b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicAbsorbed.ts new file mode 100644 index 0000000000..0f18fbea46 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicAbsorbed.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ConstantAtomicAbsorbed } from "../../structures/ConstantAtomicAbsorbed"; + +export const test_compare_equals_ConstantAtomicAbsorbed = _test_compare_equals( + "ConstantAtomicAbsorbed", +)( + ConstantAtomicAbsorbed +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ConstantAtomicSimple.ts b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicSimple.ts new file mode 100644 index 0000000000..3278967a19 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicSimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ConstantAtomicSimple } from "../../structures/ConstantAtomicSimple"; + +export const test_compare_equals_ConstantAtomicSimple = _test_compare_equals( + "ConstantAtomicSimple", +)( + ConstantAtomicSimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ConstantAtomicTagged.ts b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicTagged.ts new file mode 100644 index 0000000000..24ea48ba47 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicTagged.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ConstantAtomicTagged } from "../../structures/ConstantAtomicTagged"; + +export const test_compare_equals_ConstantAtomicTagged = _test_compare_equals( + "ConstantAtomicTagged", +)( + ConstantAtomicTagged +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ConstantAtomicUnion.ts b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicUnion.ts new file mode 100644 index 0000000000..b74d53af77 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ConstantAtomicUnion } from "../../structures/ConstantAtomicUnion"; + +export const test_compare_equals_ConstantAtomicUnion = _test_compare_equals( + "ConstantAtomicUnion", +)( + ConstantAtomicUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ConstantAtomicWrapper.ts b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicWrapper.ts new file mode 100644 index 0000000000..9fa2260246 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ConstantAtomicWrapper.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ConstantAtomicWrapper } from "../../structures/ConstantAtomicWrapper"; + +export const test_compare_equals_ConstantAtomicWrapper = _test_compare_equals( + "ConstantAtomicWrapper", +)( + ConstantAtomicWrapper +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ConstantConstEnumeration.ts b/test/src/features/compare.equals/test_compare_equals_ConstantConstEnumeration.ts new file mode 100644 index 0000000000..3f05d913a8 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ConstantConstEnumeration.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ConstantConstEnumeration } from "../../structures/ConstantConstEnumeration"; + +export const test_compare_equals_ConstantConstEnumeration = _test_compare_equals( + "ConstantConstEnumeration", +)( + ConstantConstEnumeration +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ConstantEnumeration.ts b/test/src/features/compare.equals/test_compare_equals_ConstantEnumeration.ts new file mode 100644 index 0000000000..80286ee31a --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ConstantEnumeration.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ConstantEnumeration } from "../../structures/ConstantEnumeration"; + +export const test_compare_equals_ConstantEnumeration = _test_compare_equals( + "ConstantEnumeration", +)( + ConstantEnumeration +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ConstantIntersection.ts b/test/src/features/compare.equals/test_compare_equals_ConstantIntersection.ts new file mode 100644 index 0000000000..7ca7a88f58 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ConstantIntersection.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ConstantIntersection } from "../../structures/ConstantIntersection"; + +export const test_compare_equals_ConstantIntersection = _test_compare_equals( + "ConstantIntersection", +)( + ConstantIntersection +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicArray.ts b/test/src/features/compare.equals/test_compare_equals_DynamicArray.ts new file mode 100644 index 0000000000..32e8e9fb4a --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicArray.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicArray } from "../../structures/DynamicArray"; + +export const test_compare_equals_DynamicArray = _test_compare_equals( + "DynamicArray", +)( + DynamicArray +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicComposite.ts b/test/src/features/compare.equals/test_compare_equals_DynamicComposite.ts new file mode 100644 index 0000000000..6909328745 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicComposite.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicComposite } from "../../structures/DynamicComposite"; + +export const test_compare_equals_DynamicComposite = _test_compare_equals( + "DynamicComposite", +)( + DynamicComposite +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicConstant.ts b/test/src/features/compare.equals/test_compare_equals_DynamicConstant.ts new file mode 100644 index 0000000000..c9d60a8ee1 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicConstant.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicConstant } from "../../structures/DynamicConstant"; + +export const test_compare_equals_DynamicConstant = _test_compare_equals( + "DynamicConstant", +)( + DynamicConstant +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicEnumeration.ts b/test/src/features/compare.equals/test_compare_equals_DynamicEnumeration.ts new file mode 100644 index 0000000000..a5299ef741 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicEnumeration.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicEnumeration } from "../../structures/DynamicEnumeration"; + +export const test_compare_equals_DynamicEnumeration = _test_compare_equals( + "DynamicEnumeration", +)( + DynamicEnumeration +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicJsonValue.ts b/test/src/features/compare.equals/test_compare_equals_DynamicJsonValue.ts new file mode 100644 index 0000000000..55699e4304 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicJsonValue.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicJsonValue } from "../../structures/DynamicJsonValue"; + +export const test_compare_equals_DynamicJsonValue = _test_compare_equals( + "DynamicJsonValue", +)( + DynamicJsonValue +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicNever.ts b/test/src/features/compare.equals/test_compare_equals_DynamicNever.ts new file mode 100644 index 0000000000..4713b299b3 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicNever.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicNever } from "../../structures/DynamicNever"; + +export const test_compare_equals_DynamicNever = _test_compare_equals( + "DynamicNever", +)( + DynamicNever +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicSimple.ts b/test/src/features/compare.equals/test_compare_equals_DynamicSimple.ts new file mode 100644 index 0000000000..ae9e4bdc78 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicSimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicSimple } from "../../structures/DynamicSimple"; + +export const test_compare_equals_DynamicSimple = _test_compare_equals( + "DynamicSimple", +)( + DynamicSimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicTag.ts b/test/src/features/compare.equals/test_compare_equals_DynamicTag.ts new file mode 100644 index 0000000000..f6d4920647 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicTag.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicTag } from "../../structures/DynamicTag"; + +export const test_compare_equals_DynamicTag = _test_compare_equals( + "DynamicTag", +)( + DynamicTag +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicTemplate.ts b/test/src/features/compare.equals/test_compare_equals_DynamicTemplate.ts new file mode 100644 index 0000000000..5179a84e1b --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicTemplate.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicTemplate } from "../../structures/DynamicTemplate"; + +export const test_compare_equals_DynamicTemplate = _test_compare_equals( + "DynamicTemplate", +)( + DynamicTemplate +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicTree.ts b/test/src/features/compare.equals/test_compare_equals_DynamicTree.ts new file mode 100644 index 0000000000..c46d327272 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicTree.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicTree } from "../../structures/DynamicTree"; + +export const test_compare_equals_DynamicTree = _test_compare_equals( + "DynamicTree", +)( + DynamicTree +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicUndefined.ts b/test/src/features/compare.equals/test_compare_equals_DynamicUndefined.ts new file mode 100644 index 0000000000..c472cb275b --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicUndefined.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicUndefined } from "../../structures/DynamicUndefined"; + +export const test_compare_equals_DynamicUndefined = _test_compare_equals( + "DynamicUndefined", +)( + DynamicUndefined +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_DynamicUnion.ts b/test/src/features/compare.equals/test_compare_equals_DynamicUnion.ts new file mode 100644 index 0000000000..369cfffdc1 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_DynamicUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { DynamicUnion } from "../../structures/DynamicUnion"; + +export const test_compare_equals_DynamicUnion = _test_compare_equals( + "DynamicUnion", +)( + DynamicUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_FunctionalArray.ts b/test/src/features/compare.equals/test_compare_equals_FunctionalArray.ts new file mode 100644 index 0000000000..07af13bfab --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_FunctionalArray.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { FunctionalArray } from "../../structures/FunctionalArray"; + +export const test_compare_equals_FunctionalArray = _test_compare_equals( + "FunctionalArray", +)( + FunctionalArray +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_FunctionalArrayUnion.ts b/test/src/features/compare.equals/test_compare_equals_FunctionalArrayUnion.ts new file mode 100644 index 0000000000..4a83049789 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_FunctionalArrayUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { FunctionalArrayUnion } from "../../structures/FunctionalArrayUnion"; + +export const test_compare_equals_FunctionalArrayUnion = _test_compare_equals( + "FunctionalArrayUnion", +)( + FunctionalArrayUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_FunctionalObjectUnion.ts b/test/src/features/compare.equals/test_compare_equals_FunctionalObjectUnion.ts new file mode 100644 index 0000000000..d1b22a7be2 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_FunctionalObjectUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { FunctionalObjectUnion } from "../../structures/FunctionalObjectUnion"; + +export const test_compare_equals_FunctionalObjectUnion = _test_compare_equals( + "FunctionalObjectUnion", +)( + FunctionalObjectUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_FunctionalProperty.ts b/test/src/features/compare.equals/test_compare_equals_FunctionalProperty.ts new file mode 100644 index 0000000000..b29b4c013e --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_FunctionalProperty.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { FunctionalProperty } from "../../structures/FunctionalProperty"; + +export const test_compare_equals_FunctionalProperty = _test_compare_equals( + "FunctionalProperty", +)( + FunctionalProperty +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_FunctionalPropertyUnion.ts b/test/src/features/compare.equals/test_compare_equals_FunctionalPropertyUnion.ts new file mode 100644 index 0000000000..db0dc26b2f --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_FunctionalPropertyUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { FunctionalPropertyUnion } from "../../structures/FunctionalPropertyUnion"; + +export const test_compare_equals_FunctionalPropertyUnion = _test_compare_equals( + "FunctionalPropertyUnion", +)( + FunctionalPropertyUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_FunctionalTuple.ts b/test/src/features/compare.equals/test_compare_equals_FunctionalTuple.ts new file mode 100644 index 0000000000..26266fc013 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_FunctionalTuple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { FunctionalTuple } from "../../structures/FunctionalTuple"; + +export const test_compare_equals_FunctionalTuple = _test_compare_equals( + "FunctionalTuple", +)( + FunctionalTuple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_FunctionalTupleUnion.ts b/test/src/features/compare.equals/test_compare_equals_FunctionalTupleUnion.ts new file mode 100644 index 0000000000..d3dceb7b4e --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_FunctionalTupleUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { FunctionalTupleUnion } from "../../structures/FunctionalTupleUnion"; + +export const test_compare_equals_FunctionalTupleUnion = _test_compare_equals( + "FunctionalTupleUnion", +)( + FunctionalTupleUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_FunctionalValue.ts b/test/src/features/compare.equals/test_compare_equals_FunctionalValue.ts new file mode 100644 index 0000000000..cd2f53443c --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_FunctionalValue.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { FunctionalValue } from "../../structures/FunctionalValue"; + +export const test_compare_equals_FunctionalValue = _test_compare_equals( + "FunctionalValue", +)( + FunctionalValue +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_FunctionalValueUnion.ts b/test/src/features/compare.equals/test_compare_equals_FunctionalValueUnion.ts new file mode 100644 index 0000000000..dfffbb6b70 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_FunctionalValueUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { FunctionalValueUnion } from "../../structures/FunctionalValueUnion"; + +export const test_compare_equals_FunctionalValueUnion = _test_compare_equals( + "FunctionalValueUnion", +)( + FunctionalValueUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_InstanceUnion.ts b/test/src/features/compare.equals/test_compare_equals_InstanceUnion.ts new file mode 100644 index 0000000000..4202a9549f --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_InstanceUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { InstanceUnion } from "../../structures/InstanceUnion"; + +export const test_compare_equals_InstanceUnion = _test_compare_equals( + "InstanceUnion", +)( + InstanceUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_MapAlias.ts b/test/src/features/compare.equals/test_compare_equals_MapAlias.ts new file mode 100644 index 0000000000..b3090f9391 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_MapAlias.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { MapAlias } from "../../structures/MapAlias"; + +export const test_compare_equals_MapAlias = _test_compare_equals( + "MapAlias", +)( + MapAlias +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_MapSimple.ts b/test/src/features/compare.equals/test_compare_equals_MapSimple.ts new file mode 100644 index 0000000000..8dc0ac0706 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_MapSimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { MapSimple } from "../../structures/MapSimple"; + +export const test_compare_equals_MapSimple = _test_compare_equals( + "MapSimple", +)( + MapSimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_MapSimpleProtobuf.ts b/test/src/features/compare.equals/test_compare_equals_MapSimpleProtobuf.ts new file mode 100644 index 0000000000..d44ae491e8 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_MapSimpleProtobuf.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { MapSimpleProtobuf } from "../../structures/MapSimpleProtobuf"; + +export const test_compare_equals_MapSimpleProtobuf = _test_compare_equals( + "MapSimpleProtobuf", +)( + MapSimpleProtobuf +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_MapSimpleProtobufNullable.ts b/test/src/features/compare.equals/test_compare_equals_MapSimpleProtobufNullable.ts new file mode 100644 index 0000000000..500226a98b --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_MapSimpleProtobufNullable.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { MapSimpleProtobufNullable } from "../../structures/MapSimpleProtobufNullable"; + +export const test_compare_equals_MapSimpleProtobufNullable = _test_compare_equals( + "MapSimpleProtobufNullable", +)( + MapSimpleProtobufNullable +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_MapSimpleProtobufOptional.ts b/test/src/features/compare.equals/test_compare_equals_MapSimpleProtobufOptional.ts new file mode 100644 index 0000000000..bc156ec1be --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_MapSimpleProtobufOptional.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { MapSimpleProtobufOptional } from "../../structures/MapSimpleProtobufOptional"; + +export const test_compare_equals_MapSimpleProtobufOptional = _test_compare_equals( + "MapSimpleProtobufOptional", +)( + MapSimpleProtobufOptional +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_MapUnion.ts b/test/src/features/compare.equals/test_compare_equals_MapUnion.ts new file mode 100644 index 0000000000..1290278995 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_MapUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { MapUnion } from "../../structures/MapUnion"; + +export const test_compare_equals_MapUnion = _test_compare_equals( + "MapUnion", +)( + MapUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_NativeSimple.ts b/test/src/features/compare.equals/test_compare_equals_NativeSimple.ts new file mode 100644 index 0000000000..dae7fa1698 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_NativeSimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { NativeSimple } from "../../structures/NativeSimple"; + +export const test_compare_equals_NativeSimple = _test_compare_equals( + "NativeSimple", +)( + NativeSimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_NativeUnion.ts b/test/src/features/compare.equals/test_compare_equals_NativeUnion.ts new file mode 100644 index 0000000000..99fb9ce65a --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_NativeUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { NativeUnion } from "../../structures/NativeUnion"; + +export const test_compare_equals_NativeUnion = _test_compare_equals( + "NativeUnion", +)( + NativeUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectAlias.ts b/test/src/features/compare.equals/test_compare_equals_ObjectAlias.ts new file mode 100644 index 0000000000..d8d40165cf --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectAlias.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectAlias } from "../../structures/ObjectAlias"; + +export const test_compare_equals_ObjectAlias = _test_compare_equals( + "ObjectAlias", +)( + ObjectAlias +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectClosure.ts b/test/src/features/compare.equals/test_compare_equals_ObjectClosure.ts new file mode 100644 index 0000000000..14576aa9ba --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectClosure.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectClosure } from "../../structures/ObjectClosure"; + +export const test_compare_equals_ObjectClosure = _test_compare_equals( + "ObjectClosure", +)( + ObjectClosure +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectDate.ts b/test/src/features/compare.equals/test_compare_equals_ObjectDate.ts new file mode 100644 index 0000000000..e83b229ef0 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectDate.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectDate } from "../../structures/ObjectDate"; + +export const test_compare_equals_ObjectDate = _test_compare_equals( + "ObjectDate", +)( + ObjectDate +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectDescription.ts b/test/src/features/compare.equals/test_compare_equals_ObjectDescription.ts new file mode 100644 index 0000000000..624417f38e --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectDescription.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectDescription } from "../../structures/ObjectDescription"; + +export const test_compare_equals_ObjectDescription = _test_compare_equals( + "ObjectDescription", +)( + ObjectDescription +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectDynamic.ts b/test/src/features/compare.equals/test_compare_equals_ObjectDynamic.ts new file mode 100644 index 0000000000..573dd5ef16 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectDynamic.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectDynamic } from "../../structures/ObjectDynamic"; + +export const test_compare_equals_ObjectDynamic = _test_compare_equals( + "ObjectDynamic", +)( + ObjectDynamic +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectGeneric.ts b/test/src/features/compare.equals/test_compare_equals_ObjectGeneric.ts new file mode 100644 index 0000000000..676d7558b5 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectGeneric.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectGeneric } from "../../structures/ObjectGeneric"; + +export const test_compare_equals_ObjectGeneric = _test_compare_equals( + "ObjectGeneric", +)( + ObjectGeneric +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectGenericAlias.ts b/test/src/features/compare.equals/test_compare_equals_ObjectGenericAlias.ts new file mode 100644 index 0000000000..bfa47589db --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectGenericAlias.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectGenericAlias } from "../../structures/ObjectGenericAlias"; + +export const test_compare_equals_ObjectGenericAlias = _test_compare_equals( + "ObjectGenericAlias", +)( + ObjectGenericAlias +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectGenericArray.ts b/test/src/features/compare.equals/test_compare_equals_ObjectGenericArray.ts new file mode 100644 index 0000000000..a920984cdd --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectGenericArray.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectGenericArray } from "../../structures/ObjectGenericArray"; + +export const test_compare_equals_ObjectGenericArray = _test_compare_equals( + "ObjectGenericArray", +)( + ObjectGenericArray +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectGenericUnion.ts b/test/src/features/compare.equals/test_compare_equals_ObjectGenericUnion.ts new file mode 100644 index 0000000000..79ce0cfaf4 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectGenericUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectGenericUnion } from "../../structures/ObjectGenericUnion"; + +export const test_compare_equals_ObjectGenericUnion = _test_compare_equals( + "ObjectGenericUnion", +)( + ObjectGenericUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectHierarchical.ts b/test/src/features/compare.equals/test_compare_equals_ObjectHierarchical.ts new file mode 100644 index 0000000000..f71585e5fa --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectHierarchical.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectHierarchical } from "../../structures/ObjectHierarchical"; + +export const test_compare_equals_ObjectHierarchical = _test_compare_equals( + "ObjectHierarchical", +)( + ObjectHierarchical +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectHttpArray.ts b/test/src/features/compare.equals/test_compare_equals_ObjectHttpArray.ts new file mode 100644 index 0000000000..d6da360ddc --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectHttpArray.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectHttpArray } from "../../structures/ObjectHttpArray"; + +export const test_compare_equals_ObjectHttpArray = _test_compare_equals( + "ObjectHttpArray", +)( + ObjectHttpArray +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectHttpAtomic.ts b/test/src/features/compare.equals/test_compare_equals_ObjectHttpAtomic.ts new file mode 100644 index 0000000000..4905f2916d --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectHttpAtomic.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectHttpAtomic } from "../../structures/ObjectHttpAtomic"; + +export const test_compare_equals_ObjectHttpAtomic = _test_compare_equals( + "ObjectHttpAtomic", +)( + ObjectHttpAtomic +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectHttpCommentTag.ts b/test/src/features/compare.equals/test_compare_equals_ObjectHttpCommentTag.ts new file mode 100644 index 0000000000..5f0a4723c8 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectHttpCommentTag.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectHttpCommentTag } from "../../structures/ObjectHttpCommentTag"; + +export const test_compare_equals_ObjectHttpCommentTag = _test_compare_equals( + "ObjectHttpCommentTag", +)( + ObjectHttpCommentTag +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectHttpConstant.ts b/test/src/features/compare.equals/test_compare_equals_ObjectHttpConstant.ts new file mode 100644 index 0000000000..acbd37845b --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectHttpConstant.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectHttpConstant } from "../../structures/ObjectHttpConstant"; + +export const test_compare_equals_ObjectHttpConstant = _test_compare_equals( + "ObjectHttpConstant", +)( + ObjectHttpConstant +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectHttpFormData.ts b/test/src/features/compare.equals/test_compare_equals_ObjectHttpFormData.ts new file mode 100644 index 0000000000..9a48e05a2b --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectHttpFormData.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectHttpFormData } from "../../structures/ObjectHttpFormData"; + +export const test_compare_equals_ObjectHttpFormData = _test_compare_equals( + "ObjectHttpFormData", +)( + ObjectHttpFormData +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectHttpNullable.ts b/test/src/features/compare.equals/test_compare_equals_ObjectHttpNullable.ts new file mode 100644 index 0000000000..77dd9e8ea5 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectHttpNullable.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectHttpNullable } from "../../structures/ObjectHttpNullable"; + +export const test_compare_equals_ObjectHttpNullable = _test_compare_equals( + "ObjectHttpNullable", +)( + ObjectHttpNullable +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectHttpTypeTag.ts b/test/src/features/compare.equals/test_compare_equals_ObjectHttpTypeTag.ts new file mode 100644 index 0000000000..697bfe02ca --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectHttpTypeTag.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectHttpTypeTag } from "../../structures/ObjectHttpTypeTag"; + +export const test_compare_equals_ObjectHttpTypeTag = _test_compare_equals( + "ObjectHttpTypeTag", +)( + ObjectHttpTypeTag +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectHttpUndefindable.ts b/test/src/features/compare.equals/test_compare_equals_ObjectHttpUndefindable.ts new file mode 100644 index 0000000000..d0dbb8dfc5 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectHttpUndefindable.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectHttpUndefindable } from "../../structures/ObjectHttpUndefindable"; + +export const test_compare_equals_ObjectHttpUndefindable = _test_compare_equals( + "ObjectHttpUndefindable", +)( + ObjectHttpUndefindable +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectInternal.ts b/test/src/features/compare.equals/test_compare_equals_ObjectInternal.ts new file mode 100644 index 0000000000..edbcd1667e --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectInternal.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectInternal } from "../../structures/ObjectInternal"; + +export const test_compare_equals_ObjectInternal = _test_compare_equals( + "ObjectInternal", +)( + ObjectInternal +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectIntersection.ts b/test/src/features/compare.equals/test_compare_equals_ObjectIntersection.ts new file mode 100644 index 0000000000..477924bfc0 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectIntersection.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectIntersection } from "../../structures/ObjectIntersection"; + +export const test_compare_equals_ObjectIntersection = _test_compare_equals( + "ObjectIntersection", +)( + ObjectIntersection +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectJsonTag.ts b/test/src/features/compare.equals/test_compare_equals_ObjectJsonTag.ts new file mode 100644 index 0000000000..3872090871 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectJsonTag.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectJsonTag } from "../../structures/ObjectJsonTag"; + +export const test_compare_equals_ObjectJsonTag = _test_compare_equals( + "ObjectJsonTag", +)( + ObjectJsonTag +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectLiteralProperty.ts b/test/src/features/compare.equals/test_compare_equals_ObjectLiteralProperty.ts new file mode 100644 index 0000000000..110ddd43fb --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectLiteralProperty.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectLiteralProperty } from "../../structures/ObjectLiteralProperty"; + +export const test_compare_equals_ObjectLiteralProperty = _test_compare_equals( + "ObjectLiteralProperty", +)( + ObjectLiteralProperty +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectLiteralType.ts b/test/src/features/compare.equals/test_compare_equals_ObjectLiteralType.ts new file mode 100644 index 0000000000..0cca328d1d --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectLiteralType.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectLiteralType } from "../../structures/ObjectLiteralType"; + +export const test_compare_equals_ObjectLiteralType = _test_compare_equals( + "ObjectLiteralType", +)( + ObjectLiteralType +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectNullable.ts b/test/src/features/compare.equals/test_compare_equals_ObjectNullable.ts new file mode 100644 index 0000000000..ab2b6ed470 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectNullable.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectNullable } from "../../structures/ObjectNullable"; + +export const test_compare_equals_ObjectNullable = _test_compare_equals( + "ObjectNullable", +)( + ObjectNullable +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectOptional.ts b/test/src/features/compare.equals/test_compare_equals_ObjectOptional.ts new file mode 100644 index 0000000000..0b71ae21a1 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectOptional.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectOptional } from "../../structures/ObjectOptional"; + +export const test_compare_equals_ObjectOptional = _test_compare_equals( + "ObjectOptional", +)( + ObjectOptional +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectPartial.ts b/test/src/features/compare.equals/test_compare_equals_ObjectPartial.ts new file mode 100644 index 0000000000..83b51b9720 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectPartial.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectPartial } from "../../structures/ObjectPartial"; + +export const test_compare_equals_ObjectPartial = _test_compare_equals( + "ObjectPartial", +)( + ObjectPartial +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectPartialAndRequired.ts b/test/src/features/compare.equals/test_compare_equals_ObjectPartialAndRequired.ts new file mode 100644 index 0000000000..dd920e14c6 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectPartialAndRequired.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectPartialAndRequired } from "../../structures/ObjectPartialAndRequired"; + +export const test_compare_equals_ObjectPartialAndRequired = _test_compare_equals( + "ObjectPartialAndRequired", +)( + ObjectPartialAndRequired +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectPrimitive.ts b/test/src/features/compare.equals/test_compare_equals_ObjectPrimitive.ts new file mode 100644 index 0000000000..800cb22f61 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectPrimitive.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectPrimitive } from "../../structures/ObjectPrimitive"; + +export const test_compare_equals_ObjectPrimitive = _test_compare_equals( + "ObjectPrimitive", +)( + ObjectPrimitive +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectPropertyNullable.ts b/test/src/features/compare.equals/test_compare_equals_ObjectPropertyNullable.ts new file mode 100644 index 0000000000..3ccc525e0e --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectPropertyNullable.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectPropertyNullable } from "../../structures/ObjectPropertyNullable"; + +export const test_compare_equals_ObjectPropertyNullable = _test_compare_equals( + "ObjectPropertyNullable", +)( + ObjectPropertyNullable +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectRecursive.ts b/test/src/features/compare.equals/test_compare_equals_ObjectRecursive.ts new file mode 100644 index 0000000000..e75255f5f0 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectRecursive.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectRecursive } from "../../structures/ObjectRecursive"; + +export const test_compare_equals_ObjectRecursive = _test_compare_equals( + "ObjectRecursive", +)( + ObjectRecursive +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectRequired.ts b/test/src/features/compare.equals/test_compare_equals_ObjectRequired.ts new file mode 100644 index 0000000000..a7e4c92a99 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectRequired.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectRequired } from "../../structures/ObjectRequired"; + +export const test_compare_equals_ObjectRequired = _test_compare_equals( + "ObjectRequired", +)( + ObjectRequired +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectSequenceProtobuf.ts b/test/src/features/compare.equals/test_compare_equals_ObjectSequenceProtobuf.ts new file mode 100644 index 0000000000..30db8d0b75 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectSequenceProtobuf.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectSequenceProtobuf } from "../../structures/ObjectSequenceProtobuf"; + +export const test_compare_equals_ObjectSequenceProtobuf = _test_compare_equals( + "ObjectSequenceProtobuf", +)( + ObjectSequenceProtobuf +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectSimple.ts b/test/src/features/compare.equals/test_compare_equals_ObjectSimple.ts new file mode 100644 index 0000000000..4454ea3309 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectSimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectSimple } from "../../structures/ObjectSimple"; + +export const test_compare_equals_ObjectSimple = _test_compare_equals( + "ObjectSimple", +)( + ObjectSimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobuf.ts b/test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobuf.ts new file mode 100644 index 0000000000..fe6453ef37 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobuf.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectSimpleProtobuf } from "../../structures/ObjectSimpleProtobuf"; + +export const test_compare_equals_ObjectSimpleProtobuf = _test_compare_equals( + "ObjectSimpleProtobuf", +)( + ObjectSimpleProtobuf +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobufNullable.ts b/test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobufNullable.ts new file mode 100644 index 0000000000..a535c513ea --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobufNullable.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectSimpleProtobufNullable } from "../../structures/ObjectSimpleProtobufNullable"; + +export const test_compare_equals_ObjectSimpleProtobufNullable = _test_compare_equals( + "ObjectSimpleProtobufNullable", +)( + ObjectSimpleProtobufNullable +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobufOptional.ts b/test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobufOptional.ts new file mode 100644 index 0000000000..cebdc4957b --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobufOptional.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectSimpleProtobufOptional } from "../../structures/ObjectSimpleProtobufOptional"; + +export const test_compare_equals_ObjectSimpleProtobufOptional = _test_compare_equals( + "ObjectSimpleProtobufOptional", +)( + ObjectSimpleProtobufOptional +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectTuple.ts b/test/src/features/compare.equals/test_compare_equals_ObjectTuple.ts new file mode 100644 index 0000000000..c791e34f9c --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectTuple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectTuple } from "../../structures/ObjectTuple"; + +export const test_compare_equals_ObjectTuple = _test_compare_equals( + "ObjectTuple", +)( + ObjectTuple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectUndefined.ts b/test/src/features/compare.equals/test_compare_equals_ObjectUndefined.ts new file mode 100644 index 0000000000..bbb4efa664 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectUndefined.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectUndefined } from "../../structures/ObjectUndefined"; + +export const test_compare_equals_ObjectUndefined = _test_compare_equals( + "ObjectUndefined", +)( + ObjectUndefined +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectUnionComposite.ts b/test/src/features/compare.equals/test_compare_equals_ObjectUnionComposite.ts new file mode 100644 index 0000000000..a5965c0ac9 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectUnionComposite.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectUnionComposite } from "../../structures/ObjectUnionComposite"; + +export const test_compare_equals_ObjectUnionComposite = _test_compare_equals( + "ObjectUnionComposite", +)( + ObjectUnionComposite +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectUnionCompositePointer.ts b/test/src/features/compare.equals/test_compare_equals_ObjectUnionCompositePointer.ts new file mode 100644 index 0000000000..87e91212ad --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectUnionCompositePointer.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectUnionCompositePointer } from "../../structures/ObjectUnionCompositePointer"; + +export const test_compare_equals_ObjectUnionCompositePointer = _test_compare_equals( + "ObjectUnionCompositePointer", +)( + ObjectUnionCompositePointer +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectUnionDouble.ts b/test/src/features/compare.equals/test_compare_equals_ObjectUnionDouble.ts new file mode 100644 index 0000000000..d8bfe33038 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectUnionDouble.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectUnionDouble } from "../../structures/ObjectUnionDouble"; + +export const test_compare_equals_ObjectUnionDouble = _test_compare_equals( + "ObjectUnionDouble", +)( + ObjectUnionDouble +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectUnionExplicit.ts b/test/src/features/compare.equals/test_compare_equals_ObjectUnionExplicit.ts new file mode 100644 index 0000000000..6bdce322e6 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectUnionExplicit.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectUnionExplicit } from "../../structures/ObjectUnionExplicit"; + +export const test_compare_equals_ObjectUnionExplicit = _test_compare_equals( + "ObjectUnionExplicit", +)( + ObjectUnionExplicit +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectUnionExplicitPointer.ts b/test/src/features/compare.equals/test_compare_equals_ObjectUnionExplicitPointer.ts new file mode 100644 index 0000000000..bb12610fa7 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectUnionExplicitPointer.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectUnionExplicitPointer } from "../../structures/ObjectUnionExplicitPointer"; + +export const test_compare_equals_ObjectUnionExplicitPointer = _test_compare_equals( + "ObjectUnionExplicitPointer", +)( + ObjectUnionExplicitPointer +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectUnionImplicit.ts b/test/src/features/compare.equals/test_compare_equals_ObjectUnionImplicit.ts new file mode 100644 index 0000000000..faec1d8bb5 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectUnionImplicit.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectUnionImplicit } from "../../structures/ObjectUnionImplicit"; + +export const test_compare_equals_ObjectUnionImplicit = _test_compare_equals( + "ObjectUnionImplicit", +)( + ObjectUnionImplicit +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ObjectUnionNonPredictable.ts b/test/src/features/compare.equals/test_compare_equals_ObjectUnionNonPredictable.ts new file mode 100644 index 0000000000..cc442234dd --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ObjectUnionNonPredictable.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ObjectUnionNonPredictable } from "../../structures/ObjectUnionNonPredictable"; + +export const test_compare_equals_ObjectUnionNonPredictable = _test_compare_equals( + "ObjectUnionNonPredictable", +)( + ObjectUnionNonPredictable +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_SetAlias.ts b/test/src/features/compare.equals/test_compare_equals_SetAlias.ts new file mode 100644 index 0000000000..5dc1065f17 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_SetAlias.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { SetAlias } from "../../structures/SetAlias"; + +export const test_compare_equals_SetAlias = _test_compare_equals( + "SetAlias", +)( + SetAlias +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_SetSimple.ts b/test/src/features/compare.equals/test_compare_equals_SetSimple.ts new file mode 100644 index 0000000000..74e2ca71f5 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_SetSimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { SetSimple } from "../../structures/SetSimple"; + +export const test_compare_equals_SetSimple = _test_compare_equals( + "SetSimple", +)( + SetSimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_SetUnion.ts b/test/src/features/compare.equals/test_compare_equals_SetUnion.ts new file mode 100644 index 0000000000..21f9d31f15 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_SetUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { SetUnion } from "../../structures/SetUnion"; + +export const test_compare_equals_SetUnion = _test_compare_equals( + "SetUnion", +)( + SetUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TemplateAtomic.ts b/test/src/features/compare.equals/test_compare_equals_TemplateAtomic.ts new file mode 100644 index 0000000000..cf76052d54 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TemplateAtomic.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TemplateAtomic } from "../../structures/TemplateAtomic"; + +export const test_compare_equals_TemplateAtomic = _test_compare_equals( + "TemplateAtomic", +)( + TemplateAtomic +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TemplateConstant.ts b/test/src/features/compare.equals/test_compare_equals_TemplateConstant.ts new file mode 100644 index 0000000000..7ee93b6b53 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TemplateConstant.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TemplateConstant } from "../../structures/TemplateConstant"; + +export const test_compare_equals_TemplateConstant = _test_compare_equals( + "TemplateConstant", +)( + TemplateConstant +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TemplateUnion.ts b/test/src/features/compare.equals/test_compare_equals_TemplateUnion.ts new file mode 100644 index 0000000000..acf86d7d99 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TemplateUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TemplateUnion } from "../../structures/TemplateUnion"; + +export const test_compare_equals_TemplateUnion = _test_compare_equals( + "TemplateUnion", +)( + TemplateUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ToJsonArray.ts b/test/src/features/compare.equals/test_compare_equals_ToJsonArray.ts new file mode 100644 index 0000000000..1fcaa98646 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ToJsonArray.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ToJsonArray } from "../../structures/ToJsonArray"; + +export const test_compare_equals_ToJsonArray = _test_compare_equals( + "ToJsonArray", +)( + ToJsonArray +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ToJsonAtomicSimple.ts b/test/src/features/compare.equals/test_compare_equals_ToJsonAtomicSimple.ts new file mode 100644 index 0000000000..34380d7ab1 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ToJsonAtomicSimple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ToJsonAtomicSimple } from "../../structures/ToJsonAtomicSimple"; + +export const test_compare_equals_ToJsonAtomicSimple = _test_compare_equals( + "ToJsonAtomicSimple", +)( + ToJsonAtomicSimple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ToJsonAtomicUnion.ts b/test/src/features/compare.equals/test_compare_equals_ToJsonAtomicUnion.ts new file mode 100644 index 0000000000..d84044fd36 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ToJsonAtomicUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ToJsonAtomicUnion } from "../../structures/ToJsonAtomicUnion"; + +export const test_compare_equals_ToJsonAtomicUnion = _test_compare_equals( + "ToJsonAtomicUnion", +)( + ToJsonAtomicUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ToJsonDouble.ts b/test/src/features/compare.equals/test_compare_equals_ToJsonDouble.ts new file mode 100644 index 0000000000..c0575960ed --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ToJsonDouble.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ToJsonDouble } from "../../structures/ToJsonDouble"; + +export const test_compare_equals_ToJsonDouble = _test_compare_equals( + "ToJsonDouble", +)( + ToJsonDouble +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ToJsonNull.ts b/test/src/features/compare.equals/test_compare_equals_ToJsonNull.ts new file mode 100644 index 0000000000..9043767d90 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ToJsonNull.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ToJsonNull } from "../../structures/ToJsonNull"; + +export const test_compare_equals_ToJsonNull = _test_compare_equals( + "ToJsonNull", +)( + ToJsonNull +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ToJsonTuple.ts b/test/src/features/compare.equals/test_compare_equals_ToJsonTuple.ts new file mode 100644 index 0000000000..4571c254bd --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ToJsonTuple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ToJsonTuple } from "../../structures/ToJsonTuple"; + +export const test_compare_equals_ToJsonTuple = _test_compare_equals( + "ToJsonTuple", +)( + ToJsonTuple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_ToJsonUnion.ts b/test/src/features/compare.equals/test_compare_equals_ToJsonUnion.ts new file mode 100644 index 0000000000..961a695688 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_ToJsonUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { ToJsonUnion } from "../../structures/ToJsonUnion"; + +export const test_compare_equals_ToJsonUnion = _test_compare_equals( + "ToJsonUnion", +)( + ToJsonUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TupleHierarchical.ts b/test/src/features/compare.equals/test_compare_equals_TupleHierarchical.ts new file mode 100644 index 0000000000..140ab91f02 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TupleHierarchical.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TupleHierarchical } from "../../structures/TupleHierarchical"; + +export const test_compare_equals_TupleHierarchical = _test_compare_equals( + "TupleHierarchical", +)( + TupleHierarchical +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TupleOptional.ts b/test/src/features/compare.equals/test_compare_equals_TupleOptional.ts new file mode 100644 index 0000000000..c4120753ff --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TupleOptional.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TupleOptional } from "../../structures/TupleOptional"; + +export const test_compare_equals_TupleOptional = _test_compare_equals( + "TupleOptional", +)( + TupleOptional +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TupleRestArray.ts b/test/src/features/compare.equals/test_compare_equals_TupleRestArray.ts new file mode 100644 index 0000000000..6ef0f71cb4 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TupleRestArray.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TupleRestArray } from "../../structures/TupleRestArray"; + +export const test_compare_equals_TupleRestArray = _test_compare_equals( + "TupleRestArray", +)( + TupleRestArray +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TupleRestAtomic.ts b/test/src/features/compare.equals/test_compare_equals_TupleRestAtomic.ts new file mode 100644 index 0000000000..8f4cf493ca --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TupleRestAtomic.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TupleRestAtomic } from "../../structures/TupleRestAtomic"; + +export const test_compare_equals_TupleRestAtomic = _test_compare_equals( + "TupleRestAtomic", +)( + TupleRestAtomic +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TupleRestObject.ts b/test/src/features/compare.equals/test_compare_equals_TupleRestObject.ts new file mode 100644 index 0000000000..4703bff102 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TupleRestObject.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TupleRestObject } from "../../structures/TupleRestObject"; + +export const test_compare_equals_TupleRestObject = _test_compare_equals( + "TupleRestObject", +)( + TupleRestObject +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TupleUnion.ts b/test/src/features/compare.equals/test_compare_equals_TupleUnion.ts new file mode 100644 index 0000000000..deae6b47e5 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TupleUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TupleUnion } from "../../structures/TupleUnion"; + +export const test_compare_equals_TupleUnion = _test_compare_equals( + "TupleUnion", +)( + TupleUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagArray.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagArray.ts new file mode 100644 index 0000000000..4e9369334a --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagArray.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagArray } from "../../structures/TypeTagArray"; + +export const test_compare_equals_TypeTagArray = _test_compare_equals( + "TypeTagArray", +)( + TypeTagArray +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagArrayUnion.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagArrayUnion.ts new file mode 100644 index 0000000000..b44d5661c2 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagArrayUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagArrayUnion } from "../../structures/TypeTagArrayUnion"; + +export const test_compare_equals_TypeTagArrayUnion = _test_compare_equals( + "TypeTagArrayUnion", +)( + TypeTagArrayUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagAtomicUnion.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagAtomicUnion.ts new file mode 100644 index 0000000000..32f9ddcaa8 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagAtomicUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagAtomicUnion } from "../../structures/TypeTagAtomicUnion"; + +export const test_compare_equals_TypeTagAtomicUnion = _test_compare_equals( + "TypeTagAtomicUnion", +)( + TypeTagAtomicUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagBigInt.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagBigInt.ts new file mode 100644 index 0000000000..d1eb2d5142 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagBigInt.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagBigInt } from "../../structures/TypeTagBigInt"; + +export const test_compare_equals_TypeTagBigInt = _test_compare_equals( + "TypeTagBigInt", +)( + TypeTagBigInt +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagCustom.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagCustom.ts new file mode 100644 index 0000000000..ff01f169e3 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagCustom.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagCustom } from "../../structures/TypeTagCustom"; + +export const test_compare_equals_TypeTagCustom = _test_compare_equals( + "TypeTagCustom", +)( + TypeTagCustom +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagDefault.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagDefault.ts new file mode 100644 index 0000000000..f0fe98037b --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagDefault.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagDefault } from "../../structures/TypeTagDefault"; + +export const test_compare_equals_TypeTagDefault = _test_compare_equals( + "TypeTagDefault", +)( + TypeTagDefault +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagFormat.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagFormat.ts new file mode 100644 index 0000000000..65957c6ee0 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagFormat.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagFormat } from "../../structures/TypeTagFormat"; + +export const test_compare_equals_TypeTagFormat = _test_compare_equals( + "TypeTagFormat", +)( + TypeTagFormat +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagInfinite.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagInfinite.ts new file mode 100644 index 0000000000..53b61a8f2d --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagInfinite.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagInfinite } from "../../structures/TypeTagInfinite"; + +export const test_compare_equals_TypeTagInfinite = _test_compare_equals( + "TypeTagInfinite", +)( + TypeTagInfinite +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagLength.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagLength.ts new file mode 100644 index 0000000000..3db56797b8 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagLength.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagLength } from "../../structures/TypeTagLength"; + +export const test_compare_equals_TypeTagLength = _test_compare_equals( + "TypeTagLength", +)( + TypeTagLength +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagMatrix.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagMatrix.ts new file mode 100644 index 0000000000..ac14527a61 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagMatrix.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagMatrix } from "../../structures/TypeTagMatrix"; + +export const test_compare_equals_TypeTagMatrix = _test_compare_equals( + "TypeTagMatrix", +)( + TypeTagMatrix +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagNaN.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagNaN.ts new file mode 100644 index 0000000000..dfddcc829e --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagNaN.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagNaN } from "../../structures/TypeTagNaN"; + +export const test_compare_equals_TypeTagNaN = _test_compare_equals( + "TypeTagNaN", +)( + TypeTagNaN +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagObjectUnion.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagObjectUnion.ts new file mode 100644 index 0000000000..9d9e5c0f07 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagObjectUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagObjectUnion } from "../../structures/TypeTagObjectUnion"; + +export const test_compare_equals_TypeTagObjectUnion = _test_compare_equals( + "TypeTagObjectUnion", +)( + TypeTagObjectUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagPattern.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagPattern.ts new file mode 100644 index 0000000000..836f36552d --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagPattern.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagPattern } from "../../structures/TypeTagPattern"; + +export const test_compare_equals_TypeTagPattern = _test_compare_equals( + "TypeTagPattern", +)( + TypeTagPattern +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagRange.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagRange.ts new file mode 100644 index 0000000000..5124175c5f --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagRange.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagRange } from "../../structures/TypeTagRange"; + +export const test_compare_equals_TypeTagRange = _test_compare_equals( + "TypeTagRange", +)( + TypeTagRange +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagRangeBigInt.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagRangeBigInt.ts new file mode 100644 index 0000000000..caea97718f --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagRangeBigInt.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagRangeBigInt } from "../../structures/TypeTagRangeBigInt"; + +export const test_compare_equals_TypeTagRangeBigInt = _test_compare_equals( + "TypeTagRangeBigInt", +)( + TypeTagRangeBigInt +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagTuple.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagTuple.ts new file mode 100644 index 0000000000..ffb2cf863d --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagTuple.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagTuple } from "../../structures/TypeTagTuple"; + +export const test_compare_equals_TypeTagTuple = _test_compare_equals( + "TypeTagTuple", +)( + TypeTagTuple +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagType.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagType.ts new file mode 100644 index 0000000000..cca12bd818 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagType.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagType } from "../../structures/TypeTagType"; + +export const test_compare_equals_TypeTagType = _test_compare_equals( + "TypeTagType", +)( + TypeTagType +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagTypeBigInt.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagTypeBigInt.ts new file mode 100644 index 0000000000..e4c1710f4a --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagTypeBigInt.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagTypeBigInt } from "../../structures/TypeTagTypeBigInt"; + +export const test_compare_equals_TypeTagTypeBigInt = _test_compare_equals( + "TypeTagTypeBigInt", +)( + TypeTagTypeBigInt +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_TypeTagTypeUnion.ts b/test/src/features/compare.equals/test_compare_equals_TypeTagTypeUnion.ts new file mode 100644 index 0000000000..83d37af3c1 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_TypeTagTypeUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { TypeTagTypeUnion } from "../../structures/TypeTagTypeUnion"; + +export const test_compare_equals_TypeTagTypeUnion = _test_compare_equals( + "TypeTagTypeUnion", +)( + TypeTagTypeUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare.equals/test_compare_equals_UltimateUnion.ts b/test/src/features/compare.equals/test_compare_equals_UltimateUnion.ts new file mode 100644 index 0000000000..5142c27fb3 --- /dev/null +++ b/test/src/features/compare.equals/test_compare_equals_UltimateUnion.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { UltimateUnion } from "../../structures/UltimateUnion"; + +export const test_compare_equals_UltimateUnion = _test_compare_equals( + "UltimateUnion", +)( + UltimateUnion +)((a, b) => typia.compare.equals(a, b)); diff --git a/test/src/features/compare/test_equals_AtomicType.ts b/test/src/features/compare/test_equals_AtomicType.ts new file mode 100644 index 0000000000..0a3b1b5b1e --- /dev/null +++ b/test/src/features/compare/test_equals_AtomicType.ts @@ -0,0 +1,10 @@ +import typia from "typia"; + +import { _test_compare_equals } from "../../internal/_test_compare_equals"; +import { AtomicSimple } from "../../structures/AtomicSimple"; + +export const test_compare_equals_AtomicSimple = _test_compare_equals( + "AtomicSimple", +)(AtomicSimple)((a, b) => + typia.compare.equals(a, b), +); diff --git a/test/src/index.ts b/test/src/index.ts index c23795cd7c..987d13e177 100644 --- a/test/src/index.ts +++ b/test/src/index.ts @@ -6,17 +6,22 @@ import { DynamicImportIterator } from "./helpers/DynamicImportIterator"; async function main(): Promise { const counter: IPointer = { value: 0 }; const exceptions: Error[] = []; + const subfolder = + process.argv.find((a) => a.startsWith("--folder"))?.split("=")[1] ?? ""; console.log("-------------------------------------------------------"); console.log(" TRANSFORMATION TESTING"); console.log("-------------------------------------------------------"); exceptions.push( - ...(await DynamicImportIterator.force(__dirname + "/features", { - prefix: "test", - parameters: () => [], - counter, - })), + ...(await DynamicImportIterator.force( + __dirname + "/features/" + subfolder, + { + prefix: "test", + parameters: () => [], + counter, + }, + )), ); if ( diff --git a/test/src/internal/_test_compare_equals.ts b/test/src/internal/_test_compare_equals.ts new file mode 100644 index 0000000000..98447edfed --- /dev/null +++ b/test/src/internal/_test_compare_equals.ts @@ -0,0 +1,32 @@ +import { TestStructure } from "../helpers/TestStructure"; +import { resolved_equal_to } from "../helpers/resolved_equal_to"; + +export const _test_compare_equals = + (name: string) => + (factory: TestStructure) => + (equals: (a: T, b: T) => boolean) => + () => { + const dataA: T = factory.generate(); + const dataB: T = factory.generate(); + let equaled = false; + try { + equaled = equals(dataA, dataB); + } catch (e) { + if ( + e instanceof Error && + e.message.includes("no transform has been configured") + ) { + // This happens when there are unsupported types at the transformation stage. Expected behavior + return; + } + throw e; + } + const resolved = resolved_equal_to(name)(dataA, dataB); + + if (resolved !== equaled) { + throw new Error( + `typia.compare.equals(): failed to compare the ${name} type.`, + { cause: { dataA, dataB, equaled, resolved } }, + ); + } + };