typia 14.0.6 → 15.0.1

package/native/core/programmers/llm/LlmReferenceDescription.go

@@ -0,0 +1,113 @@
+package llm
+
+import (
+  "strings"
+
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+)
+
+// llmReferenceDescription_root describes a parameters root that was reached
+// through `$ref`, the way `LlmSchemaConverter.parameters` does with
+// `JsonDescriptor.cascade({ escape: true })`: the type's own description, then
+// each described namespace parent quoted, or `Current Type: {@link Name}` when
+// the type carries none (samchon/typia#2405). A root that is not a reference
+// keeps `own`.
+func llmReferenceDescription_root(
+  schema nativeiterate.JsonSchema,
+  components *nativeiterate.OpenApi_IComponents,
+  own *string,
+) *string {
+  ref, ok := schema["$ref"].(string)
+  if ok == false {
+    return own
+  }
+  key, ok := llmReferenceDescription_key(ref)
+  if ok == false {
+    return own
+  }
+  return llmReferenceDescription_cascade(key, components, own)
+}
+
+// llmReferenceDescription_cascade ports `JsonDescriptor.cascade` with
+// `escape: true`.
+func llmReferenceDescription_cascade(
+  key string,
+  components *nativeiterate.OpenApi_IComponents,
+  own *string,
+) *string {
+  type parent struct {
+    key         string
+    description *string
+  }
+  accessors := strings.Split(key, ".")
+  parents := []parent{}
+  for i := len(accessors); i >= 1; i-- {
+    current := strings.Join(accessors[:i], ".")
+    var description *string
+    if components != nil && components.Schemas != nil {
+      if target, found := components.Schemas[current]; found {
+        if text, ok := target["description"].(string); ok {
+          description = &text
+        }
+      }
+    }
+    // the type itself always stays; a parent only when it is described
+    if i == len(accessors) || (description != nil && *description != "") {
+      parents = append(parents, parent{key: current, description: description})
+    }
+  }
+  if (own == nil || *own == "") && len(parents) == 0 {
+    return nil
+  }
+  parts := []string{}
+  if own != nil && *own != "" {
+    parts = append(parts, *own)
+  }
+  for i, p := range parents {
+    if p.description == nil {
+      parts = append(parts, "Current Type: {@link "+p.key+"}")
+      continue
+    }
+    role := "parent"
+    if i == 0 {
+      role = "current"
+    }
+    lines := strings.Split(*p.description, "\n")
+    for j, line := range lines {
+      lines[j] = "> " + line
+    }
+    parts = append(parts, "Description of the "+role+" {@link "+p.key+"} type:\n\n"+strings.Join(lines, "\n"))
+  }
+  output := strings.Join(parts, "\n\n------------------------------\n\n")
+  return &output
+}
+
+// llmReferenceDescription_key reads the component key of a
+// `#/components/schemas/` reference. Native references carry the raw key, the
+// one `components.schemas` is indexed by; `LlmReference.readOpenApi` decodes
+// the escaped form of the same key in an emitted document.
+func llmReferenceDescription_key(ref string) (string, bool) {
+  const prefix = "#/components/schemas/"
+  if strings.HasPrefix(ref, prefix) == false {
+    return "", false
+  }
+  return strings.TrimPrefix(ref, prefix), true
+}
+
+// llmReferenceDescription_assign sets the cascaded root description on a
+// converted parameters object, removing it when the cascade yields none.
+func llmReferenceDescription_assign(
+  output map[string]any,
+  schema nativeiterate.JsonSchema,
+  components *nativeiterate.OpenApi_IComponents,
+) {
+  var own *string
+  if text, ok := output["description"].(string); ok {
+    own = &text
+  }
+  if description := llmReferenceDescription_root(schema, components, own); description != nil {
+    output["description"] = *description
+  } else {
+    delete(output, "description")
+  }
+}

package/native/core/programmers/llm/LlmSchemaProgrammer.go

@@ -15,6 +15,7 @@ import (
   nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
   nativejson "github.com/samchon/typia/packages/typia/native/core/programmers/json"
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  nativeutils "github.com/samchon/typia/packages/typia/native/core/utils"
 )
 
 type llmSchemaProgrammerNamespace struct{}
