From 1d633056310d5cf332ae707f4325e9855b66ef5a Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Wed, 12 Feb 2025 21:36:01 +0200 Subject: [PATCH 01/13] Preparing to develop compare --- src/compare.ts | 19 ++++ src/module.ts | 1 + .../compare/CompareEqualsProgrammer.ts | 89 +++++++++++++++++++ src/transformers/CallExpressionTransformer.ts | 4 + .../compare/CompareEqualsTransformer.ts | 13 +++ test/package.json | 3 +- .../compare/test_equals_AtomicType.ts | 10 +++ test/src/index.ts | 15 ++-- test/src/internal/_test_compare_equals.ts | 20 +++++ 9 files changed, 168 insertions(+), 6 deletions(-) create mode 100644 src/compare.ts create mode 100644 src/programmers/compare/CompareEqualsProgrammer.ts create mode 100644 src/transformers/features/compare/CompareEqualsTransformer.ts create mode 100644 test/src/features/compare/test_equals_AtomicType.ts create mode 100644 test/src/internal/_test_compare_equals.ts diff --git a/src/compare.ts b/src/compare.ts new file mode 100644 index 00000000000..01db62c892b --- /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/module.ts b/src/module.ts index 27a5d2e145b..570dff9e7b7 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 00000000000..c4dc356f51b --- /dev/null +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -0,0 +1,89 @@ +import ts from "typescript"; + +import { MetadataCollection } from "../../factories/MetadataCollection"; +import { MetadataFactory } from "../../factories/MetadataFactory"; +import { TypeFactory } from "../../factories/TypeFactory"; + +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 { + export const decompose = (props: { + context: ITypiaContext; + functor: FunctionProgrammer; + type: ts.Type; + name: string | undefined; + }): FeatureProgrammer.IDecomposed => { + // ANALYZE TYPE + const collection: MetadataCollection = new MetadataCollection(); + const result = MetadataFactory.analyze({ + checker: props.context.checker, + transformer: props.context.transformer, + options: { + escape: false, + constant: true, + absorb: true, + }, + collection, + type: props.type, + }); + if (result.success === false) { + throw TransformerError.from({ + code: props.functor.method, + errors: result.errors, + }); + } + + console.log(result.data); + // DO TRANSFORM + // const object = result.data.objects?.[0]!.type; + // console.log(object.description); + + return { + functions: {}, + statements: [], + arrow: ts.factory.createArrowFunction( + undefined, + undefined, + [], + props.context.importer.type({ + file: "typia", + name: "Resolved", + arguments: [ + ts.factory.createTypeReferenceNode( + props.name ?? + TypeFactory.getFullName({ + checker: props.context.checker, + type: props.type, + }), + ), + ], + }), + undefined, + ts.factory.createBlock([], true), + ), + }; + }; + + export const write = (props: IProgrammerProps) => { + const functor = new FunctionProgrammer(props.modulo.getText()); + const result: FeatureProgrammer.IDecomposed = decompose({ + ...props, + functor, + }); + console.log("-----------------------------------------------------"); + console.log(result); + console.log("-----------------------------------------------------"); + console.log(props.modulo); + console.log("-----------------------------------------------------"); + return FeatureProgrammer.writeDecomposed({ + modulo: props.modulo, + functor, + result, + }); + }; +} diff --git a/src/transformers/CallExpressionTransformer.ts b/src/transformers/CallExpressionTransformer.ts index 27d6933b080..8389c7bea2f 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 00000000000..995cf1275de --- /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: "json.isStringify", + write: CompareEqualsProgrammer.write, + }); +} diff --git a/test/package.json b/test/package.json index 109e6587fb5..6f2cc83172d 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/test_equals_AtomicType.ts b/test/src/features/compare/test_equals_AtomicType.ts new file mode 100644 index 00000000000..0a3b1b5b1e0 --- /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 c23795cd7cd..987d13e177a 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 00000000000..841f3ce1710 --- /dev/null +++ b/test/src/internal/_test_compare_equals.ts @@ -0,0 +1,20 @@ +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(); + const equaled = equals(dataA, dataB); + 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 } }, + ); + } + }; From 83a376e2a82a02ae2219f5cec82ec0a918ed8ded Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Thu, 13 Feb 2025 21:31:58 +0200 Subject: [PATCH 02/13] Added shallow object and atomic comparing --- .../compare/CompareEqualsProgrammer.ts | 229 ++++++++++++++---- test/generate/input/generate_comare.ts | 13 + 2 files changed, 197 insertions(+), 45 deletions(-) create mode 100644 test/generate/input/generate_comare.ts diff --git a/src/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts index c4dc356f51b..b94b50c988b 100644 --- a/src/programmers/compare/CompareEqualsProgrammer.ts +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -1,12 +1,9 @@ import ts from "typescript"; -import { MetadataCollection } from "../../factories/MetadataCollection"; -import { MetadataFactory } from "../../factories/MetadataFactory"; -import { TypeFactory } from "../../factories/TypeFactory"; +import { IdentifierFactory } from "../../factories/IdentifierFactory"; import { IProgrammerProps } from "../../transformers/IProgrammerProps"; import { ITypiaContext } from "../../transformers/ITypiaContext"; -import { TransformerError } from "../../transformers/TransformerError"; import { FeatureProgrammer } from "../FeatureProgrammer"; import { FunctionProgrammer } from "../helpers/FunctionProgrammer"; @@ -19,29 +16,37 @@ export namespace CompareEqualsProgrammer { name: string | undefined; }): FeatureProgrammer.IDecomposed => { // ANALYZE TYPE - const collection: MetadataCollection = new MetadataCollection(); - const result = MetadataFactory.analyze({ - checker: props.context.checker, - transformer: props.context.transformer, - options: { - escape: false, - constant: true, - absorb: true, - }, - collection, - type: props.type, - }); - if (result.success === false) { - throw TransformerError.from({ - code: props.functor.method, - errors: result.errors, - }); - } + // const collection: MetadataCollection = new MetadataCollection(); + // const result = MetadataFactory.analyze({ + // checker: props.context.checker, + // transformer: props.context.transformer, + // options: { + // escape: false, + // constant: true, + // absorb: true, + // }, + // collection, + // type: props.type, + // }); + // if (result.success === false) { + // throw TransformerError.from({ + // code: props.functor.method, + // errors: result.errors, + // }); + // } - console.log(result.data); // DO TRANSFORM - // const object = result.data.objects?.[0]!.type; - // console.log(object.description); + const a = ts.factory.createIdentifier("a"); + const b = ts.factory.createIdentifier("b"); + // console.log(props.type); + + // const statements = transform(a, b, result.data, props); + const expression = transform(a, b, props.context, props.type); + const argType = props.context.checker.typeToTypeNode( + props.type, + undefined, + ts.NodeBuilderFlags.NoTruncation, + ); return { functions: {}, @@ -49,22 +54,16 @@ export namespace CompareEqualsProgrammer { arrow: ts.factory.createArrowFunction( undefined, undefined, - [], - props.context.importer.type({ - file: "typia", - name: "Resolved", - arguments: [ - ts.factory.createTypeReferenceNode( - props.name ?? - TypeFactory.getFullName({ - checker: props.context.checker, - type: props.type, - }), - ), - ], - }), + [ + IdentifierFactory.parameter("a", argType), + IdentifierFactory.parameter("b", argType), + ], + ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword), undefined, - ts.factory.createBlock([], true), + ts.factory.createBlock( + [ts.factory.createExpressionStatement(expression)], + true, + ), ), }; }; @@ -75,15 +74,155 @@ export namespace CompareEqualsProgrammer { ...props, functor, }); - console.log("-----------------------------------------------------"); - console.log(result); - console.log("-----------------------------------------------------"); - console.log(props.modulo); - console.log("-----------------------------------------------------"); + + // console.log("-----------------------------------------------------"); + // console.log(props.context); + // console.log("-----------------------------------------------------"); + // console.log(props.modulo); + // console.log("-----------------------------------------------------"); return FeatureProgrammer.writeDecomposed({ modulo: props.modulo, functor, result, }); }; + function isPrimitiveType(type: ts.Type): boolean { + const primitiveFlags = + ts.TypeFlags.String | + ts.TypeFlags.Number | + ts.TypeFlags.Boolean | + ts.TypeFlags.BigInt | + ts.TypeFlags.ESSymbol | + ts.TypeFlags.Null | + ts.TypeFlags.Undefined | + ts.TypeFlags.StringLiteral | + ts.TypeFlags.NumberLiteral | + ts.TypeFlags.BooleanLiteral | + ts.TypeFlags.BigIntLiteral; + return (type.flags & primitiveFlags) !== 0; + } + function eqeqeq(a: ts.Identifier, b: ts.Identifier) { + return ts.factory.createExpressionStatement( + ts.factory.createBinaryExpression( + a, + ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), + b, + ), + ); + } + + function eqeqeqReturn(a: ts.Identifier, b: ts.Identifier) { + return ts.factory.createIfStatement( + eqeqeq(a, b).expression, + ts.factory.createReturnStatement( + ts.factory.createToken(ts.SyntaxKind.TrueKeyword), + ), + ); + } + + function mergeWithAmp(expressions: ts.Expression[]) { + if (expressions.length === 0) { + return ts.factory.createTrue(); + } + + return expressions.reduce((acc, current) => + ts.factory.createBinaryExpression( + acc, + ts.factory.createToken(ts.SyntaxKind.AmpersandAmpersandToken), + current, + ), + ); + } + + function transform( + a: ts.Identifier, + b: ts.Identifier, + context: ITypiaContext, + type: ts.Type, + ): ts.Expression { + if (isPrimitiveType(type)) { + return eqeqeqReturn(a, b).expression; + } + + if (context.checker.isArrayType(type)) { + return eqeqeqReturn(a, b).expression; + } + if (context.checker.isTupleType(type)) { + return eqeqeqReturn(a, b).expression; + } + + if ((type.flags & ts.TypeFlags.Object) !== 0) { + const properties = type.getProperties(); + const statements = properties.flatMap((prop) => { + return transform( + ts.factory.createIdentifier(`${a.escapedText}.${prop.escapedName}`), + ts.factory.createIdentifier(`${b.escapedText}.${prop.escapedName}`), + context, + context.checker.getTypeOfSymbolAtLocation( + prop, + prop.declarations![0]!, + ), + ); + }); + return ts.factory.createBinaryExpression( + eqeqeq(a, b).expression, + ts.factory.createToken(ts.SyntaxKind.BarBarToken), + mergeWithAmp(statements), + ); + } + + throw new Error("Unsupported type"); + } + + // function transform_( + // a: ts.Identifier, + // b: ts.Identifier, + // metadata: Metadata, + // props: { + // context: ITypiaContext; + // type: ts.Type; + // }, + // ) { + // if (metadata.atomics[0]) { + // // DO: + // return [ + // ts.factory.createExpressionStatement( + // ts.factory.createBinaryExpression( + // a, + // ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), + // b, + // ), + // ), + // ]; + // } + // // if (props.metadata.tuples[0]) { + // // const tuple = props.metadata.tuples[0]!.type; + // // console.log(tuple.elements.at(0)); + // // return [ + // // ts.factory.createExpressionStatement( + // // ts.factory.createBinaryExpression( + // // eqeqeq(a, b).expression, + // // ts.factory.createToken(ts.SyntaxKind.AmpersandAmpersandEqualsToken), + // // b, + // // ), + // // ), + // // ]; + // // } + // if (metadata.objects[0]) { + // // const tuple = props.metadata.tuples[0]!.type; + // // console.log(tuple.elements.at(0)); + // // props.type.isTypeParameter + // return [eqeqeqReturn(a, b), ...transform_meta(a, b, metadata.objects)]; + // } + // + // return [ + // ts.factory.createExpressionStatement( + // ts.factory.createBinaryExpression( + // a, + // ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), + // b, + // ), + // ), + // ]; + // } } diff --git a/test/generate/input/generate_comare.ts b/test/generate/input/generate_comare.ts new file mode 100644 index 00000000000..e27113b46a8 --- /dev/null +++ b/test/generate/input/generate_comare.ts @@ -0,0 +1,13 @@ +import typia from "typia"; + +interface ISomething { + id: string; + age: number; +} + +// export const objects = typia.compare.equals( +// { id: "1", age: 2 }, +// { id: "1", age: 2 }, +// ); + +export const arrays = typia.compare.equals([1, 2, 3], [1, 2, 3]); From 39600b202b4d56580a63d107da4bd10ba35eb1eb Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Sat, 15 Feb 2025 15:41:57 +0200 Subject: [PATCH 03/13] Suppport arrays, tuples, optional props --- .../compare/CompareEqualsProgrammer.ts | 229 +++++++++++------- test/generate/input/generate_comare.ts | 14 +- 2 files changed, 159 insertions(+), 84 deletions(-) diff --git a/src/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts index b94b50c988b..badf5f76d30 100644 --- a/src/programmers/compare/CompareEqualsProgrammer.ts +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -61,7 +61,7 @@ export namespace CompareEqualsProgrammer { ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword), undefined, ts.factory.createBlock( - [ts.factory.createExpressionStatement(expression)], + [ts.factory.createReturnStatement(expression)], true, ), ), @@ -101,7 +101,7 @@ export namespace CompareEqualsProgrammer { ts.TypeFlags.BigIntLiteral; return (type.flags & primitiveFlags) !== 0; } - function eqeqeq(a: ts.Identifier, b: ts.Identifier) { + function eqeqeq(a: ts.Expression, b: ts.Expression) { return ts.factory.createExpressionStatement( ts.factory.createBinaryExpression( a, @@ -111,52 +111,171 @@ export namespace CompareEqualsProgrammer { ); } - function eqeqeqReturn(a: ts.Identifier, b: ts.Identifier) { - return ts.factory.createIfStatement( - eqeqeq(a, b).expression, - ts.factory.createReturnStatement( - ts.factory.createToken(ts.SyntaxKind.TrueKeyword), - ), - ); - } + // function eqeqeqReturn(a: ts.Identifier, b: ts.Identifier) { + // return ts.factory.createIfStatement( + // eqeqeq(a, b).expression, + // ts.factory.createReturnStatement( + // ts.factory.createToken(ts.SyntaxKind.TrueKeyword), + // ), + // ); + // } - function mergeWithAmp(expressions: ts.Expression[]) { + function mergeWithAmp( + expressions: ts.Expression[], + withParenthesized = false, + ) { if (expressions.length === 0) { return ts.factory.createTrue(); } - return expressions.reduce((acc, current) => - ts.factory.createBinaryExpression( - acc, - ts.factory.createToken(ts.SyntaxKind.AmpersandAmpersandToken), - current, - ), + const result = expressions.reduce((acc, current) => and(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("index"), + }; + const ids = { + item: ts.factory.createIdentifier("item"), + index: ts.factory.createIdentifier("index"), + every: ts.factory.createIdentifier("every"), + length: ts.factory.createIdentifier("length"), + }; + + 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 (optinal) { + return ts.factory.createPropertyAccessChain( + target, + ts.factory.createToken(ts.SyntaxKind.QuestionDotToken), + prop, + ); + } else { + return ts.factory.createPropertyAccessExpression(target, prop); + } + } + function transform( - a: ts.Identifier, - b: ts.Identifier, + a: ts.Expression, + b: ts.Expression, context: ITypiaContext, type: ts.Type, ): ts.Expression { if (isPrimitiveType(type)) { - return eqeqeqReturn(a, b).expression; + return eqeqeq(a, b).expression; } - if (context.checker.isArrayType(type)) { - return eqeqeqReturn(a, b).expression; - } if (context.checker.isTupleType(type)) { - return eqeqeqReturn(a, b).expression; + const tuple = type as ts.TypeReference; + const types = context.checker.getTypeArguments(tuple); + const compares = types.map((type, index) => + transform( + indexAccess(a, ts.factory.createIdentifier(index.toString())), + indexAccess(b, ts.factory.createIdentifier(index.toString())), + context, + type, + ), + ); + return or(eqeqeq(a, b).expression, mergeWithAmp(compares, true)); + } + + if (context.checker.isArrayType(type)) { + const elementType = context.checker.getElementTypeOfArrayType(type); + if (!elementType) { + throw new Error(`Unknown type of ${type}`); + } + + const checkFn = ts.factory.createArrowFunction( + undefined, + undefined, + [params.item, params.index], + undefined, + undefined, + ts.factory.createBlock([ + ts.factory.createReturnStatement( + transform( + ids.item, + indexAccess(b, ids.index, true), + context, + elementType, + ), + ), + ]), + ); + + 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, [ + checkFn, + ]), + ), + ), + ); } if ((type.flags & ts.TypeFlags.Object) !== 0) { const properties = type.getProperties(); const statements = properties.flatMap((prop) => { + const optional = + prop.declarations?.some((decl) => { + if ( + ts.isPropertySignature(decl) || + ts.isPropertyDeclaration(decl) + ) { + return Boolean(decl.questionToken); + } + return false; + }) ?? false; + return transform( - ts.factory.createIdentifier(`${a.escapedText}.${prop.escapedName}`), - ts.factory.createIdentifier(`${b.escapedText}.${prop.escapedName}`), + access( + a, + ts.factory.createIdentifier(prop.escapedName.toString()), + optional, + ), + access( + b, + ts.factory.createIdentifier(prop.escapedName.toString()), + optional, + ), context, context.checker.getTypeOfSymbolAtLocation( prop, @@ -164,65 +283,9 @@ export namespace CompareEqualsProgrammer { ), ); }); - return ts.factory.createBinaryExpression( - eqeqeq(a, b).expression, - ts.factory.createToken(ts.SyntaxKind.BarBarToken), - mergeWithAmp(statements), - ); + return or(eqeqeq(a, b).expression, mergeWithAmp(statements, true)); } throw new Error("Unsupported type"); } - - // function transform_( - // a: ts.Identifier, - // b: ts.Identifier, - // metadata: Metadata, - // props: { - // context: ITypiaContext; - // type: ts.Type; - // }, - // ) { - // if (metadata.atomics[0]) { - // // DO: - // return [ - // ts.factory.createExpressionStatement( - // ts.factory.createBinaryExpression( - // a, - // ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), - // b, - // ), - // ), - // ]; - // } - // // if (props.metadata.tuples[0]) { - // // const tuple = props.metadata.tuples[0]!.type; - // // console.log(tuple.elements.at(0)); - // // return [ - // // ts.factory.createExpressionStatement( - // // ts.factory.createBinaryExpression( - // // eqeqeq(a, b).expression, - // // ts.factory.createToken(ts.SyntaxKind.AmpersandAmpersandEqualsToken), - // // b, - // // ), - // // ), - // // ]; - // // } - // if (metadata.objects[0]) { - // // const tuple = props.metadata.tuples[0]!.type; - // // console.log(tuple.elements.at(0)); - // // props.type.isTypeParameter - // return [eqeqeqReturn(a, b), ...transform_meta(a, b, metadata.objects)]; - // } - // - // return [ - // ts.factory.createExpressionStatement( - // ts.factory.createBinaryExpression( - // a, - // ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), - // b, - // ), - // ), - // ]; - // } } diff --git a/test/generate/input/generate_comare.ts b/test/generate/input/generate_comare.ts index e27113b46a8..b17cce2b620 100644 --- a/test/generate/input/generate_comare.ts +++ b/test/generate/input/generate_comare.ts @@ -10,4 +10,16 @@ interface ISomething { // { id: "1", age: 2 }, // ); -export const arrays = typia.compare.equals([1, 2, 3], [1, 2, 3]); +// 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" }] }); From 151b979ee0ddc868eb3f73b0c87ca3dfac1937a1 Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Sat, 15 Feb 2025 16:02:35 +0200 Subject: [PATCH 04/13] Support unions and removed unused code --- .../compare/CompareEqualsProgrammer.ts | 80 +++++++++-------- test/generate/input/generate_comare.ts | 23 +++-- test/generate/output/generate_comare.ts | 88 +++++++++++++++++++ 3 files changed, 147 insertions(+), 44 deletions(-) create mode 100644 test/generate/output/generate_comare.ts diff --git a/src/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts index badf5f76d30..532e7b7625c 100644 --- a/src/programmers/compare/CompareEqualsProgrammer.ts +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -9,38 +9,14 @@ import { FeatureProgrammer } from "../FeatureProgrammer"; import { FunctionProgrammer } from "../helpers/FunctionProgrammer"; export namespace CompareEqualsProgrammer { - export const decompose = (props: { + export function decompose(props: { context: ITypiaContext; functor: FunctionProgrammer; type: ts.Type; name: string | undefined; - }): FeatureProgrammer.IDecomposed => { - // ANALYZE TYPE - // const collection: MetadataCollection = new MetadataCollection(); - // const result = MetadataFactory.analyze({ - // checker: props.context.checker, - // transformer: props.context.transformer, - // options: { - // escape: false, - // constant: true, - // absorb: true, - // }, - // collection, - // type: props.type, - // }); - // if (result.success === false) { - // throw TransformerError.from({ - // code: props.functor.method, - // errors: result.errors, - // }); - // } - - // DO TRANSFORM + }): FeatureProgrammer.IDecomposed { const a = ts.factory.createIdentifier("a"); const b = ts.factory.createIdentifier("b"); - // console.log(props.type); - - // const statements = transform(a, b, result.data, props); const expression = transform(a, b, props.context, props.type); const argType = props.context.checker.typeToTypeNode( props.type, @@ -66,26 +42,22 @@ export namespace CompareEqualsProgrammer { ), ), }; - }; + } - export const write = (props: IProgrammerProps) => { + export function write(props: IProgrammerProps) { const functor = new FunctionProgrammer(props.modulo.getText()); const result: FeatureProgrammer.IDecomposed = decompose({ ...props, functor, }); - // console.log("-----------------------------------------------------"); - // console.log(props.context); - // console.log("-----------------------------------------------------"); - // console.log(props.modulo); - // console.log("-----------------------------------------------------"); return FeatureProgrammer.writeDecomposed({ modulo: props.modulo, functor, result, }); - }; + } + function isPrimitiveType(type: ts.Type): boolean { const primitiveFlags = ts.TypeFlags.String | @@ -135,6 +107,21 @@ export namespace CompareEqualsProgrammer { 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, @@ -196,6 +183,22 @@ export namespace CompareEqualsProgrammer { context: ITypiaContext, type: ts.Type, ): ts.Expression { + if (type.isUnion()) { + const union = type as ts.UnionType; + let primitiveHandled = false; + const compares: ts.Expression[] = []; + for (const type of union.types) { + if (isPrimitiveType(type)) { + if (primitiveHandled) { + continue; + } + primitiveHandled = true; + } + compares.push(transform(a, b, context, type)); + } + return or(eqeqeq(a, b).expression, mergeWithBar(compares, true)); + } + if (isPrimitiveType(type)) { return eqeqeq(a, b).expression; } @@ -230,7 +233,14 @@ export namespace CompareEqualsProgrammer { ts.factory.createReturnStatement( transform( ids.item, - indexAccess(b, ids.index, true), + indexAccess( + ts.factory.createAsExpression( + b, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword), + ), + ids.index, + true, + ), context, elementType, ), diff --git a/test/generate/input/generate_comare.ts b/test/generate/input/generate_comare.ts index b17cce2b620..b596f59cf71 100644 --- a/test/generate/input/generate_comare.ts +++ b/test/generate/input/generate_comare.ts @@ -5,12 +5,12 @@ interface ISomething { age: number; } -// export const objects = typia.compare.equals( -// { id: "1", age: 2 }, -// { id: "1", age: 2 }, -// ); +export const objects = typia.compare.equals( + { id: "1", age: 2 }, + { id: "1", age: 2 }, +); -// export const arrays = typia.compare.equals([1, 2, 3], [1, 2, 3]); +export const arrays = typia.compare.equals([1, 2, 3], [1, 2, 3]); export const tuple = typia.compare.equals< [number, string, { foo: string; bar?: string }] @@ -19,7 +19,12 @@ export const tuple = typia.compare.equals< [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 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" }]); diff --git a/test/generate/output/generate_comare.ts b/test/generate/output/generate_comare.ts new file mode 100644 index 00000000000..e4eeead5451 --- /dev/null +++ b/test/generate/output/generate_comare.ts @@ -0,0 +1,88 @@ +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 }); +export const arrays = (() => { + return (a: number[], b: number[]): boolean => { + return ( + a === b || + (a.length === b.length && + a.every((item: any, index: any) => { + return item === (b as any)[index]!; + })) + ); + }; +})()([1, 2, 3], [1, 2, 3]); +export const tuple = (() => { + return ( + a: [number, string, { foo: string; bar?: string }], + b: [number, string, { foo: string; bar?: string }], + ): boolean => { + return ( + a === b || + (a[0] === b[0] && + a[1] === b[1] && + (a[2] === b[2] || (a[2].foo === b[2].foo && a[2]?.bar === b[2]?.bar))) + ); + }; +})()( + [1, "foo", { foo: "bar", bar: "baz" }], + [1, "foo", { foo: "bar", bar: "baz" }], +); +export const nested = (() => { + return ( + a: { id: number; items: { name: string }[] }, + b: { id: number; items: { name: string }[] }, + ): boolean => { + return ( + a === b || + (a.id === b.id && + (a.items === b.items || + (a.items.length === b.items.length && + a.items.every((item: any, index: any) => { + return ( + item === (b.items as any)[index]! || + item.name === (b.items as any)[index]!.name + ); + })))) + ); + }; +})()({ id: 1, items: [{ name: "foo" }] }, { id: 1, items: [{ name: "foo" }] }); +export const union = (() => { + return (a: (string | number)[], b: (string | number)[]): boolean => { + return ( + a === b || + (a.length === b.length && + a.every((item: any, index: any) => { + return item === (b as any)[index]! || item === (b as any)[index]!; + })) + ); + }; +})()([1], [1]); +export const unionNested = (() => { + return ( + a: ({ foo: string } | { bar: number })[], + b: ({ foo: string } | { bar: number })[], + ): boolean => { + return ( + a === b || + (a.length === b.length && + a.every((item: any, index: any) => { + return ( + item === (b as any)[index]! || + item === (b as any)[index]! || + item.foo === (b as any)[index]!.foo || + item === (b as any)[index]! || + item.bar === (b as any)[index]!.bar + ); + })) + ); + }; +})()([{ foo: "1" }], [{ foo: "1" }]); From c764e8f38b45bcabe158a52d5602db9b67e14ce6 Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Sat, 15 Feb 2025 18:32:21 +0200 Subject: [PATCH 05/13] Generated tests --- .../compare.equals/test_compare_equals_ArrayAny.ts | 10 ++++++++++ .../test_compare_equals_ArrayAtomicAlias.ts | 10 ++++++++++ .../test_compare_equals_ArrayAtomicSimple.ts | 10 ++++++++++ .../test_compare_equals_ArrayHierarchical.ts | 10 ++++++++++ .../test_compare_equals_ArrayHierarchicalPointer.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ArrayMatrix.ts | 10 ++++++++++ .../test_compare_equals_ArrayRecursive.ts | 10 ++++++++++ .../test_compare_equals_ArrayRecursiveUnionExplicit.ts | 10 ++++++++++ ...ompare_equals_ArrayRecursiveUnionExplicitPointer.ts | 10 ++++++++++ .../test_compare_equals_ArrayRecursiveUnionImplicit.ts | 10 ++++++++++ .../test_compare_equals_ArrayRepeatedNullable.ts | 10 ++++++++++ .../test_compare_equals_ArrayRepeatedOptional.ts | 10 ++++++++++ .../test_compare_equals_ArrayRepeatedRequired.ts | 10 ++++++++++ .../test_compare_equals_ArrayRepeatedUnion.ts | 10 ++++++++++ .../test_compare_equals_ArrayRepeatedUnionWithTuple.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ArraySimple.ts | 10 ++++++++++ .../test_compare_equals_ArraySimpleProtobuf.ts | 10 ++++++++++ .../test_compare_equals_ArraySimpleProtobufNullable.ts | 10 ++++++++++ .../test_compare_equals_ArraySimpleProtobufOptional.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ArrayUnion.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_AtomicAlias.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_AtomicClass.ts | 10 ++++++++++ .../test_compare_equals_AtomicIntersection.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_AtomicSimple.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_AtomicUnion.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ClassClosure.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ClassGetter.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ClassMethod.ts | 10 ++++++++++ .../test_compare_equals_ClassNonPublic.ts | 10 ++++++++++ .../test_compare_equals_ClassPropertyAssignment.ts | 10 ++++++++++ .../test_compare_equals_CommentTagArray.ts | 10 ++++++++++ .../test_compare_equals_CommentTagArrayUnion.ts | 10 ++++++++++ .../test_compare_equals_CommentTagAtomicUnion.ts | 10 ++++++++++ .../test_compare_equals_CommentTagBigInt.ts | 10 ++++++++++ .../test_compare_equals_CommentTagDefault.ts | 10 ++++++++++ .../test_compare_equals_CommentTagFormat.ts | 10 ++++++++++ .../test_compare_equals_CommentTagInfinite.ts | 10 ++++++++++ .../test_compare_equals_CommentTagLength.ts | 10 ++++++++++ .../test_compare_equals_CommentTagNaN.ts | 10 ++++++++++ .../test_compare_equals_CommentTagObjectUnion.ts | 10 ++++++++++ .../test_compare_equals_CommentTagPattern.ts | 10 ++++++++++ .../test_compare_equals_CommentTagRange.ts | 10 ++++++++++ .../test_compare_equals_CommentTagRangeBigInt.ts | 10 ++++++++++ .../test_compare_equals_CommentTagType.ts | 10 ++++++++++ .../test_compare_equals_CommentTagTypeBigInt.ts | 10 ++++++++++ .../test_compare_equals_ConstantAtomicAbsorbed.ts | 10 ++++++++++ .../test_compare_equals_ConstantAtomicSimple.ts | 10 ++++++++++ .../test_compare_equals_ConstantAtomicTagged.ts | 10 ++++++++++ .../test_compare_equals_ConstantAtomicUnion.ts | 10 ++++++++++ .../test_compare_equals_ConstantAtomicWrapper.ts | 10 ++++++++++ .../test_compare_equals_ConstantConstEnumeration.ts | 10 ++++++++++ .../test_compare_equals_ConstantEnumeration.ts | 10 ++++++++++ .../test_compare_equals_ConstantIntersection.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_DynamicArray.ts | 10 ++++++++++ .../test_compare_equals_DynamicComposite.ts | 10 ++++++++++ .../test_compare_equals_DynamicConstant.ts | 10 ++++++++++ .../test_compare_equals_DynamicEnumeration.ts | 10 ++++++++++ .../test_compare_equals_DynamicJsonValue.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_DynamicNever.ts | 10 ++++++++++ .../test_compare_equals_DynamicSimple.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_DynamicTag.ts | 10 ++++++++++ .../test_compare_equals_DynamicTemplate.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_DynamicTree.ts | 10 ++++++++++ .../test_compare_equals_DynamicUndefined.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_DynamicUnion.ts | 10 ++++++++++ .../test_compare_equals_FunctionalArray.ts | 10 ++++++++++ .../test_compare_equals_FunctionalArrayUnion.ts | 10 ++++++++++ .../test_compare_equals_FunctionalObjectUnion.ts | 10 ++++++++++ .../test_compare_equals_FunctionalProperty.ts | 10 ++++++++++ .../test_compare_equals_FunctionalPropertyUnion.ts | 10 ++++++++++ .../test_compare_equals_FunctionalTuple.ts | 10 ++++++++++ .../test_compare_equals_FunctionalTupleUnion.ts | 10 ++++++++++ .../test_compare_equals_FunctionalValue.ts | 10 ++++++++++ .../test_compare_equals_FunctionalValueUnion.ts | 10 ++++++++++ .../test_compare_equals_InstanceUnion.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_MapAlias.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_MapSimple.ts | 10 ++++++++++ .../test_compare_equals_MapSimpleProtobuf.ts | 10 ++++++++++ .../test_compare_equals_MapSimpleProtobufNullable.ts | 10 ++++++++++ .../test_compare_equals_MapSimpleProtobufOptional.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_MapUnion.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_NativeSimple.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_NativeUnion.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ObjectAlias.ts | 10 ++++++++++ .../test_compare_equals_ObjectClosure.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ObjectDate.ts | 10 ++++++++++ .../test_compare_equals_ObjectDescription.ts | 10 ++++++++++ .../test_compare_equals_ObjectDynamic.ts | 10 ++++++++++ .../test_compare_equals_ObjectGeneric.ts | 10 ++++++++++ .../test_compare_equals_ObjectGenericAlias.ts | 10 ++++++++++ .../test_compare_equals_ObjectGenericArray.ts | 10 ++++++++++ .../test_compare_equals_ObjectGenericUnion.ts | 10 ++++++++++ .../test_compare_equals_ObjectHierarchical.ts | 10 ++++++++++ .../test_compare_equals_ObjectHttpArray.ts | 10 ++++++++++ .../test_compare_equals_ObjectHttpAtomic.ts | 10 ++++++++++ .../test_compare_equals_ObjectHttpCommentTag.ts | 10 ++++++++++ .../test_compare_equals_ObjectHttpConstant.ts | 10 ++++++++++ .../test_compare_equals_ObjectHttpFormData.ts | 10 ++++++++++ .../test_compare_equals_ObjectHttpNullable.ts | 10 ++++++++++ .../test_compare_equals_ObjectHttpTypeTag.ts | 10 ++++++++++ .../test_compare_equals_ObjectHttpUndefindable.ts | 10 ++++++++++ .../test_compare_equals_ObjectInternal.ts | 10 ++++++++++ .../test_compare_equals_ObjectIntersection.ts | 10 ++++++++++ .../test_compare_equals_ObjectJsonTag.ts | 10 ++++++++++ .../test_compare_equals_ObjectLiteralProperty.ts | 10 ++++++++++ .../test_compare_equals_ObjectLiteralType.ts | 10 ++++++++++ .../test_compare_equals_ObjectNullable.ts | 10 ++++++++++ .../test_compare_equals_ObjectOptional.ts | 10 ++++++++++ .../test_compare_equals_ObjectPartial.ts | 10 ++++++++++ .../test_compare_equals_ObjectPartialAndRequired.ts | 10 ++++++++++ .../test_compare_equals_ObjectPrimitive.ts | 10 ++++++++++ .../test_compare_equals_ObjectPropertyNullable.ts | 10 ++++++++++ .../test_compare_equals_ObjectRecursive.ts | 10 ++++++++++ .../test_compare_equals_ObjectRequired.ts | 10 ++++++++++ .../test_compare_equals_ObjectSequenceProtobuf.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ObjectSimple.ts | 10 ++++++++++ .../test_compare_equals_ObjectSimpleProtobuf.ts | 10 ++++++++++ ...test_compare_equals_ObjectSimpleProtobufNullable.ts | 10 ++++++++++ ...test_compare_equals_ObjectSimpleProtobufOptional.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ObjectTuple.ts | 10 ++++++++++ .../test_compare_equals_ObjectUndefined.ts | 10 ++++++++++ .../test_compare_equals_ObjectUnionComposite.ts | 10 ++++++++++ .../test_compare_equals_ObjectUnionCompositePointer.ts | 10 ++++++++++ .../test_compare_equals_ObjectUnionDouble.ts | 10 ++++++++++ .../test_compare_equals_ObjectUnionExplicit.ts | 10 ++++++++++ .../test_compare_equals_ObjectUnionExplicitPointer.ts | 10 ++++++++++ .../test_compare_equals_ObjectUnionImplicit.ts | 10 ++++++++++ .../test_compare_equals_ObjectUnionNonPredictable.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_SetAlias.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_SetSimple.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_SetUnion.ts | 10 ++++++++++ .../test_compare_equals_TemplateAtomic.ts | 10 ++++++++++ .../test_compare_equals_TemplateConstant.ts | 10 ++++++++++ .../test_compare_equals_TemplateUnion.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ToJsonArray.ts | 10 ++++++++++ .../test_compare_equals_ToJsonAtomicSimple.ts | 10 ++++++++++ .../test_compare_equals_ToJsonAtomicUnion.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ToJsonDouble.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ToJsonNull.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ToJsonTuple.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_ToJsonUnion.ts | 10 ++++++++++ .../test_compare_equals_TupleHierarchical.ts | 10 ++++++++++ .../test_compare_equals_TupleOptional.ts | 10 ++++++++++ .../test_compare_equals_TupleRestArray.ts | 10 ++++++++++ .../test_compare_equals_TupleRestAtomic.ts | 10 ++++++++++ .../test_compare_equals_TupleRestObject.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_TupleUnion.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_TypeTagArray.ts | 10 ++++++++++ .../test_compare_equals_TypeTagArrayUnion.ts | 10 ++++++++++ .../test_compare_equals_TypeTagAtomicUnion.ts | 10 ++++++++++ .../test_compare_equals_TypeTagBigInt.ts | 10 ++++++++++ .../test_compare_equals_TypeTagCustom.ts | 10 ++++++++++ .../test_compare_equals_TypeTagDefault.ts | 10 ++++++++++ .../test_compare_equals_TypeTagFormat.ts | 10 ++++++++++ .../test_compare_equals_TypeTagInfinite.ts | 10 ++++++++++ .../test_compare_equals_TypeTagLength.ts | 10 ++++++++++ .../test_compare_equals_TypeTagMatrix.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_TypeTagNaN.ts | 10 ++++++++++ .../test_compare_equals_TypeTagObjectUnion.ts | 10 ++++++++++ .../test_compare_equals_TypeTagPattern.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_TypeTagRange.ts | 10 ++++++++++ .../test_compare_equals_TypeTagRangeBigInt.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_TypeTagTuple.ts | 10 ++++++++++ .../compare.equals/test_compare_equals_TypeTagType.ts | 10 ++++++++++ .../test_compare_equals_TypeTagTypeBigInt.ts | 10 ++++++++++ .../test_compare_equals_TypeTagTypeUnion.ts | 10 ++++++++++ .../test_compare_equals_UltimateUnion.ts | 10 ++++++++++ 167 files changed, 1670 insertions(+) create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayAny.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayAtomicAlias.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayAtomicSimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayHierarchical.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayHierarchicalPointer.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayMatrix.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayRecursive.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionExplicit.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionExplicitPointer.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayRecursiveUnionImplicit.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayRepeatedNullable.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayRepeatedOptional.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayRepeatedRequired.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayRepeatedUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayRepeatedUnionWithTuple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArraySimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobuf.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobufNullable.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArraySimpleProtobufOptional.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ArrayUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_AtomicAlias.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_AtomicClass.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_AtomicIntersection.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_AtomicSimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_AtomicUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ClassClosure.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ClassGetter.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ClassMethod.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ClassNonPublic.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ClassPropertyAssignment.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagArray.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagArrayUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagAtomicUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagBigInt.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagDefault.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagFormat.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagInfinite.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagLength.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagNaN.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagObjectUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagPattern.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagRange.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagRangeBigInt.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagType.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_CommentTagTypeBigInt.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ConstantAtomicAbsorbed.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ConstantAtomicSimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ConstantAtomicTagged.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ConstantAtomicUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ConstantAtomicWrapper.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ConstantConstEnumeration.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ConstantEnumeration.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ConstantIntersection.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicArray.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicComposite.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicConstant.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicEnumeration.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicJsonValue.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicNever.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicSimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicTag.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicTemplate.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicTree.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicUndefined.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_DynamicUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_FunctionalArray.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_FunctionalArrayUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_FunctionalObjectUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_FunctionalProperty.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_FunctionalPropertyUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_FunctionalTuple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_FunctionalTupleUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_FunctionalValue.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_FunctionalValueUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_InstanceUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_MapAlias.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_MapSimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_MapSimpleProtobuf.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_MapSimpleProtobufNullable.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_MapSimpleProtobufOptional.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_MapUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_NativeSimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_NativeUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectAlias.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectClosure.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectDate.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectDescription.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectDynamic.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectGeneric.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectGenericAlias.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectGenericArray.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectGenericUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectHierarchical.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectHttpArray.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectHttpAtomic.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectHttpCommentTag.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectHttpConstant.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectHttpFormData.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectHttpNullable.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectHttpTypeTag.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectHttpUndefindable.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectInternal.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectIntersection.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectJsonTag.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectLiteralProperty.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectLiteralType.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectNullable.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectOptional.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectPartial.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectPartialAndRequired.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectPrimitive.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectPropertyNullable.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectRecursive.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectRequired.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectSequenceProtobuf.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectSimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobuf.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobufNullable.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectSimpleProtobufOptional.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectTuple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectUndefined.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectUnionComposite.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectUnionCompositePointer.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectUnionDouble.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectUnionExplicit.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectUnionExplicitPointer.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectUnionImplicit.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ObjectUnionNonPredictable.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_SetAlias.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_SetSimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_SetUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TemplateAtomic.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TemplateConstant.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TemplateUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ToJsonArray.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ToJsonAtomicSimple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ToJsonAtomicUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ToJsonDouble.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ToJsonNull.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ToJsonTuple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_ToJsonUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TupleHierarchical.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TupleOptional.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TupleRestArray.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TupleRestAtomic.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TupleRestObject.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TupleUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagArray.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagArrayUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagAtomicUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagBigInt.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagCustom.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagDefault.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagFormat.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagInfinite.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagLength.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagMatrix.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagNaN.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagObjectUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagPattern.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagRange.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagRangeBigInt.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagTuple.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagType.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagTypeBigInt.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_TypeTagTypeUnion.ts create mode 100644 test/src/features/compare.equals/test_compare_equals_UltimateUnion.ts 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 00000000000..f15da6fe072 --- /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 00000000000..9af2fbd0352 --- /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 00000000000..e437caa488d --- /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 00000000000..bf18642c6bb --- /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 00000000000..35ee6968705 --- /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 00000000000..1c07abc33e3 --- /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 00000000000..3bdd121bf37 --- /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 00000000000..6f5f475a419 --- /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 00000000000..f966d9b6969 --- /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 00000000000..28b3d81b97e --- /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 00000000000..cd970f73902 --- /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 00000000000..3b331a26dff --- /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 00000000000..58a78babe51 --- /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 00000000000..a408e13f633 --- /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 00000000000..81c43bcb8ca --- /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 00000000000..9c80dd58d23 --- /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 00000000000..0bf3f2653a5 --- /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 00000000000..e3e7ebe3706 --- /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 00000000000..7f560b92fc0 --- /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 00000000000..c9c9148418c --- /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 00000000000..70e8b43816c --- /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 00000000000..d2a5a6b98a2 --- /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 00000000000..aea1f394c17 --- /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 00000000000..3508159d4cb --- /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 00000000000..4fb44b326c9 --- /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 00000000000..dcc9c515e6b --- /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 00000000000..c0158c71f58 --- /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 00000000000..807fb87bdf5 --- /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 00000000000..6e637a2cd16 --- /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 00000000000..d1bcf4ced81 --- /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 00000000000..f253830d7c5 --- /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 00000000000..7afbf5b3979 --- /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 00000000000..de212747819 --- /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 00000000000..37d42701a48 --- /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 00000000000..c36c728c793 --- /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 00000000000..c20388bc1f5 --- /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 00000000000..2692dd289a6 --- /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 00000000000..708e691d213 --- /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 00000000000..ad253585d6f --- /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 00000000000..2be7d9bc97b --- /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 00000000000..df8eae77779 --- /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 00000000000..a7b88c218bc --- /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 00000000000..b1a25cebe66 --- /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 00000000000..0e8d55a43f0 --- /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 00000000000..e8d2e558d01 --- /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 00000000000..0f18fbea46b --- /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 00000000000..3278967a192 --- /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 00000000000..24ea48ba47e --- /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 00000000000..b74d53af77b --- /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 00000000000..9fa2260246d --- /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 00000000000..3f05d913a85 --- /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 00000000000..80286ee31ac --- /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 00000000000..7ca7a88f587 --- /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 00000000000..32e8e9fb4ac --- /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 00000000000..6909328745d --- /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 00000000000..c9d60a8ee15 --- /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 00000000000..a5299ef7415 --- /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 00000000000..55699e43046 --- /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 00000000000..4713b299b31 --- /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 00000000000..ae9e4bdc784 --- /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 00000000000..f6d49206473 --- /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 00000000000..5179a84e1bb --- /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 00000000000..c46d327272c --- /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 00000000000..c472cb275b0 --- /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 00000000000..369cfffdc1d --- /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 00000000000..07af13bfabf --- /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 00000000000..4a830497895 --- /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 00000000000..d1b22a7be22 --- /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 00000000000..b29b4c013e6 --- /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 00000000000..db0dc26b2f4 --- /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 00000000000..26266fc0132 --- /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 00000000000..d3dceb7b4e9 --- /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 00000000000..cd2f53443c0 --- /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 00000000000..dfffbb6b701 --- /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 00000000000..4202a9549fc --- /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 00000000000..b3090f93919 --- /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 00000000000..8dc0ac07068 --- /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 00000000000..d44ae491e82 --- /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 00000000000..500226a98b1 --- /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 00000000000..bc156ec1bef --- /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 00000000000..1290278995a --- /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 00000000000..dae7fa16989 --- /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 00000000000..99fb9ce65ae --- /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 00000000000..d8d40165cfd --- /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 00000000000..14576aa9bad --- /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 00000000000..e83b229ef0a --- /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 00000000000..624417f38e0 --- /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 00000000000..573dd5ef16e --- /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 00000000000..676d7558b5b --- /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 00000000000..bfa47589db4 --- /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 00000000000..a920984cddb --- /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 00000000000..79ce0cfaf43 --- /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 00000000000..f71585e5fa4 --- /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 00000000000..d6da360ddcc --- /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 00000000000..4905f2916df --- /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 00000000000..5f0a4723c82 --- /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 00000000000..acbd37845b3 --- /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 00000000000..9a48e05a2b8 --- /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 00000000000..77dd9e8ea5d --- /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 00000000000..697bfe02ca0 --- /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 00000000000..d0dbb8dfc54 --- /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 00000000000..edbcd1667e4 --- /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 00000000000..477924bfc04 --- /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 00000000000..38720908717 --- /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 00000000000..110ddd43fb1 --- /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 00000000000..0cca328d1d3 --- /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 00000000000..ab2b6ed470c --- /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 00000000000..0b71ae21a10 --- /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 00000000000..83b51b97206 --- /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 00000000000..dd920e14c6d --- /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 00000000000..800cb22f612 --- /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 00000000000..3ccc525e0e2 --- /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 00000000000..e75255f5f06 --- /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 00000000000..a7e4c92a996 --- /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 00000000000..30db8d0b75d --- /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 00000000000..4454ea33092 --- /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 00000000000..fe6453ef373 --- /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 00000000000..a535c513ea3 --- /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 00000000000..cebdc4957b8 --- /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 00000000000..c791e34f9c0 --- /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 00000000000..bbb4efa664e --- /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 00000000000..a5965c0ac9b --- /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 00000000000..87e91212ad0 --- /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 00000000000..d8bfe330385 --- /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 00000000000..6bdce322e60 --- /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 00000000000..bb12610fa71 --- /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 00000000000..faec1d8bb5e --- /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 00000000000..cc442234dd7 --- /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 00000000000..5dc1065f17f --- /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 00000000000..74e2ca71f5e --- /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 00000000000..21f9d31f159 --- /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 00000000000..cf76052d54c --- /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 00000000000..7ee93b6b53e --- /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 00000000000..acf86d7d99e --- /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 00000000000..1fcaa98646b --- /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 00000000000..34380d7ab1b --- /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 00000000000..d84044fd367 --- /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 00000000000..c0575960edf --- /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 00000000000..9043767d901 --- /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 00000000000..4571c254bd7 --- /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 00000000000..961a6956889 --- /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 00000000000..140ab91f021 --- /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 00000000000..c4120753ff5 --- /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 00000000000..6ef0f71cb43 --- /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 00000000000..8f4cf493ca6 --- /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 00000000000..4703bff102e --- /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 00000000000..deae6b47e56 --- /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 00000000000..4e9369334a3 --- /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 00000000000..b44d5661c25 --- /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 00000000000..32f9ddcaa84 --- /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 00000000000..d1eb2d5142a --- /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 00000000000..ff01f169e31 --- /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 00000000000..f0fe98037b8 --- /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 00000000000..65957c6ee0a --- /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 00000000000..53b61a8f2d5 --- /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 00000000000..3db56797b8c --- /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 00000000000..ac14527a61f --- /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 00000000000..dfddcc829eb --- /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 00000000000..9d9e5c0f070 --- /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 00000000000..836f36552d8 --- /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 00000000000..5124175c5f4 --- /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 00000000000..caea97718ff --- /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 00000000000..ffb2cf863d6 --- /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 00000000000..cca12bd818a --- /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 00000000000..e4c1710f4a5 --- /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 00000000000..83d37af3c1c --- /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 00000000000..5142c27fb3d --- /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)); From b43668b10ddc4fcda98e996f293bd06af123ac1c Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Sat, 15 Feb 2025 18:32:39 +0200 Subject: [PATCH 06/13] Added template feature only --- test/build/internal/TestFeature.ts | 17 +++++++++ test/build/template.ts | 9 ++++- test/build/writers/write_compare.ts | 54 +++++++++++++++++++++++++++++ 3 files changed, 79 insertions(+), 1 deletion(-) create mode 100644 test/build/writers/write_compare.ts diff --git a/test/build/internal/TestFeature.ts b/test/build/internal/TestFeature.ts index 43ddac1ca76..510173c23bc 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 4d6342cbc50..0e1eabc1527 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 00000000000..db4fb33135e --- /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; +} From 903e80f6e908d76f738f33a24996a108c934b711 Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Sat, 15 Feb 2025 18:33:07 +0200 Subject: [PATCH 07/13] Remove throw exceptions --- .../compare/CompareEqualsProgrammer.ts | 11 +- test/generate/input/generate_comare.ts | 63 ++++++----- test/generate/output/generate_comare.ts | 102 +++++------------- 3 files changed, 65 insertions(+), 111 deletions(-) diff --git a/src/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts index 532e7b7625c..8c048c5f256 100644 --- a/src/programmers/compare/CompareEqualsProgrammer.ts +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -83,15 +83,6 @@ export namespace CompareEqualsProgrammer { ); } - // function eqeqeqReturn(a: ts.Identifier, b: ts.Identifier) { - // return ts.factory.createIfStatement( - // eqeqeq(a, b).expression, - // ts.factory.createReturnStatement( - // ts.factory.createToken(ts.SyntaxKind.TrueKeyword), - // ), - // ); - // } - function mergeWithAmp( expressions: ts.Expression[], withParenthesized = false, @@ -296,6 +287,6 @@ export namespace CompareEqualsProgrammer { return or(eqeqeq(a, b).expression, mergeWithAmp(statements, true)); } - throw new Error("Unsupported type"); + return eqeqeq(a, b).expression; } } diff --git a/test/generate/input/generate_comare.ts b/test/generate/input/generate_comare.ts index b596f59cf71..c3e91fb58f3 100644 --- a/test/generate/input/generate_comare.ts +++ b/test/generate/input/generate_comare.ts @@ -1,30 +1,43 @@ import typia from "typia"; -interface ISomething { - id: string; - age: number; -} - -export const objects = typia.compare.equals( - { id: "1", age: 2 }, - { id: "1", age: 2 }, -); - -export const arrays = typia.compare.equals([1, 2, 3], [1, 2, 3]); +// interface ISomething { +// id: string; +// age: number; +// } +// +// export const objects = typia.compare.equals( +// { id: "1", age: 2 }, +// { id: "1", age: 2 }, +// ); +// +// export const matrix = 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<{ +interface ICategory { + children: ICategory[]; id: number; - items: Array<{ name: string }>; -}>({ id: 1, items: [{ name: "foo" }] }, { id: 1, items: [{ name: "foo" }] }); + code: string; + sequence: number; +} +export const recurcive = typia.compare.equals(1 as any, 1 as any); -export const union = typia.compare.equals>([1], [1]); -export const unionNested = typia.compare.equals< - Array<{ foo: string } | { bar: number }> ->([{ foo: "1" }], [{ foo: "1" }]); +// 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" }]); diff --git a/test/generate/output/generate_comare.ts b/test/generate/output/generate_comare.ts index e4eeead5451..afbf509bfb3 100644 --- a/test/generate/output/generate_comare.ts +++ b/test/generate/output/generate_comare.ts @@ -1,88 +1,38 @@ 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 }); -export const arrays = (() => { - return (a: number[], b: number[]): boolean => { - return ( - a === b || - (a.length === b.length && - a.every((item: any, index: any) => { - return item === (b as any)[index]!; - })) - ); - }; -})()([1, 2, 3], [1, 2, 3]); -export const tuple = (() => { - return ( - a: [number, string, { foo: string; bar?: string }], - b: [number, string, { foo: string; bar?: string }], - ): boolean => { - return ( - a === b || - (a[0] === b[0] && - a[1] === b[1] && - (a[2] === b[2] || (a[2].foo === b[2].foo && a[2]?.bar === b[2]?.bar))) - ); - }; -})()( - [1, "foo", { foo: "bar", bar: "baz" }], - [1, "foo", { foo: "bar", bar: "baz" }], -); -export const nested = (() => { - return ( - a: { id: number; items: { name: string }[] }, - b: { id: number; items: { name: string }[] }, - ): boolean => { - return ( - a === b || - (a.id === b.id && - (a.items === b.items || - (a.items.length === b.items.length && - a.items.every((item: any, index: any) => { - return ( - item === (b.items as any)[index]! || - item.name === (b.items as any)[index]!.name - ); - })))) - ); - }; -})()({ id: 1, items: [{ name: "foo" }] }, { id: 1, items: [{ name: "foo" }] }); -export const union = (() => { - return (a: (string | number)[], b: (string | number)[]): boolean => { - return ( - a === b || - (a.length === b.length && - a.every((item: any, index: any) => { - return item === (b as any)[index]! || item === (b as any)[index]!; - })) - ); - }; -})()([1], [1]); -export const unionNested = (() => { - return ( - a: ({ foo: string } | { bar: number })[], - b: ({ foo: string } | { bar: number })[], - ): boolean => { +// interface ISomething { +// id: string; +// age: number; +// } +// +// export const objects = typia.compare.equals( +// { id: "1", age: 2 }, +// { id: "1", age: 2 }, +// ); +// +export const matrix = (() => { + return (a: number[][][], b: number[][][]): boolean => { return ( a === b || (a.length === b.length && a.every((item: any, index: any) => { return ( item === (b as any)[index]! || - item === (b as any)[index]! || - item.foo === (b as any)[index]!.foo || - item === (b as any)[index]! || - item.bar === (b as any)[index]!.bar + (item.length === (b as any)[index]!.length && + item.every((item: any, index: any) => { + return ( + item === ((b as any)[index]! as any)[index]! || + (item.length === ((b as any)[index]! as any)[index]!.length && + item.every((item: any, index: any) => { + return ( + item === + (((b as any)[index]! as any)[index]! as any)[index]! + ); + })) + ); + })) ); })) ); }; -})()([{ foo: "1" }], [{ foo: "1" }]); +})()([[[1, 2, 3]]], [[[1, 2, 3]]]); From dc478cfc0706d29ed61066d7600d0e0a5d168a36 Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Sun, 23 Feb 2025 18:26:37 +0200 Subject: [PATCH 08/13] Added meta information that it's class --- src/factories/internal/metadata/iterate_metadata.ts | 3 +++ src/schemas/metadata/IMetadata.ts | 1 + src/schemas/metadata/Metadata.ts | 6 ++++++ 3 files changed, 10 insertions(+) diff --git a/src/factories/internal/metadata/iterate_metadata.ts b/src/factories/internal/metadata/iterate_metadata.ts index ae79625f7fa..86a8c080e06 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/schemas/metadata/IMetadata.ts b/src/schemas/metadata/IMetadata.ts index 4eb84863046..70c5c811a05 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 4c78d8a0f6b..e05cc38f1ec 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 From 4406a07b7680a58a4be010792b00863f9a0c0d34 Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Sun, 23 Feb 2025 18:27:24 +0200 Subject: [PATCH 09/13] Migrated to Metadata and added support errors & Sets, Maps --- src/compare.ts | 4 +- .../compare/CompareEqualsProgrammer.ts | 270 +++++++++++------- .../compare/CompareEqualsTransformer.ts | 2 +- test/generate/input/generate_comare.ts | 59 ++-- test/generate/output/generate_comare.ts | 83 ++++-- 5 files changed, 265 insertions(+), 153 deletions(-) diff --git a/src/compare.ts b/src/compare.ts index 01db62c892b..987262732d9 100644 --- a/src/compare.ts +++ b/src/compare.ts @@ -1,11 +1,11 @@ /** * Comapre in deep A and B */ -export function equals(a: T, b: T): boolean; +export function equals(a: T, b: T): boolean; /** * @internal */ -export function equals(_a: T, _b: T): boolean { +export function equals(_a: T, _b: T): boolean { halt("equals"); } diff --git a/src/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts index 8c048c5f256..22e86cb961f 100644 --- a/src/programmers/compare/CompareEqualsProgrammer.ts +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -1,23 +1,59 @@ import ts from "typescript"; import { IdentifierFactory } from "../../factories/IdentifierFactory"; +import { MetadataCollection } from "../../factories/MetadataCollection"; +import { MetadataFactory } from "../../factories/MetadataFactory"; + +import { Metadata } from "../../schemas/metadata/Metadata"; 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 { - export function decompose(props: { + type Props = { context: ITypiaContext; functor: FunctionProgrammer; type: ts.Type; name: string | undefined; - }): FeatureProgrammer.IDecomposed { + }; + + export function decompose(props: Props): FeatureProgrammer.IDecomposed { + const result = MetadataFactory.analyze({ + type: props.type, + checker: props.context.checker, + transformer: props.context.transformer, + collection: new MetadataCollection(), + 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.context, props.type); + const expression = transform(a, b, props, result.data); const argType = props.context.checker.typeToTypeNode( props.type, undefined, @@ -58,21 +94,6 @@ export namespace CompareEqualsProgrammer { }); } - function isPrimitiveType(type: ts.Type): boolean { - const primitiveFlags = - ts.TypeFlags.String | - ts.TypeFlags.Number | - ts.TypeFlags.Boolean | - ts.TypeFlags.BigInt | - ts.TypeFlags.ESSymbol | - ts.TypeFlags.Null | - ts.TypeFlags.Undefined | - ts.TypeFlags.StringLiteral | - ts.TypeFlags.NumberLiteral | - ts.TypeFlags.BooleanLiteral | - ts.TypeFlags.BigIntLiteral; - return (type.flags & primitiveFlags) !== 0; - } function eqeqeq(a: ts.Expression, b: ts.Expression) { return ts.factory.createExpressionStatement( ts.factory.createBinaryExpression( @@ -98,20 +119,20 @@ export namespace CompareEqualsProgrammer { 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 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( @@ -134,9 +155,14 @@ export namespace CompareEqualsProgrammer { index: IdentifierFactory.parameter("index"), }; const ids = { + Array: ts.factory.createIdentifier("Array"), + item: ts.factory.createIdentifier("item"), + size: ts.factory.createIdentifier("size"), + from: ts.factory.createIdentifier("from"), index: ts.factory.createIdentifier("index"), every: ts.factory.createIdentifier("every"), + values: ts.factory.createIdentifier("values"), length: ts.factory.createIdentifier("length"), }; @@ -157,64 +183,91 @@ export namespace CompareEqualsProgrammer { prop: string | ts.MemberName, optinal = false, ) { - if (optinal) { - return ts.factory.createPropertyAccessChain( - target, - ts.factory.createToken(ts.SyntaxKind.QuestionDotToken), - prop, - ); - } else { - return ts.factory.createPropertyAccessExpression(target, prop); + if (typeof prop === "string") { + return IdentifierFactory.access(target, prop, optinal); } + + return IdentifierFactory.access( + target, + prop.escapedText as string, + optinal, + ); } function transform( a: ts.Expression, b: ts.Expression, - context: ITypiaContext, - type: ts.Type, + props: Props, + metadata: Metadata, ): ts.Expression { - if (type.isUnion()) { - const union = type as ts.UnionType; - let primitiveHandled = false; - const compares: ts.Expression[] = []; - for (const type of union.types) { - if (isPrimitiveType(type)) { - if (primitiveHandled) { - continue; - } - primitiveHandled = true; - } - compares.push(transform(a, b, context, type)); - } - return or(eqeqeq(a, b).expression, mergeWithBar(compares, true)); + if (metadata.atomics[0]) { + return eqeqeq(a, b).expression; } - if (isPrimitiveType(type)) { - return eqeqeq(a, b).expression; + if (metadata.objects[0]) { + const object = metadata.objects[0]; + const name = object.getName(); + + 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}.`, + }); + } + + if (name === "__type" || name.startsWith("__type.")) { + return eqeqeq(a, b).expression; + } + + 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, + ); + }); + return or(eqeqeq(a, b).expression, mergeWithAmp(statements, true)); } - if (context.checker.isTupleType(type)) { - const tuple = type as ts.TypeReference; - const types = context.checker.getTypeArguments(tuple); - const compares = types.map((type, index) => + if (metadata.tuples[0]) { + const tuple = metadata.tuples[0]; + + const compares = tuple.type.elements.map((type, index) => transform( indexAccess(a, ts.factory.createIdentifier(index.toString())), indexAccess(b, ts.factory.createIdentifier(index.toString())), - context, + props, type, ), ); return or(eqeqeq(a, b).expression, mergeWithAmp(compares, true)); } - if (context.checker.isArrayType(type)) { - const elementType = context.checker.getElementTypeOfArrayType(type); - if (!elementType) { - throw new Error(`Unknown type of ${type}`); - } - - const checkFn = ts.factory.createArrowFunction( + function compaeItem(meta: Metadata) { + return ts.factory.createArrowFunction( undefined, undefined, [params.item, params.index], @@ -232,59 +285,60 @@ export namespace CompareEqualsProgrammer { ids.index, true, ), - context, - elementType, + props, + meta, ), ), ]), ); + } + function compareIterable(meta: 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, [ - checkFn, - ]), + eqeqeq(access(a, ids.size), access(b, ids.size)).expression, + + ts.factory.createCallExpression( + access( + ts.factory.createCallExpression( + access(ids.Array, ids.from), + undefined, + [ + ts.factory.createCallExpression( + access(a, ids.values), + undefined, + undefined, + ), + ], + ), + ids.every, + ), + undefined, + [compaeItem(meta)], + ), ), ), ); } - if ((type.flags & ts.TypeFlags.Object) !== 0) { - const properties = type.getProperties(); - const statements = properties.flatMap((prop) => { - const optional = - prop.declarations?.some((decl) => { - if ( - ts.isPropertySignature(decl) || - ts.isPropertyDeclaration(decl) - ) { - return Boolean(decl.questionToken); - } - return false; - }) ?? false; - - return transform( - access( - a, - ts.factory.createIdentifier(prop.escapedName.toString()), - optional, - ), - access( - b, - ts.factory.createIdentifier(prop.escapedName.toString()), - optional, - ), - context, - context.checker.getTypeOfSymbolAtLocation( - prop, - prop.declarations![0]!, + if (metadata.arrays[0]) { + 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, [ + compaeItem(metadata.arrays[0].type.value), + ]), ), - ); - }); - return or(eqeqeq(a, b).expression, mergeWithAmp(statements, true)); + ), + ); + } else if (metadata.sets[0]) { + return compareIterable(metadata.sets[0].value); + } else if (metadata.maps[0]) { + return compareIterable(metadata.maps[0].value); } return eqeqeq(a, b).expression; diff --git a/src/transformers/features/compare/CompareEqualsTransformer.ts b/src/transformers/features/compare/CompareEqualsTransformer.ts index 995cf1275de..1115d54b6eb 100644 --- a/src/transformers/features/compare/CompareEqualsTransformer.ts +++ b/src/transformers/features/compare/CompareEqualsTransformer.ts @@ -7,7 +7,7 @@ export namespace CompareEqualsTransformer { export const transform = (props: ITransformProps) => GenericTransformer.scalar({ ...props, - method: "json.isStringify", + method: "compare.equals", write: CompareEqualsProgrammer.write, }); } diff --git a/test/generate/input/generate_comare.ts b/test/generate/input/generate_comare.ts index c3e91fb58f3..92eb75d9eec 100644 --- a/test/generate/input/generate_comare.ts +++ b/test/generate/input/generate_comare.ts @@ -1,30 +1,30 @@ import typia from "typia"; -// interface ISomething { -// id: string; -// age: number; -// } -// -// export const objects = typia.compare.equals( -// { id: "1", age: 2 }, -// { id: "1", age: 2 }, -// ); +interface ISomething { + id: string; + age: number; +} + +export const objects = typia.compare.equals( + { id: "1", age: 2 }, + { id: "1", age: 2 }, +); // // 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); +// 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 }] // >( @@ -41,3 +41,28 @@ export const recurcive = typia.compare.equals(1 as any, 1 as any); // export const unionNested = typia.compare.equals< // Array<{ foo: string } | { bar: number }> // >([{ foo: "1" }], [{ foo: "1" }]); + +// 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 }]), +); diff --git a/test/generate/output/generate_comare.ts b/test/generate/output/generate_comare.ts index afbf509bfb3..77e37257f33 100644 --- a/test/generate/output/generate_comare.ts +++ b/test/generate/output/generate_comare.ts @@ -1,38 +1,71 @@ import typia from "typia"; -// interface ISomething { -// id: string; -// age: number; +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 }); +// +// 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 objects = typia.compare.equals( -// { id: "1", age: 2 }, -// { id: "1", age: 2 }, +// 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" }]); +// 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 matrix = (() => { - return (a: number[][][], b: number[][][]): boolean => { +// 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 = (() => { + return (a: Set<{ foo: number }>, b: Set<{ foo: number }>): boolean => { return ( a === b || - (a.length === b.length && - a.every((item: any, index: any) => { + (a.size === b.size && + Array.from(a.values()).every((item: any, index: any) => { return ( - item === (b as any)[index]! || - (item.length === (b as any)[index]!.length && - item.every((item: any, index: any) => { - return ( - item === ((b as any)[index]! as any)[index]! || - (item.length === ((b as any)[index]! as any)[index]!.length && - item.every((item: any, index: any) => { - return ( - item === - (((b as any)[index]! as any)[index]! as any)[index]! - ); - })) - ); - })) + item === (b as any)[index]! || item.foo === (b as any)[index]!.foo ); })) ); }; -})()([[[1, 2, 3]]], [[[1, 2, 3]]]); +})()(new Set([{ foo: 1 }]), new Set([{ foo: 1 }])); From e9ec8503cc5794a432a4242d55d66dcb2a33e518 Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Sun, 23 Feb 2025 22:32:27 +0200 Subject: [PATCH 10/13] Added support unions --- .../compare/CompareEqualsProgrammer.ts | 379 ++++++++++++------ test/generate/input/generate_comare.ts | 77 +++- test/generate/output/generate_comare.ts | 101 +++-- test/src/internal/_test_compare_equals.ts | 14 +- 4 files changed, 412 insertions(+), 159 deletions(-) diff --git a/src/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts index 22e86cb961f..b296f52cb09 100644 --- a/src/programmers/compare/CompareEqualsProgrammer.ts +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -5,6 +5,9 @@ import { MetadataCollection } from "../../factories/MetadataCollection"; import { MetadataFactory } from "../../factories/MetadataFactory"; import { Metadata } from "../../schemas/metadata/Metadata"; +import { MetadataArray } from "../../schemas/metadata/MetadataArray"; +import { MetadataObject } from "../../schemas/metadata/MetadataObject"; +import { MetadataTuple } from "../../schemas/metadata/MetadataTuple"; import { IProgrammerProps } from "../../transformers/IProgrammerProps"; import { ITypiaContext } from "../../transformers/ITypiaContext"; @@ -119,20 +122,20 @@ export namespace CompareEqualsProgrammer { 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 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( @@ -152,18 +155,23 @@ export namespace CompareEqualsProgrammer { const params = { item: IdentifierFactory.parameter("item"), - index: IdentifierFactory.parameter("index"), + index: IdentifierFactory.parameter, }; const ids = { + Map: ts.factory.createIdentifier("Map"), + Set: ts.factory.createIdentifier("Set"), Array: ts.factory.createIdentifier("Array"), item: ts.factory.createIdentifier("item"), size: ts.factory.createIdentifier("size"), from: ts.factory.createIdentifier("from"), - index: ts.factory.createIdentifier("index"), every: ts.factory.createIdentifier("every"), + object: ts.factory.createIdentifier("object"), values: ts.factory.createIdentifier("values"), length: ts.factory.createIdentifier("length"), + isArray: ts.factory.createIdentifier("isArray"), + + index: () => ts.factory.createUniqueName("index"), }; function indexAccess( @@ -194,151 +202,262 @@ export namespace CompareEqualsProgrammer { ); } - function transform( + function transformObject( a: ts.Expression, b: ts.Expression, props: Props, metadata: Metadata, - ): ts.Expression { - if (metadata.atomics[0]) { - return eqeqeq(a, b).expression; + 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.objects[0]) { - const object = metadata.objects[0]; - const name = object.getName(); - - 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}.`, + }); + } - if (metadata.class) { + const statements = object.type.properties.map((prop) => { + if (!prop.key.getSoleLiteral()) { throw new TransformerError({ code: `typia.compare.equals()`, - message: `Can't compare classes as static ${props.type.getSymbol()?.getName()} -> ${object.type.name}.`, + message: `Detected unknown property name ${props.type.getSymbol()?.getName()} -> ${object.type.name}. If it's dynamic it's doesn't support.`, }); } - if (name === "__type" || name.startsWith("__type.")) { - return eqeqeq(a, b).expression; - } + 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, + ); + }); + return or(eqeqeq(a, b).expression, mergeWithAmp(statements, true)); + } - 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, + function compareItem(b: ts.Expression, props: Props, metadata: Metadata) { + const index = ids.index(); + return ts.factory.createArrowFunction( + undefined, + undefined, + [params.item, params.index(index)], + undefined, + undefined, + ts.factory.createBlock([ + ts.factory.createReturnStatement( + transform( + ids.item, + indexAccess( + ts.factory.createAsExpression( + b, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword), + ), + index, + true, + ), + props, + metadata, ), - access( - b, - ts.factory.createIdentifier(prop.key.getSoleLiteral()!), - prop.value.optional, + ), + ]), + ); + } + + function transformIterable( + a: ts.Expression, + b: ts.Expression, + props: Props, + metadata: Metadata, + ) { + return or( + eqeqeq(a, b).expression, + ts.factory.createParenthesizedExpression( + and( + eqeqeq(access(a, ids.size), access(b, ids.size)).expression, + + ts.factory.createCallExpression( + access( + ts.factory.createCallExpression( + access(ids.Array, ids.from), + undefined, + [ + ts.factory.createCallExpression( + access(a, ids.values), + undefined, + undefined, + ), + ], + ), + ids.every, + ), + undefined, + [compareItem(b, props, metadata)], ), - props, - prop.value, - ); + ), + ), + ); + } + + 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 transformArray( + a: ts.Expression, + b: ts.Expression, + props: Props, + _metadata: Metadata, + 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 or(eqeqeq(a, b).expression, mergeWithAmp(statements, true)); } - - if (metadata.tuples[0]) { - const tuple = metadata.tuples[0]; - - 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, + 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, array.type.value), + ]), ), - ); - return or(eqeqeq(a, b).expression, mergeWithAmp(compares, true)); - } + ), + ); + } - function compaeItem(meta: Metadata) { - return ts.factory.createArrowFunction( - undefined, - undefined, - [params.item, params.index], - undefined, - undefined, - ts.factory.createBlock([ - ts.factory.createReturnStatement( - transform( - ids.item, - indexAccess( - ts.factory.createAsExpression( - b, - ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword), - ), - ids.index, - true, + 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 transform( + a: ts.Expression, + b: ts.Expression, + props: Props, + metadata: Metadata, + ): ts.Expression { + if (metadata.isUnionBucket()) { + const compares: ts.Expression[] = []; + + if (metadata.constants.length > 0 || metadata.atomics.length > 0) { + compares.push(eqeqeq(a, b).expression); + } + if (metadata.maps.length > 0) { + compares.push( + and( + instaceof(a, ids.Map), + mergeWithBar( + metadata.maps.map((element) => + transformIterable(a, b, props, element.value), ), - props, - meta, ), ), - ]), - ); - } - - function compareIterable(meta: Metadata) { - return or( - eqeqeq(a, b).expression, - ts.factory.createParenthesizedExpression( + ); + } + if (metadata.sets.length > 0) { + compares.push( and( - eqeqeq(access(a, ids.size), access(b, ids.size)).expression, - - ts.factory.createCallExpression( - access( - ts.factory.createCallExpression( - access(ids.Array, ids.from), - undefined, - [ - ts.factory.createCallExpression( - access(a, ids.values), - undefined, - undefined, - ), - ], - ), - ids.every, + instaceof(a, ids.Map), + mergeWithBar( + metadata.sets.map((element) => + transformIterable(a, b, props, element.value), ), - undefined, - [compaeItem(meta)], ), ), - ), - ); + ); + } + if (metadata.objects.length > 0) { + 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, metadata, element), + ), + ), + ), + ); + } + + return mergeWithBar(compares); + } + + if (metadata.atomics[0] || metadata.constants[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 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, [ - compaeItem(metadata.arrays[0].type.value), - ]), - ), - ), - ); + return transformArray(a, b, props, metadata, metadata.arrays[0]); } else if (metadata.sets[0]) { - return compareIterable(metadata.sets[0].value); + return transformIterable(a, b, props, metadata.sets[0].value); } else if (metadata.maps[0]) { - return compareIterable(metadata.maps[0].value); + return transformIterable(a, b, props, metadata.maps[0].value); } return eqeqeq(a, b).expression; diff --git a/test/generate/input/generate_comare.ts b/test/generate/input/generate_comare.ts index 92eb75d9eec..fe27daa0136 100644 --- a/test/generate/input/generate_comare.ts +++ b/test/generate/input/generate_comare.ts @@ -1,3 +1,4 @@ +import { assert } from "console"; import typia from "typia"; interface ISomething { @@ -9,12 +10,17 @@ export const objects = typia.compare.equals( { id: "1", age: 2 }, { id: "1", age: 2 }, ); -// + // 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; @@ -42,6 +48,48 @@ export const objects = 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 }]); + +console.assert( + typia.compare.equals(new Set([1]), new Set([1])), + "Set compares should be equal", +); + +export type MegaUnion = + | number + | Uint8Array + | Set + | Map + | [string, string] + | [boolean, number, number] + | number[] + | boolean[] + | []; + +export function megaUnion(): MegaUnion[] { + return [ + 3, + // new Uint8Array(), + new Set([false, true]), + // new Map(), + // ["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; // }; @@ -62,7 +110,26 @@ export const objects = typia.compare.equals( // { foo: new FooClass() }, // ); -export const sets = typia.compare.equals( - new Set([{ foo: 1 }]), - new Set([{ foo: 1 }]), -); +// 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 index 77e37257f33..58c55d64b3c 100644 --- a/test/generate/output/generate_comare.ts +++ b/test/generate/output/generate_comare.ts @@ -1,3 +1,4 @@ +import { assert } from "console"; import typia from "typia"; interface ISomething { @@ -9,11 +10,14 @@ export const objects = (() => { return a === b || (a.id === b.id && a.age === b.age); }; })()({ id: "1", age: 2 }, { id: "1", age: 2 }); -// // 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; @@ -38,34 +42,85 @@ export const objects = (() => { // export const unionNested = typia.compare.equals< // Array<{ foo: string } | { bar: number }> // >([{ foo: "1" }], [{ foo: "1" }]); -// 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 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); // -// 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 = (() => { - return (a: Set<{ foo: number }>, b: Set<{ foo: number }>): boolean => { +// typia.compare.equals([{ a: 1 }], [{ a: 1 }]); +console.assert( + (() => { + return (a: Set, b: Set): boolean => { + return ( + a === b || + (a.size === b.size && + Array.from(a.values()).every((item: any, index_1: any) => { + return item === (b as any)[index_1]!; + })) + ); + }; + })()(new Set([1]), new Set([1])), + "Set compares should be equal", +); +export type MegaUnion = + | number + | Uint8Array + | Set + | Map + | [string, string] + | [boolean, number, number] + | number[] + | boolean[] + | []; +export function megaUnion(): MegaUnion[] { + return [ + 3, + // new Uint8Array(), + new Set([false, true]), + // new Map(), + // ["one", "two"], + // [false, 1, 2], + // [1, 2, 3], + // [true, false], + // [], + ]; +} +export const arrayMegaUnioun = (() => { + return (a: MegaUnion[], b: MegaUnion[]): boolean => { return ( a === b || - (a.size === b.size && - Array.from(a.values()).every((item: any, index: any) => { + (a.length === b.length && + a.every((item: any, index_2: any) => { return ( - item === (b as any)[index]! || item.foo === (b as any)[index]!.foo + item === (b as any)[index_2]! || + (item instanceof Map && + (item === (b as any)[index_2]! || + (item.size === (b as any)[index_2]!.size && + Array.from(item.values()).every((item: any, index_3: any) => { + return item === ((b as any)[index_2]! as any)[index_3]!; + })))) || + (item instanceof Map && + (item === (b as any)[index_2]! || + (item.size === (b as any)[index_2]!.size && + Array.from(item.values()).every((item: any, index_4: any) => { + return item === ((b as any)[index_2]! as any)[index_4]!; + })))) || + (Array.isArray(item) && + (item === (b as any)[index_2]! || + (item.length === (b as any)[index_2]!.length && + item.every((item: any, index_5: any) => { + return item === ((b as any)[index_2]! as any)[index_5]!; + })) || + item === (b as any)[index_2]! || + (item.length === (b as any)[index_2]!.length && + item.every((item: any, index_6: any) => { + return item === ((b as any)[index_2]! as any)[index_6]!; + })))) ); })) ); }; -})()(new Set([{ foo: 1 }]), new Set([{ foo: 1 }])); +})()(megaUnion(), megaUnion()); +console.assert(arrayMegaUnioun, megaUnion.name); diff --git a/test/src/internal/_test_compare_equals.ts b/test/src/internal/_test_compare_equals.ts index 841f3ce1710..98447edfeda 100644 --- a/test/src/internal/_test_compare_equals.ts +++ b/test/src/internal/_test_compare_equals.ts @@ -8,7 +8,19 @@ export const _test_compare_equals = () => { const dataA: T = factory.generate(); const dataB: T = factory.generate(); - const equaled = equals(dataA, dataB); + 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) { From beb3969ab5fcb637174bea306f2a440f329f27c7 Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Sun, 23 Feb 2025 23:44:35 +0200 Subject: [PATCH 11/13] Added iterable comparing with IIFE --- .../compare/CompareEqualsProgrammer.ts | 146 +++++++++++++---- test/generate/input/generate_comare.ts | 67 ++++---- test/generate/output/generate_comare.ts | 152 ++++++------------ 3 files changed, 191 insertions(+), 174 deletions(-) diff --git a/src/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts index b296f52cb09..feb5b4180e6 100644 --- a/src/programmers/compare/CompareEqualsProgrammer.ts +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -3,6 +3,7 @@ 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"; @@ -70,8 +71,8 @@ export namespace CompareEqualsProgrammer { undefined, undefined, [ - IdentifierFactory.parameter("a", argType), - IdentifierFactory.parameter("b", argType), + IdentifierFactory.parameter(a.text, argType), + IdentifierFactory.parameter(b.text, argType), ], ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword), undefined, @@ -162,6 +163,7 @@ export namespace CompareEqualsProgrammer { Set: ts.factory.createIdentifier("Set"), Array: ts.factory.createIdentifier("Array"), + zero: ts.factory.createIdentifier("0"), item: ts.factory.createIdentifier("item"), size: ts.factory.createIdentifier("size"), from: ts.factory.createIdentifier("from"), @@ -170,6 +172,7 @@ export namespace CompareEqualsProgrammer { values: ts.factory.createIdentifier("values"), length: ts.factory.createIdentifier("length"), isArray: ts.factory.createIdentifier("isArray"), + difference: ts.factory.createIdentifier("difference"), index: () => ts.factory.createUniqueName("index"), }; @@ -277,36 +280,95 @@ export namespace CompareEqualsProgrammer { ); } + 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 transformIterable( a: ts.Expression, b: ts.Expression, - props: Props, - metadata: Metadata, + _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: ts.factory.createCallExpression( + access(ids.Array, ids.from), + undefined, + [ + ts.factory.createCallExpression( + access(a, ids.values), + undefined, + undefined, + ), + ], + ), + }), + StatementFactory.constant({ + name: b1.text, + value: ts.factory.createCallExpression( + access(ids.Array, ids.from), + undefined, + [ + 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, - ts.factory.createCallExpression( - access( - ts.factory.createCallExpression( - access(ids.Array, ids.from), - undefined, - [ - ts.factory.createCallExpression( - access(a, ids.values), - undefined, - undefined, - ), - ], - ), - ids.every, - ), - undefined, - [compareItem(b, props, metadata)], - ), + iffeCompare, + // ts.factory.createCallExpression( + // access( + // ts.factory.createCallExpression( + // access(ids.Array, ids.from), + // undefined, + // [ + // ts.factory.createCallExpression( + // access(a, ids.values), + // undefined, + // undefined, + // ), + // ], + // ), + // ids.every, + // ), + // undefined, + // [compareItem(b, props, metadata)], + // ), ), ), ); @@ -330,32 +392,40 @@ export namespace CompareEqualsProgrammer { return or(eqeqeq(a, b).expression, mergeWithAmp(compares, true)); } - function transformArray( + function compareEvery( a: ts.Expression, b: ts.Expression, props: Props, - _metadata: Metadata, - array: MetadataArray, + metadata: Metadata, ) { - if (array.type.recursive) { - throw new TransformerError({ - code: `typia.compare.equals()`, - message: `Detected recusion type ${props.type.getSymbol()?.getName()} -> ${array.type.name}.`, - }); - } 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, array.type.value), + compareItem(b, props, metadata), ]), ), ), ); } + 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, @@ -382,6 +452,12 @@ export namespace CompareEqualsProgrammer { 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.isUnionBucket()) { const compares: ts.Expression[] = []; @@ -403,7 +479,7 @@ export namespace CompareEqualsProgrammer { if (metadata.sets.length > 0) { compares.push( and( - instaceof(a, ids.Map), + instaceof(a, ids.Set), mergeWithBar( metadata.sets.map((element) => transformIterable(a, b, props, element.value), @@ -430,7 +506,7 @@ export namespace CompareEqualsProgrammer { isArray(a), mergeWithBar( metadata.arrays.map((element) => - transformArray(a, b, props, metadata, element), + transformArray(a, b, props, element), ), ), ), @@ -453,7 +529,7 @@ export namespace CompareEqualsProgrammer { } if (metadata.arrays[0]) { - return transformArray(a, b, props, metadata, 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]) { diff --git a/test/generate/input/generate_comare.ts b/test/generate/input/generate_comare.ts index fe27daa0136..e3dd174cab0 100644 --- a/test/generate/input/generate_comare.ts +++ b/test/generate/input/generate_comare.ts @@ -1,4 +1,3 @@ -import { assert } from "console"; import typia from "typia"; interface ISomething { @@ -11,6 +10,15 @@ export const objects = typia.compare.equals( { 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]]], @@ -57,38 +65,31 @@ export const objects = typia.compare.equals( // // typia.compare.equals([{ a: 1 }], [{ a: 1 }]); -console.assert( - typia.compare.equals(new Set([1]), new Set([1])), - "Set compares should be equal", -); - -export type MegaUnion = - | number - | Uint8Array - | Set - | Map - | [string, string] - | [boolean, number, number] - | number[] - | boolean[] - | []; - -export function megaUnion(): MegaUnion[] { - return [ - 3, - // new Uint8Array(), - new Set([false, true]), - // new Map(), - // ["one", "two"], - // [false, 1, 2], - // [1, 2, 3], - // [true, false], - // [], - ]; -} - -export const arrayMegaUnioun = typia.compare.equals(megaUnion(), megaUnion()); -console.assert(arrayMegaUnioun, megaUnion.name); +// 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; diff --git a/test/generate/output/generate_comare.ts b/test/generate/output/generate_comare.ts index 58c55d64b3c..9d5501098db 100644 --- a/test/generate/output/generate_comare.ts +++ b/test/generate/output/generate_comare.ts @@ -1,4 +1,3 @@ -import { assert } from "console"; import typia from "typia"; interface ISomething { @@ -10,117 +9,58 @@ export const objects = (() => { return a === b || (a.id === b.id && a.age === b.age); }; })()({ id: "1", age: 2 }, { id: "1", age: 2 }); -// 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 }]); console.assert( (() => { - return (a: Set, b: Set): boolean => { + return (a: Map, b: Map): boolean => { return ( a === b || (a.size === b.size && - Array.from(a.values()).every((item: any, index_1: any) => { - return item === (b as any)[index_1]!; - })) + (() => { + 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 Set([1]), new Set([1])), - "Set compares should be equal", + })()(new Map([["foo", 1]]), new Map([["foo", 1]])), + "Map compares should be equal", ); -export type MegaUnion = - | number - | Uint8Array - | Set - | Map - | [string, string] - | [boolean, number, number] - | number[] - | boolean[] - | []; -export function megaUnion(): MegaUnion[] { - return [ - 3, - // new Uint8Array(), - new Set([false, true]), - // new Map(), - // ["one", "two"], - // [false, 1, 2], - // [1, 2, 3], - // [true, false], - // [], - ]; -} -export const arrayMegaUnioun = (() => { - return (a: MegaUnion[], b: MegaUnion[]): boolean => { +console.assert( + (() => { return ( - a === b || - (a.length === b.length && - a.every((item: any, index_2: any) => { - return ( - item === (b as any)[index_2]! || - (item instanceof Map && - (item === (b as any)[index_2]! || - (item.size === (b as any)[index_2]!.size && - Array.from(item.values()).every((item: any, index_3: any) => { - return item === ((b as any)[index_2]! as any)[index_3]!; - })))) || - (item instanceof Map && - (item === (b as any)[index_2]! || - (item.size === (b as any)[index_2]!.size && - Array.from(item.values()).every((item: any, index_4: any) => { - return item === ((b as any)[index_2]! as any)[index_4]!; - })))) || - (Array.isArray(item) && - (item === (b as any)[index_2]! || - (item.length === (b as any)[index_2]!.length && - item.every((item: any, index_5: any) => { - return item === ((b as any)[index_2]! as any)[index_5]!; - })) || - item === (b as any)[index_2]! || - (item.length === (b as any)[index_2]!.length && - item.every((item: any, index_6: any) => { - return item === ((b as any)[index_2]! as any)[index_6]!; - })))) - ); - })) - ); - }; -})()(megaUnion(), megaUnion()); -console.assert(arrayMegaUnioun, megaUnion.name); + 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", +); From 1da0dcefa1f7cdbae5ca628c7760f4c8770c4db8 Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Mon, 24 Feb 2025 01:46:56 +0200 Subject: [PATCH 12/13] Added methods resolve for objects --- src/factories/MetadataCollection.ts | 10 + .../compare/CompareEqualsProgrammer.ts | 243 +++++++++++------- 2 files changed, 167 insertions(+), 86 deletions(-) diff --git a/src/factories/MetadataCollection.ts b/src/factories/MetadataCollection.ts index 6feeb4b7d8c..efc20807f60 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/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts index feb5b4180e6..654716db9b9 100644 --- a/src/programmers/compare/CompareEqualsProgrammer.ts +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -7,6 +7,7 @@ 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"; @@ -21,6 +22,7 @@ export namespace CompareEqualsProgrammer { type Props = { context: ITypiaContext; functor: FunctionProgrammer; + metaCollection: MetadataCollection; type: ts.Type; name: string | undefined; }; @@ -30,7 +32,7 @@ export namespace CompareEqualsProgrammer { type: props.type, checker: props.context.checker, transformer: props.context.transformer, - collection: new MetadataCollection(), + collection: props.metaCollection, options: { escape: false, constant: true, @@ -88,6 +90,7 @@ export namespace CompareEqualsProgrammer { const functor = new FunctionProgrammer(props.modulo.getText()); const result: FeatureProgrammer.IDecomposed = decompose({ ...props, + metaCollection: new MetadataCollection(), functor, }); @@ -168,10 +171,11 @@ export namespace CompareEqualsProgrammer { size: ts.factory.createIdentifier("size"), from: ts.factory.createIdentifier("from"), every: ts.factory.createIdentifier("every"), - object: ts.factory.createIdentifier("object"), + object: ts.factory.createIdentifier('"object"'), values: ts.factory.createIdentifier("values"), length: ts.factory.createIdentifier("length"), isArray: ts.factory.createIdentifier("isArray"), + toString: ts.factory.createIdentifier("toString"), difference: ts.factory.createIdentifier("difference"), index: () => ts.factory.createUniqueName("index"), @@ -249,11 +253,45 @@ export namespace CompareEqualsProgrammer { 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 (isFunctionProperty(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) { + 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, @@ -261,21 +299,7 @@ export namespace CompareEqualsProgrammer { undefined, undefined, ts.factory.createBlock([ - ts.factory.createReturnStatement( - transform( - ids.item, - indexAccess( - ts.factory.createAsExpression( - b, - ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword), - ), - index, - true, - ), - props, - metadata, - ), - ), + ts.factory.createReturnStatement(compareExpression), ]), ); } @@ -296,6 +320,14 @@ export namespace CompareEqualsProgrammer { ); } + 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, @@ -307,30 +339,22 @@ export namespace CompareEqualsProgrammer { const iffeCompare = iife([ StatementFactory.constant({ name: a1.text, - value: ts.factory.createCallExpression( - access(ids.Array, ids.from), - undefined, - [ - ts.factory.createCallExpression( - access(a, ids.values), - undefined, - undefined, - ), - ], + value: spreadClone( + ts.factory.createCallExpression( + access(a, ids.values), + undefined, + undefined, + ), ), }), StatementFactory.constant({ name: b1.text, - value: ts.factory.createCallExpression( - access(ids.Array, ids.from), - undefined, - [ - ts.factory.createCallExpression( - access(b, ids.values), - undefined, - undefined, - ), - ], + value: spreadClone( + ts.factory.createCallExpression( + access(b, ids.values), + undefined, + undefined, + ), ), }), @@ -349,26 +373,7 @@ export namespace CompareEqualsProgrammer { ts.factory.createParenthesizedExpression( and( eqeqeq(access(a, ids.size), access(b, ids.size)).expression, - iffeCompare, - // ts.factory.createCallExpression( - // access( - // ts.factory.createCallExpression( - // access(ids.Array, ids.from), - // undefined, - // [ - // ts.factory.createCallExpression( - // access(a, ids.values), - // undefined, - // undefined, - // ), - // ], - // ), - // ids.every, - // ), - // undefined, - // [compareItem(b, props, metadata)], - // ), ), ), ); @@ -396,7 +401,7 @@ export namespace CompareEqualsProgrammer { a: ts.Expression, b: ts.Expression, props: Props, - metadata: Metadata, + metadata?: Metadata, ) { return or( eqeqeq(a, b).expression, @@ -411,6 +416,38 @@ export namespace CompareEqualsProgrammer { ); } + 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(access(a, ids.toString), undefined, []), + ts.factory.createCallExpression(access(b, ids.toString), undefined, []), + ).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, @@ -426,13 +463,13 @@ export namespace CompareEqualsProgrammer { 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 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; @@ -446,6 +483,27 @@ export namespace CompareEqualsProgrammer { ); } + 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, @@ -458,35 +516,44 @@ export namespace CompareEqualsProgrammer { message: `Detected any type ${props.type.getSymbol()?.getName()}. It can't be supported for static equals.`, }); } - if (metadata.isUnionBucket()) { + if (metadata.size() > 1) { const compares: ts.Expression[] = []; if (metadata.constants.length > 0 || metadata.atomics.length > 0) { compares.push(eqeqeq(a, b).expression); } if (metadata.maps.length > 0) { - compares.push( - and( - instaceof(a, ids.Map), - mergeWithBar( - metadata.maps.map((element) => - transformIterable(a, b, props, element.value), - ), - ), - ), - ); + 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) { - compares.push( - and( - instaceof(a, ids.Set), - mergeWithBar( - metadata.sets.map((element) => - transformIterable(a, b, props, element.value), - ), - ), - ), - ); + 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) { compares.push( @@ -536,6 +603,10 @@ export namespace CompareEqualsProgrammer { 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; } } From 969f1ed9ed8bce5eefd1036de1940be0a2e093bb Mon Sep 17 00:00:00 2001 From: Andrew Brighton Date: Mon, 24 Feb 2025 02:26:39 +0200 Subject: [PATCH 13/13] Fixes for comparing natives and methods --- .../compare/CompareEqualsProgrammer.ts | 107 +++++++++++------- 1 file changed, 63 insertions(+), 44 deletions(-) diff --git a/src/programmers/compare/CompareEqualsProgrammer.ts b/src/programmers/compare/CompareEqualsProgrammer.ts index 654716db9b9..0e23b815d40 100644 --- a/src/programmers/compare/CompareEqualsProgrammer.ts +++ b/src/programmers/compare/CompareEqualsProgrammer.ts @@ -60,11 +60,7 @@ export namespace CompareEqualsProgrammer { const a = ts.factory.createIdentifier("a"); const b = ts.factory.createIdentifier("b"); const expression = transform(a, b, props, result.data); - const argType = props.context.checker.typeToTypeNode( - props.type, - undefined, - ts.NodeBuilderFlags.NoTruncation, - ); + const argType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword); return { functions: {}, @@ -165,16 +161,18 @@ export namespace CompareEqualsProgrammer { 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"), - object: ts.factory.createIdentifier('"object"'), 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"), @@ -263,7 +261,7 @@ export namespace CompareEqualsProgrammer { if (!node) { continue; } - if (isFunctionProperty(node)) { + if (ts.isMethodSignature(node)) { statements.push( eqeqeq(access(a, symbol.getName()), access(b, symbol.getName())) .expression, @@ -428,8 +426,8 @@ export namespace CompareEqualsProgrammer { } if (native.name === "Date") { return eqeqeq( - ts.factory.createCallExpression(access(a, ids.toString), undefined, []), - ts.factory.createCallExpression(access(b, ids.toString), undefined, []), + ts.factory.createCallExpression(ids.String, undefined, [a]), + ts.factory.createCallExpression(ids.String, undefined, [b]), ).expression; } @@ -471,9 +469,9 @@ export namespace CompareEqualsProgrammer { // ); // } - function typeOf(a: ts.Expression, b: ts.Expression) { - return eqeqeq(ts.factory.createTypeOfExpression(a), b).expression; - } + // 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( @@ -483,26 +481,26 @@ export namespace CompareEqualsProgrammer { ); } - 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 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, @@ -519,7 +517,11 @@ export namespace CompareEqualsProgrammer { if (metadata.size() > 1) { const compares: ts.Expression[] = []; - if (metadata.constants.length > 0 || metadata.atomics.length > 0) { + if ( + metadata.constants.length > 0 || + metadata.atomics.length > 0 || + metadata.functions.length > 0 + ) { compares.push(eqeqeq(a, b).expression); } if (metadata.maps.length > 0) { @@ -556,16 +558,20 @@ export namespace CompareEqualsProgrammer { // ); } if (metadata.objects.length > 0) { - compares.push( - and( - typeOf(a, ids.object), - mergeWithBar( - metadata.objects.map((element) => - transformObject(a, b, props, metadata, element), - ), - ), - ), - ); + 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( @@ -580,10 +586,23 @@ export namespace CompareEqualsProgrammer { ); } + // 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]) { + if (metadata.atomics[0] || metadata.constants[0] || metadata.functions[0]) { return eqeqeq(a, b).expression; }