typia 15.2.0 → 15.2.2

package/native/core/programmers/random_programmer_array_schema_reference_test.go

@@ -0,0 +1,53 @@
+package programmers
+
+import (
+  "reflect"
+  "testing"
+
+  iterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+)
+
+// TestRandomProgrammerArraySchemaReference verifies random generation consumes
+// the schema writer's selected recursive variant rather than the bare type name.
+//
+// A recursive array can have several constrained schema components; only the
+// returned reference identifies the constraints of the current use.
+//
+// 1. Supply a decoy plain component and a referenced maximum-zero variant.
+// 2. Resolve a variant with multiple alternative tag rows.
+// 3. Preserve inline, external and unresolved schemas without inventing a target.
+//
+// @evidence contracts/testing.md#behavioral-verification Resolves authored component references and compares complete schema lists, including explicit zero bounds and alternatives, as consumed by the random generator.
+// @evidence contracts/testing.md#independent-expectations A local reference selects its named component, not a similarly named unconstrained component; literal array schema maps establish the expected constraints.
+// @evidence contracts/testing.md#distinguishing-cases Distinguishes plain versus constrained targets, zero bounds, one versus multiple rows, inline schemas, nil components, absent targets and external references.
+// @evidence contracts/testing.md#execution-ownership pnpm test:go:native discovers this same-package unit test; it executes the schema consumer in memory with no compiler or product process.
+func TestRandomProgrammerArraySchemaReference(t *testing.T) {
+  empty := iterate.JsonSchema{"type": "array", "maxItems": 0}
+  multiple := []iterate.JsonSchema{empty, {"type": "array", "minItems": 2}}
+  components := &iterate.OpenApi_IComponents{Schemas: map[string]iterate.JsonSchema{
+    "Tree": {"type": "array"}, "Tree-array": empty,
+    "Tree-array-1": {"oneOf": multiple},
+  }}
+  for _, sample := range []struct {
+    name     string
+    schema   iterate.JsonSchema
+    expected []iterate.JsonSchema
+  }{
+    {"selected tagged target", iterate.JsonSchema{"$ref": "#/components/schemas/Tree-array"}, []iterate.JsonSchema{empty}},
+    {"alternative rows", iterate.JsonSchema{"$ref": "#/components/schemas/Tree-array-1"}, multiple},
+    {"inline", empty, []iterate.JsonSchema{empty}},
+    {"missing", iterate.JsonSchema{"$ref": "#/components/schemas/Missing"}, []iterate.JsonSchema{{"$ref": "#/components/schemas/Missing"}}},
+    {"external", iterate.JsonSchema{"$ref": "other.json#/Tree-array"}, []iterate.JsonSchema{{"$ref": "other.json#/Tree-array"}}},
+  } {
+    t.Run(sample.name, func(t *testing.T) {
+      actual := randomProgrammer_array_schema_list(components, []iterate.JsonSchema{sample.schema})
+      if !reflect.DeepEqual(actual, sample.expected) {
+        t.Errorf("got %#v, want %#v", actual, sample.expected)
+      }
+    })
+  }
+  original := []iterate.JsonSchema{empty}
+  if !reflect.DeepEqual(randomProgrammer_array_schema_list(nil, original), original) {
+    t.Error("nil components changed inline schema")
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "15.2.0",
+  "version": "15.2.2",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -43,8 +43,8 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "randexp": "^0.5.3",
-    "@typia/interface": "^15.2.0",
-    "@typia/utils": "^15.2.0"
+    "@typia/interface": "^15.2.2",
+    "@typia/utils": "^15.2.2"
   },
   "peerDependencies": {
     "ttsc": ">=0.34.1"

package/src/internal/_stringLengthGte.ts

@@ -1,15 +1,20 @@
 /**
  * Test whether a string has at least the given number of code points.
  *
- * Iteration stops as soon as the count is reached, so a long string is not
- * scanned to its end.
+ * Twice the requested minimum in UTF-16 units guarantees enough code points.
+ * Other inputs are counted only until the minimum is reached.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 export const _stringLengthGte = (value: string, length: number): boolean => {
+  if (value.length >= length * 2) return true;
   let count: number = 0;
   if (length <= count) return true;
   for (const _ch of value) if (length <= ++count) return true;

package/src/internal/_stringLengthLte.ts

@@ -1,15 +1,20 @@
 /**
  * Test whether a string has at most the given number of code points.
  *
- * Iteration stops as soon as the count is exceeded, so a long string is not
- * scanned to its end.
+ * UTF-16 length decides inputs whose code units already fit the bound. Other
+ * inputs are counted only until the maximum is exceeded.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 export const _stringLengthLte = (value: string, length: number): boolean => {
+  if (value.length <= length) return true;
   let count: number = 0;
   if (!(count <= length)) return false;
   for (const _ch of value) if (!(++count <= length)) return false;