@@ -709,11 +710,11 @@ func llmSchemaProgrammer_shift_array(schema map[string]any) map[string]any {
   output := llmSchemaProgrammer_clone(schema)
   tags := []string{}
   if value, ok := output["minItems"]; ok {
-    tags = append(tags, "@minItems "+fmt.Sprint(value))
+    tags = append(tags, "@minItems "+llmSchemaProgrammer_tag_text(value))
     delete(output, "minItems")
   }
   if value, ok := output["maxItems"]; ok {
-    tags = append(tags, "@maxItems "+fmt.Sprint(value))
+    tags = append(tags, "@maxItems "+llmSchemaProgrammer_tag_text(value))
     delete(output, "maxItems")
   }
   if value, ok := output["uniqueItems"].(bool); ok {
@@ -732,7 +733,7 @@ func llmSchemaProgrammer_shift_numeric(schema map[string]any) map[string]any {
   tags := []string{}
   for _, key := range []string{"minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "default"} {
     if value, ok := output[key]; ok {
-      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
+      tags = append(tags, "@"+key+" "+llmSchemaProgrammer_tag_text(value))
       delete(output, key)
     }
   }
@@ -745,7 +746,7 @@ func llmSchemaProgrammer_shift_string(schema map[string]any) map[string]any {
   tags := []string{}
   for _, key := range []string{"minLength", "maxLength", "format", "pattern", "contentMediaType", "default"} {
     if value, ok := output[key]; ok {
-      tags = append(tags, "@"+key+" "+fmt.Sprint(value))
+      tags = append(tags, "@"+key+" "+llmSchemaProgrammer_tag_text(value))
       delete(output, key)
     }
   }
@@ -753,6 +754,35 @@ func llmSchemaProgrammer_shift_string(schema map[string]any) map[string]any {
   return output
 }
 
+// llmSchemaProgrammer_tag_text writes a shifted constraint value as `@typia/utils`'
+// OpenApiConstraintShifter does, through JavaScript's template interpolation.
+//
+// A numeric literal from a type tag arrives as the compiler's `jsnum.Number`,
+// whose `String()` already follows JavaScript, but a comment tag's value is a
+// plain float64, and `fmt.Sprint` spells it the Go way: `1e+06` for 1000000,
+// `1e-07` for 1e-7, `+Inf` for an infinity (samchon/typia#2452). Every float is
+// therefore spelled by `NumberUtil.String`, whatever its defined type, and a
+// pointer is followed to the value it holds.
+func llmSchemaProgrammer_tag_text(value any) string {
+  reflected := reflect.ValueOf(value)
+  for reflected.IsValid() && reflected.Kind() == reflect.Pointer && reflected.IsNil() == false {
+    reflected = reflected.Elem()
+  }
+  if reflected.IsValid() == false {
+    return fmt.Sprint(value)
+  }
+  switch reflected.Kind() {
+  case reflect.Float32, reflect.Float64:
+    return nativeutils.NumberUtil.String(reflected.Float())
+  case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+    // JavaScript holds the count as a double, rounding past 2^53.
+    return nativeutils.NumberUtil.String(float64(reflected.Int()))
+  case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+    return nativeutils.NumberUtil.String(float64(reflected.Uint()))
+  }
+  return fmt.Sprint(reflected.Interface())
+}
+
 func llmSchemaProgrammer_write_tag_with_description(schema map[string]any, tags []string) {
   if len(tags) == 0 {
     return

package/native/core/programmers/llm/llm_reference_description_test.go

@@ -0,0 +1,134 @@
+package llm
+
+import (
+  "testing"
+
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+)
+
+// TestLlmReferenceDescription locks the root description of a parameters
+// object reached through `$ref` to `JsonDescriptor.cascade({ escape: true })`,
+// the description `LlmSchemaConverter.parameters` writes for the same
+// collection (samchon/typia#2405).
+func TestLlmReferenceDescription(t *testing.T) {
+  t.Parallel()
+  const separator = "\n\n------------------------------\n\n"
+  text := func(value string) *string { return &value }
+  components := &nativeiterate.OpenApi_IComponents{
+    Schemas: map[string]nativeiterate.JsonSchema{
+      "IPlain":               {"type": "object"},
+      "IMember":              {"type": "object", "description": "Member.\nSecond line."},
+      "IMember.ICreate":      {"type": "object", "description": "Creation."},
+      "IMember.IBare":        {"type": "object"},
+      "IMember.Deep":         {"type": "object"},
+      "IMember.Deep.ILeaf":   {"type": "object"},
+      "IMember.IEmpty":       {"type": "object", "description": ""},
+      "INamespaceless.IItem": {"type": "object"},
+    },
+  }
+  cases := []struct {
+    name     string
+    schema   nativeiterate.JsonSchema
+    own      *string
+    expected *string
+  }{
+    {
+      name:     "undescribed",
+      schema:   nativeiterate.JsonSchema{"$ref": "#/components/schemas/IPlain"},
+      expected: text("Current Type: {@link IPlain}"),
+    },
+    {
+      name:   "described",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember"},
+      own:    text("Member.\nSecond line."),
+      expected: text("Member.\nSecond line." + separator +
+        "Description of the current {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:   "described child of a described parent",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember.ICreate"},
+      own:    text("Creation."),
+      expected: text("Creation." + separator +
+        "Description of the current {@link IMember.ICreate} type:\n\n> Creation." + separator +
+        "Description of the parent {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:   "undescribed child of a described parent",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember.IBare"},
+      expected: text("Current Type: {@link IMember.IBare}" + separator +
+        "Description of the parent {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:   "undescribed middle parent is skipped",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember.Deep.ILeaf"},
+      expected: text("Current Type: {@link IMember.Deep.ILeaf}" + separator +
+        "Description of the parent {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:   "empty own description renders quoted",
+      schema: nativeiterate.JsonSchema{"$ref": "#/components/schemas/IMember.IEmpty"},
+      own:    text(""),
+      expected: text("Description of the current {@link IMember.IEmpty} type:\n\n> " + separator +
+        "Description of the parent {@link IMember} type:\n\n> Member.\n> Second line."),
+    },
+    {
+      name:     "parent missing from components",
+      schema:   nativeiterate.JsonSchema{"$ref": "#/components/schemas/INamespaceless.IItem"},
+      expected: text("Current Type: {@link INamespaceless.IItem}"),
+    },
+    {
+      name:     "inline object keeps its own description",
+      schema:   nativeiterate.JsonSchema{"type": "object"},
+      own:      text("Inline."),
+      expected: text("Inline."),
+    },
+    {
+      name:   "inline object without description",
+      schema: nativeiterate.JsonSchema{"type": "object"},
+    },
+    {
+      name:     "foreign reference keeps its own description",
+      schema:   nativeiterate.JsonSchema{"$ref": "#/$defs/IPlain"},
+      own:      text("Own."),
+      expected: text("Own."),
+    },
+  }
+  for _, c := range cases {
+    actual := llmReferenceDescription_root(c.schema, components, c.own)
+    if (actual == nil) != (c.expected == nil) || (actual != nil && *actual != *c.expected) {
+      t.Errorf("%s:\nexpected %s\nactual   %s", c.name, llmReferenceDescriptionTest_show(c.expected), llmReferenceDescriptionTest_show(actual))
+    }
+  }
+}
+
+// TestLlmReferenceDescriptionAssign locks that the parameters object loses a
+// stale description when the cascade yields none, and gains the cascade
+// otherwise.
+func TestLlmReferenceDescriptionAssign(t *testing.T) {
+  t.Parallel()
+  components := &nativeiterate.OpenApi_IComponents{
+    Schemas: map[string]nativeiterate.JsonSchema{"IPlain": {"type": "object"}},
+  }
+  output := map[string]any{"type": "object"}
+  llmReferenceDescription_assign(output, nativeiterate.JsonSchema{"$ref": "#/components/schemas/IPlain"}, components)
+  if output["description"] != "Current Type: {@link IPlain}" {
+    t.Fatalf("reference root: got %#v", output["description"])
+  }
+  inline := map[string]any{"type": "object", "description": ""}
+  llmReferenceDescription_assign(inline, nativeiterate.JsonSchema{"type": "object"}, components)
+  if value, ok := inline["description"]; ok == false || value != "" {
+    t.Fatalf("inline root must keep its own description: got %#v", inline)
+  }
+  bare := map[string]any{"type": "object"}
+  llmReferenceDescription_assign(bare, nativeiterate.JsonSchema{"type": "object"}, components)
+  if _, ok := bare["description"]; ok {
+    t.Fatalf("inline root without description must stay undescribed: got %#v", bare)
+  }
+}
+
+func llmReferenceDescriptionTest_show(value *string) string {
+  if value == nil {
+    return "<nil>"
+  }
+  return "\"" + *value + "\""
+}

package/native/core/schemas/metadata/MetadataDependency.go

@@ -91,6 +91,15 @@ func MetadataDependency_active(checker *nativechecker.Checker) bool {
   return metadataDependency_listener(checker).active()
 }
 
+// MetadataDependency_touchFile reports a source file consulted outside the
+// metadata iterator, so a complete transform dependency list still watches it.
+func MetadataDependency_touchFile(checker *nativechecker.Checker, fileName string) {
+  listener := metadataDependency_listener(checker)
+  if listener.File != nil {
+    listener.File(fileName)
+  }
+}
+
 // MetadataDependency_touchType reports the declaration files of a consulted
 // type: both the structural symbol (interface / class / enum / object literal)
 // and the type-name symbol (a `type` alias), which differ for aliased types.

package/native/core/utils/NumberUtil.go

@@ -0,0 +1,195 @@
+package utils
+
+import (
+  "math"
+  "math/big"
+  "regexp"
+  "strconv"
+  "strings"
+  "unicode"
+)
+
+// NumberUtil reads numeric text the way JavaScript's `Number()` does.
+//
+// Tag values and JSDoc extensions are written in TypeScript source, and typia
+// splices numbers it reads from them into the JavaScript it emits, so their
+// grammar is JavaScript's StringNumericLiteral, not Go's float syntax. The two
+// differ in both directions: `strconv.ParseFloat` accepts `NaN`, `Inf`, and
+// `infinity` in any case, hexadecimal floats (`0x1p4`), and digit separators
+// (`1_000`), all of which `Number()` reads as NaN, while it rejects the
+// `0x`/`0o`/`0b` integers that `Number()` accepts. A spelling Go accepts but
+// JavaScript does not also becomes invalid emitted code once it is spliced into
+// a validator (samchon/typia#2442).
+type numberUtilNamespace struct{}
+
+var NumberUtil = numberUtilNamespace{}
+
+// NumberUtil_Reading is the outcome of reading one numeric text.
+type NumberUtil_Reading struct {
+  // Value is what `Number(text)` evaluates to, with negative zero read as zero.
+  Value float64
+
+  // Numeric is false when `Number(text)` is NaN, or when the text is blank.
+  Numeric bool
+
+  // Finite is false for `Infinity`, `-Infinity`, and values that overflow to
+  // them, such as `1e400`. JSON has no spelling for either.
+  Finite bool
+}
+
+// Read evaluates text with the grammar of JavaScript's `Number()`.
+//
+// Surrounding JavaScript whitespace is ignored, as `Number()` ignores it. One
+// deliberate difference remains: `Number("")` and `Number("  ")` are 0, but
+// blank text names no number, so it reads as non-numeric here.
+func (numberUtilNamespace) Read(text string) NumberUtil_Reading {
+  text = strings.TrimFunc(text, numberUtil_isWhiteSpace)
+  if text == "" {
+    return NumberUtil_Reading{}
+  }
+  if match := numberUtil_NON_DECIMAL.FindStringSubmatch(text); match != nil {
+    base := 16
+    switch match[1] {
+    case "o", "O":
+      base = 8
+    case "b", "B":
+      base = 2
+    }
+    integer, ok := new(big.Int).SetString(match[2], base)
+    if ok == false {
+      return NumberUtil_Reading{}
+    }
+    // big.Float rounds to nearest, ties to even, as the specification's
+    // mathematical-value conversion does, and reports overflow as an infinity.
+    value, _ := new(big.Float).SetInt(integer).Float64()
+    return numberUtil_reading(value)
+  }
+  if numberUtil_DECIMAL.MatchString(text) == false {
+    return NumberUtil_Reading{}
+  }
+  if strings.HasSuffix(text, "Infinity") {
+    if strings.HasPrefix(text, "-") {
+      return numberUtil_reading(math.Inf(-1))
+    }
+    return numberUtil_reading(math.Inf(1))
+  }
+  // The pattern admits only plain decimal notation, which ParseFloat reads with
+  // IEEE round-to-nearest. An out-of-range magnitude comes back as an infinity
+  // with ErrRange, which is exactly what `Number()` yields; underflow comes back
+  // as zero without an error, as it does in JavaScript.
+  value, err := strconv.ParseFloat(text, 64)
+  if err != nil && math.IsInf(value, 0) == false {
+    return NumberUtil_Reading{}
+  }
+  return numberUtil_reading(value)
+}
+
+// Integer reads text that spells an integer exactly: decimal digits with an
+// optional sign, or an unsigned `0x` / `0o` / `0b` literal.
+//
+// `Number()` rounds such text to the nearest double, so `9007199254740993`
+// reads as 9007199254740992. Splicing the digits as written keeps a check that
+// reads them as a BigInt literal (`$input % 9007199254740993n`) exact. Any
+// other spelling, including an integer written with an exponent or a point
+// (`1e3`, `1.0`), reports false; its value is the double `Read` returns.
+func (numberUtilNamespace) Integer(text string) (*big.Int, bool) {
+  text = strings.TrimFunc(text, numberUtil_isWhiteSpace)
+  if match := numberUtil_NON_DECIMAL.FindStringSubmatch(text); match != nil {
+    base := 16
+    switch match[1] {
+    case "o", "O":
+      base = 8
+    case "b", "B":
+      base = 2
+    }
+    return new(big.Int).SetString(match[2], base)
+  }
+  if numberUtil_INTEGER.MatchString(text) == false {
+    return nil, false
+  }
+  return new(big.Int).SetString(strings.TrimPrefix(text, "+"), 10)
+}
+
+// Rational is the exact value a finite numeric text writes.
+//
+// `Read` evaluates the text as `Number()` does, rounding it to the nearest
+// double; this keeps what the text says, so a caller can tell whether that
+// double is the written value itself. `9007199254740993` and
+// `9007199254740993.0` both read as 9007199254740992, but their rational value
+// is 9007199254740993. Text `Read` does not find numeric and finite reports
+// false, and so does text `big.Rat` refuses to expand: an exponent outside the
+// int64 range, or a non-zero mantissa whose exponent, net of its fraction
+// digits, lies beyond a million in magnitude (`1e-1000001` reads as 0 but has
+// no exact value here).
+func (numberUtilNamespace) Rational(text string) (*big.Rat, bool) {
+  if reading := NumberUtil.Read(text); reading.Numeric == false || reading.Finite == false {
+    return nil, false
+  }
+  if integer, ok := NumberUtil.Integer(text); ok {
+    return new(big.Rat).SetInt(integer), true
+  }
+  // `Read` admitted only StrDecimalLiteral here, whose spellings `big.Rat`
+  // parses: `5.`, `.5`, `+5`, and `1E3` included.
+  return new(big.Rat).SetString(strings.TrimFunc(text, numberUtil_isWhiteSpace))
+}
+
+// String spells a value exactly as JavaScript's `String(value)` does.
+//
+// That is `Number.prototype.toString`: positional notation from 1e-6 up to
+// 1e21, exponent notation outside with a signed exponent of no padded zeros
+// (`1e+21`, `1e-7`), and `NaN`, `Infinity`, `-Infinity`, and `0` for negative
+// zero. Each result is also JavaScript source text that evaluates to the value,
+// negative zero reading back as zero.
+func (numberUtilNamespace) String(value float64) string {
+  switch {
+  case math.IsNaN(value):
+    return "NaN"
+  case math.IsInf(value, 1):
+    return "Infinity"
+  case math.IsInf(value, -1):
+    return "-Infinity"
+  case value == 0:
+    return "0"
+  }
+  magnitude := math.Abs(value)
+  if magnitude >= 1e-6 && magnitude < 1e21 {
+    return strconv.FormatFloat(value, 'f', -1, 64)
+  }
+  // Go pads the exponent to two digits (`1e-07`); JavaScript does not.
+  text := strconv.FormatFloat(value, 'e', -1, 64)
+  index := strings.IndexByte(text, 'e')
+  mantissa, sign, digits := text[:index], text[index+1:index+2], strings.TrimLeft(text[index+2:], "0")
+  return mantissa + "e" + sign + digits
+}
+
+func numberUtil_reading(value float64) NumberUtil_Reading {
+  if value == 0 {
+    value = 0 // negative zero
+  }
+  return NumberUtil_Reading{
+    Value:   value,
+    Numeric: true,
+    Finite:  math.IsInf(value, 0) == false,
+  }
+}
+
+// numberUtil_isWhiteSpace is StrWhiteSpaceChar: WhiteSpace and LineTerminator.
+func numberUtil_isWhiteSpace(r rune) bool {
+  switch r {
+  case '\t', '\v', '\f', ' ', 0x00a0, 0xfeff, '\n', '\r', 0x2028, 0x2029:
+    return true
+  }
+  return unicode.Is(unicode.Zs, r)
+}
+
+// numberUtil_NON_DECIMAL is NonDecimalIntegerLiteral without separators. It
+// takes no sign: `Number("-0x10")` is NaN.
+var numberUtil_NON_DECIMAL = regexp.MustCompile(`^0([xXoObB])([0-9a-fA-F]+)$`)
+
+// numberUtil_INTEGER is a decimal integer with an optional sign.
+var numberUtil_INTEGER = regexp.MustCompile(`^[+-]?[0-9]+$`)
+
+// numberUtil_DECIMAL is StrDecimalLiteral: an optional sign before `Infinity`
+// or a decimal literal whose digits may omit either side of the point, with an
+// optional exponent. Separators are not part of it.
+var numberUtil_DECIMAL = regexp.MustCompile(`^[+-]?(?:Infinity|(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?)$`)

package/native/core/utils/number_util_rational_keeps_written_value_test.go

@@ -0,0 +1,62 @@
+package utils
+
+import (
+  "math/big"
+  "testing"
+)
+
+// TestNumberUtilRationalKeepsWrittenValue verifies NumberUtil.Rational keeps the
+// value a numeric text writes, not the double `Number()` rounds it to.
+//
+// A bigint comment tag must know whether a double is the written integer itself
+// before it states a bound with it (samchon/typia#2457), so the exact value has
+// to survive every spelling `Read` admits: points, exponents, signs, radix
+// prefixes, and surrounding whitespace. Text `Read` refuses, or finds infinite,
+// has no exact value.
+//
+//  1. Keep integers past 2^53, in every spelling.
+//  2. Keep fractions and point-edge spellings exactly.
+//  3. Refuse what `Read` refuses, and infinities.
+func TestNumberUtilRationalKeepsWrittenValue(t *testing.T) {
+  exact := func(text string) *big.Rat {
+    value, ok := new(big.Rat).SetString(text)
+    if ok == false {
+      t.Fatalf("bad expectation %s", text)
+    }
+    return value
+  }
+  for _, item := range []struct {
+    text     string
+    expected string
+  }{
+    // 1. integers past 2^53
+    {"9007199254740993", "9007199254740993"},
+    {"9007199254740993.0", "9007199254740993"},
+    {"9.007199254740993e15", "9007199254740993"},
+    {"+9007199254740993", "9007199254740993"},
+    {"-9007199254740993", "-9007199254740993"},
+    {"0x20000000000001", "9007199254740993"},
+    {"0o400000000000000001", "9007199254740993"},
+    {" 9007199254740993\t", "9007199254740993"},
+    {"\u00a09007199254740993.0 ", "9007199254740993"},
+    {"\t.5\u2028", "1/2"},
+    // 2. fractions and point edges
+    {".5", "1/2"},
+    {"5.", "5"},
+    {"-.5e1", "-5"},
+    {"1e-3", "1/1000"},
+    {"-0", "0"},
+  } {
+    value, ok := NumberUtil.Rational(item.text)
+    if ok == false || value.Cmp(exact(item.expected)) != 0 {
+      t.Fatalf("%q must be exactly %s, got %v (ok=%v)", item.text, item.expected, value, ok)
+    }
+  }
+
+  // 3. what Read refuses, and infinities
+  for _, text := range []string{"", " ", "1_000", "0x1p4", "inf", "NaN", "-0x10", "Infinity", "-Infinity", "1e400"} {
+    if value, ok := NumberUtil.Rational(text); ok {
+      t.Fatalf("%q must have no exact value, got %v", text, value)
+    }
+  }
+}