goscript 0.2.5 → 0.2.7

package/gs/fmt/fmt.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { resetHostRuntimeForTests } from '@goscript/builtin/hostio.js'
 import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
 import * as os from '@goscript/os/index.js'
 import * as fmt from './fmt.js'
 
@@ -86,6 +87,21 @@ describe('fmt basic value formatting', () => {
     expect(fmt.Sprintf('%q', 97)).toBe(JSON.stringify('a'))
   })
 
+  it('%c encodes runes including astral planes and invalid code points', () => {
+    expect(fmt.Sprintf('%c', 0x597d)).toBe('好')
+    // U+1F600 is above U+FFFF; fromCharCode would have truncated it.
+    expect(fmt.Sprintf('%c', 0x1f600)).toBe('😀')
+    expect(fmt.Sprintf('%c', 0x1f600).codePointAt(0)).toBe(0x1f600)
+    // Invalid code points map to U+FFFD instead of throwing.
+    expect(fmt.Sprintf('%c', 0x110000)).toBe('�')
+    expect(fmt.Sprintf('%c', -1)).toBe('�')
+  })
+
+  it('%q on an astral rune does not throw and round-trips the code point', () => {
+    expect(fmt.Sprintf('%q', 0x1f600)).toBe(JSON.stringify('😀'))
+    expect(fmt.Sprintf('%q', 0x110000)).toBe(JSON.stringify('�'))
+  })
+
   it('%p pointer-ish formatting fallback', () => {
     expect(fmt.Sprintf('%p', {})).toBe('0x0')
     expect(fmt.Sprintf('%p', { __address: 255 })).toBe('0xff')
@@ -127,8 +143,33 @@ describe('fmt basic value formatting', () => {
         return '<go stringer>'
       },
     }
-    // We prefer GoString() first
-    expect(fmt.Sprintf('%v', goStringer)).toBe('<go stringer>')
+    // Go consults GoString only for %#v, never plain %v / Sprint.
+    expect(fmt.Sprintf('%#v', goStringer)).toBe('<go stringer>')
+    expect(fmt.Sprintf('%v', goStringer)).not.toBe('<go stringer>')
+    expect(fmt.Sprint(goStringer)).not.toBe('<go stringer>')
+  })
+
+  it('applies # base prefixes and +/space sign flags (Go parity)', () => {
+    expect(fmt.Sprintf('%#x', 15)).toBe('0xf')
+    expect(fmt.Sprintf('%#X', 15)).toBe('0XF')
+    expect(fmt.Sprintf('%#o', 15)).toBe('017')
+    expect(fmt.Sprintf('%#x', 0)).toBe('0x0')
+    expect(fmt.Sprintf('%+d', 15)).toBe('+15')
+    expect(fmt.Sprintf('% d', 15)).toBe(' 15')
+    expect(fmt.Sprintf('%+d', -15)).toBe('-15')
+  })
+
+  it('%v prefers Stringer while %#v prefers GoStringer', () => {
+    const g = {
+      String() {
+        return 'G(7)'
+      },
+      GoString() {
+        return 'main.G{n:7}'
+      },
+    }
+    expect(fmt.Sprintf('%v|%#v', g, g)).toBe('G(7)|main.G{n:7}')
+    expect(fmt.Sprint(g)).toBe('G(7)')
   })
 
   it('%w formats errors by Error method', () => {
@@ -136,6 +177,21 @@ describe('fmt basic value formatting', () => {
     expect(fmt.Errorf('wrap: %w', err)?.Error()).toBe('wrap: root')
   })
 
+  it('%w wraps so Unwrap and errors.Is reach the operand', () => {
+    const base = $.newError('root')
+    const wrapped = fmt.Errorf('ctx: %w', base)
+    expect((wrapped as any).Unwrap()).toBe(base)
+    expect(errors.Is(wrapped, base)).toBe(true)
+  })
+
+  it('multiple %w unwrap to every operand', () => {
+    const a = $.newError('a')
+    const b = $.newError('b')
+    const wrapped = fmt.Errorf('%w and %w', a, b)
+    expect(errors.Is(wrapped, a)).toBe(true)
+    expect(errors.Is(wrapped, b)).toBe(true)
+  })
+
   it('%s formats stringers by String method', () => {
     const stringer = {
       String() {
@@ -297,4 +353,16 @@ describe('fmt scanning', () => {
     expect(start.value).toBe(12)
     expect(end.value).toBe(34)
   })
+
+  it('allows trailing input after the matched verbs (Go parity)', () => {
+    const v = $.varRef(0)
+    const [n, err] = fmt.Sscanf(
+      '123 trailing',
+      '%d',
+      $.interfaceValue(v, '*int64'),
+    )
+    expect(err).toBeNull()
+    expect(n).toBe(1)
+    expect(v.value).toBe(123)
+  })
 })

package/gs/fmt/fmt.ts

@@ -25,19 +25,58 @@ export interface State {
   Write(b: $.Bytes): [number, $.GoError | null]
 }
 
+// formatInt renders an integer value in the given radix, applying Go's # flag
+// (0x/0X/0 base prefix) and +/space sign flags. The sign precedes the prefix,
+// matching fmt's "%+#x" ordering.
+function formatInt(
+  value: any,
+  radix: number,
+  flags: string,
+  upper: boolean,
+): string {
+  const big = typeof value === 'bigint'
+  const neg = big ? (value as bigint) < 0n : Number(value) < 0
+  let digits = big
+    ? (neg ? -(value as bigint) : (value as bigint)).toString(radix)
+    : Math.abs(Math.trunc(Number(value))).toString(radix)
+  if (upper) {
+    digits = digits.toUpperCase()
+  }
+  let prefix = ''
+  if (flags.includes('#')) {
+    if (radix === 16) {
+      prefix = upper ? '0X' : '0x'
+    } else if (radix === 8 && !digits.startsWith('0')) {
+      prefix = '0'
+    }
+  }
+  let sign = ''
+  if (neg) {
+    sign = '-'
+  } else if (flags.includes('+')) {
+    sign = '+'
+  } else if (flags.includes(' ')) {
+    sign = ' '
+  }
+  return sign + prefix + digits
+}
+
 // Simple printf-style formatting implementation
-function formatValue(value: any, verb: string): string {
+function formatValue(value: any, verb: string, flags = ''): string {
   if (value === null || value === undefined) {
     return '<nil>'
   }
 
   switch (verb) {
     case 'v': // default format
+      if (flags.includes('#') && hasGoString(value)) {
+        return defaultFormat(value.GoString())
+      }
       return defaultFormat(value)
     case 'w': // wrapped error
       return defaultFormat(value)
     case 'd': // decimal integer
-      return String(Math.trunc(Number(value)))
+      return formatInt(value, 10, flags, false)
     case 'f': // decimal point, no exponent
       return Number(value).toString()
     case 's': // string
@@ -55,15 +94,18 @@ function formatValue(value: any, verb: string): string {
       if (typeof value === 'string') return 'string'
       return typeof value
     case 'c': // character (Unicode code point)
-      return String.fromCharCode(Number(value))
+      // Go's %c encodes the rune as a Unicode character; fromCharCode truncates
+      // any code point above U+FFFF and mangles surrogates. runeToString owns
+      // the Go string(rune) rule (astral intact, invalid -> U+FFFD, no throw).
+      return $.runeToString(Number(value))
     case 'x': // hexadecimal lowercase
-      return Number(value).toString(16)
+      return formatInt(value, 16, flags, false)
     case 'X': // hexadecimal uppercase
-      return Number(value).toString(16).toUpperCase()
+      return formatInt(value, 16, flags, true)
     case 'o': // octal
-      return Number(value).toString(8)
+      return formatInt(value, 8, flags, false)
     case 'b': // binary
-      return Number(value).toString(2)
+      return formatInt(value, 2, flags, false)
     case 'e': // scientific notation lowercase
       return Number(value).toExponential()
     case 'E': // scientific notation uppercase
@@ -74,9 +116,9 @@ function formatValue(value: any, verb: string): string {
       return Number(value).toPrecision().toUpperCase()
     case 'q': // quoted string / rune
       if (typeof value === 'number' && Number.isInteger(value)) {
-        // emulate quoted rune for integers in basic range
-        const ch = String.fromCodePoint(value)
-        return JSON.stringify(ch)
+        // emulate quoted rune; runeToString avoids fromCodePoint throwing on
+        // invalid code points and maps them to U+FFFD as Go's %q does.
+        return JSON.stringify($.runeToString(value))
       }
       return JSON.stringify(String(value))
     case 'p': {
@@ -98,6 +140,16 @@ function hasGoTypeName(value: unknown): value is { __goType: string } {
   )
 }
 
+// hasGoString reports whether value implements the GoStringer interface. Go
+// invokes GoString only for the %#v verb, never for %v, %s, or Sprint.
+function hasGoString(value: unknown): value is { GoString: () => string } {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    typeof (value as { GoString?: unknown }).GoString === 'function'
+  )
+}
+
 type MaybeString = string | PromiseLike<string>
 
 function isPromiseLike<T = unknown>(value: unknown): value is PromiseLike<T> {
@@ -145,17 +197,9 @@ function defaultFormatMaybe(value: any): MaybeString {
   if (Array.isArray(value))
     return joinMaybe(value.map(defaultFormatMaybe), ' ', '[', ']')
   if (typeof value === 'object') {
-    // Prefer GoStringer if present
-    if (
-      (value as any).GoString &&
-      typeof (value as any).GoString === 'function'
-    ) {
-      try {
-        return toMaybeString((value as any).GoString())
-      } catch {
-        // Ignore error by continuing to next case.
-      }
-    }
+    // GoStringer is intentionally not consulted here: Go calls GoString only
+    // for the %#v verb, which formatValue handles before reaching this default
+    // path. %v, %s, Sprint, and Print use Error then Stringer.
     // Prefer error interface if present
     if ((value as any).Error && typeof (value as any).Error === 'function') {
       try {
@@ -233,18 +277,21 @@ function parseFormat(format: string, args: any[]): string {
   return formatted
 }
 
-function formatValueMaybe(value: any, verb: string): MaybeString {
+function formatValueMaybe(value: any, verb: string, flags = ''): MaybeString {
   switch (verb) {
     case 'v':
+      if (flags.includes('#') && hasGoString(value)) {
+        return toMaybeString(value.GoString())
+      }
+      return defaultFormatMaybe(value)
     case 'w':
+      return defaultFormatMaybe(value)
     case 's':
-      if (verb === 's') {
-        if (typeof value === 'string') return value
-        if (value instanceof Uint8Array) return $.bytesToString(value)
-      }
+      if (typeof value === 'string') return value
+      if (value instanceof Uint8Array) return $.bytesToString(value)
       return defaultFormatMaybe(value)
     default:
-      return formatValue(value, verb)
+      return formatValue(value, verb, flags)
   }
 }
 
@@ -351,8 +398,8 @@ function parseFormatMaybe(
             if (formatted === null) {
               formatted =
                 allowAsync ?
-                  formatValueMaybe(arg, verb)
-                : formatValue(arg, verb)
+                  formatValueMaybe(arg, verb, flags)
+                : formatValue(arg, verb, flags)
             }
 
             parts.push(
@@ -591,7 +638,52 @@ export function Appendln(b: $.Bytes, ...a: any[]): $.Bytes {
 // Error creation
 export function Errorf(format: string, ...a: any[]): any {
   const message = parseFormat(format, a)
-  return errors.New(message)
+  const err = errors.New(message)
+  // %w operands are wrapped: the result must Unwrap to them so errors.Is/As can
+  // walk the chain. One %w unwraps to a single error; multiple %w (Go 1.20+)
+  // unwrap to an []error, matching the depth-first traversal in errors.Is.
+  const wrapped = errorfWrappedArgs(format, a)
+  if (wrapped.length === 1) {
+    ;(err as any).Unwrap = (): $.GoError => wrapped[0]
+  } else if (wrapped.length > 1) {
+    ;(err as any).Unwrap = (): $.GoError[] => wrapped
+  }
+  return err
+}
+
+// errorfWrappedArgs returns the error operands consumed by %w verbs, in order.
+// It walks the format string with the same flag/width/precision/verb skip and
+// the same positional arg consumption as parseFormat, so the operand a %w binds
+// to here is exactly the one it formatted in the message.
+function errorfWrappedArgs(format: string, args: any[]): $.GoError[] {
+  const wrapped: $.GoError[] = []
+  let argIndex = 0
+  for (let i = 0; i < format.length; i++) {
+    if (format[i] !== '%' || i + 1 >= format.length) {
+      continue
+    }
+    if (format[i + 1] === '%') {
+      i++
+      continue
+    }
+    let j = i + 1
+    while (j < format.length && '+-# 0'.includes(format[j])) j++
+    while (j < format.length && format[j] >= '0' && format[j] <= '9') j++
+    if (j < format.length && format[j] === '.') {
+      j++
+      while (j < format.length && format[j] >= '0' && format[j] <= '9') j++
+    }
+    if (j < format.length) {
+      if (argIndex < args.length) {
+        if (format[j] === 'w') {
+          wrapped.push(args[argIndex] as $.GoError)
+        }
+        argIndex++
+      }
+      i = j
+    }
+  }
+  return wrapped
 }
 
 // FormatString - simplified implementation
@@ -676,12 +768,15 @@ export function Sscanf(
 function buildScanPattern(
   format: string,
 ): { pattern: RegExp; verbs: string[] } | null {
+  // Anchor at the start only: Go's Sscanf consumes a prefix and allows trailing
+  // input to remain, so no end anchor. A run of whitespace in the format matches
+  // spaces and tabs but not a newline, which Go treats as a record boundary.
   let source = '^'
   const verbs: string[] = []
   for (let i = 0; i < format.length; i++) {
     const ch = format[i]
     if (ch !== '%') {
-      source += /\s/.test(ch) ? '\\s+' : escapeRegExp(ch)
+      source += /\s/.test(ch) ? '[ \\t]+' : escapeRegExp(ch)
       continue
     }
     const verb = format[++i]
@@ -690,18 +785,17 @@ function buildScanPattern(
       continue
     }
     if (verb === 'd') {
-      source += '([+-]?\\d+)'
+      source += '\\s*([+-]?\\d+)' // verbs skip leading whitespace, incl. newlines
       verbs.push(verb)
       continue
     }
     if (verb === 's') {
-      source += '(\\S+)'
+      source += '\\s*(\\S+)'
       verbs.push(verb)
       continue
     }
     return null
   }
-  source += '$'
   return { pattern: new RegExp(source), verbs }
 }
 

package/gs/golang.org/x/crypto/cryptobyte/index.ts

@@ -1378,7 +1378,7 @@ function makeTime(
   const millis =
     globalThis.Date.UTC(year, month - 1, day, hour, minute, second) -
     offsetMinutes * 60 * 1000
-  return time.Unix(Math.floor(millis / 1000), 0)
+  return time.Unix(BigInt(Math.floor(millis / 1000)), 0n)
 }
 
 function parseGeneralizedTime(value: string): time.Time | null {

package/gs/internal/bytealg/index.test.ts

@@ -1,6 +1,11 @@
 import { describe, expect, test } from 'vitest'
 
-import { CountString, IndexByteString, LastIndexByteString } from './index.js'
+import {
+  CountString,
+  IndexByteString,
+  IndexString,
+  LastIndexByteString,
+} from './index.js'
 
 describe('internal/bytealg string byte indexes', () => {
   test('finds first and last byte positions in strings', () => {
@@ -15,4 +20,24 @@ describe('internal/bytealg string byte indexes', () => {
     expect(CountString('hello', 'x'.charCodeAt(0))).toBe(0)
     expect(CountString('', 'x'.charCodeAt(0))).toBe(0)
   })
+
+  test('indexes UTF-8 bytes, not UTF-16 code units (Go semantics)', () => {
+    // '你' encodes to UTF-8 bytes E4 BD A0. A 0xA0 byte lives at byte index 2,
+    // and the trailing 'A' at byte index 3; UTF-16 search would mislocate both.
+    const s = '你A'
+    expect(IndexByteString(s, 0xe4)).toBe(0)
+    expect(IndexByteString(s, 0xa0)).toBe(2)
+    expect(IndexByteString(s, 'A'.charCodeAt(0))).toBe(3)
+    expect(LastIndexByteString(s, 0xbd)).toBe(1)
+    expect(CountString('日本語', 0xe6)).toBe(2)
+  })
+
+  test('IndexString returns the byte offset of a multibyte substring', () => {
+    // 'A你B': 'B' is at byte index 4 (1 + 3 UTF-8 bytes for 你).
+    expect(IndexString('A你B', 'B')).toBe(4)
+    expect(IndexString('A你B', '你')).toBe(1)
+    expect(IndexString('hello', '')).toBe(0)
+    expect(IndexString('hi', 'hello')).toBe(-1)
+    expect(IndexString('hello', 'xyz')).toBe(-1)
+  })
 })

package/gs/internal/bytealg/index.ts

@@ -1,5 +1,7 @@
 // Placeholder bytealg module for reflect package compatibility
 
+import * as $ from '@goscript/builtin/index.js'
+
 // Helper function to normalize bytes input
 function normalizeBytes(b: any): any[] {
   if (b === null || b === undefined) {
@@ -126,21 +128,35 @@ export function IndexRabinKarp(s: any, sep: any): number {
   return Index(s, sep)
 }
 
+// Go bytealg operates on the UTF-8 byte representation of a string and returns
+// byte indices, not UTF-16 code-unit indices. String.fromCharCode/indexOf would
+// search code units, mislocating any byte >127 or any multi-byte rune. Search
+// the Go bytes via the builtin string owner so indices match Go.
 export function IndexByteString(s: string, b: number): number {
-  const char = String.fromCharCode(b)
-  return s.indexOf(char)
+  const bytes = $.stringToBytes(s)
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] === b) {
+      return i
+    }
+  }
+  return -1
 }
 
 export function LastIndexByteString(s: string, b: number): number {
-  const char = String.fromCharCode(b)
-  return s.lastIndexOf(char)
+  const bytes = $.stringToBytes(s)
+  for (let i = bytes.length - 1; i >= 0; i--) {
+    if (bytes[i] === b) {
+      return i
+    }
+  }
+  return -1
 }
 
 export function CountString(s: string, b: number): number {
-  const char = String.fromCharCode(b)
+  const bytes = $.stringToBytes(s)
   let count = 0
-  for (let i = 0; i < s.length; i++) {
-    if (s[i] === char) {
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] === b) {
       count++
     }
   }
@@ -148,7 +164,27 @@ export function CountString(s: string, b: number): number {
 }
 
 export function IndexString(s: string, substr: string): number {
-  return s.indexOf(substr)
+  const bytes = $.stringToBytes(s)
+  const sub = $.stringToBytes(substr)
+  if (sub.length === 0) {
+    return 0
+  }
+  if (sub.length > bytes.length) {
+    return -1
+  }
+  for (let i = 0; i <= bytes.length - sub.length; i++) {
+    let found = true
+    for (let j = 0; j < sub.length; j++) {
+      if (bytes[i + j] !== sub[j]) {
+        found = false
+        break
+      }
+    }
+    if (found) {
+      return i
+    }
+  }
+  return -1
 }
 
 export function MakeNoZero(n: number): Uint8Array {

package/gs/internal/byteorder/index.ts

@@ -12,8 +12,9 @@ export function BEUint32(b: $.Bytes): number {
   return (((b![0] << 24) >>> 0) | (b![1] << 16) | (b![2] << 8) | b![3]) >>> 0
 }
 
-export function BEUint64(b: $.Bytes): number {
-  return $.uint(
+export function BEUint64(b: $.Bytes): bigint {
+  return BigInt.asUintN(
+    64,
     (BigInt(b![0]) << 56n) |
       (BigInt(b![1]) << 48n) |
       (BigInt(b![2]) << 40n) |
@@ -33,8 +34,9 @@ export function LEUint32(b: $.Bytes): number {
   return b![0] | (b![1] << 8) | (b![2] << 16) | (b![3] << 24)
 }
 
-export function LEUint64(b: $.Bytes): number {
-  return $.uint(
+export function LEUint64(b: $.Bytes): bigint {
+  return BigInt.asUintN(
+    64,
     BigInt(b![0]) |
       (BigInt(b![1]) << 8n) |
       (BigInt(b![2]) << 16n) |

package/gs/io/fs/format.ts

@@ -16,8 +16,8 @@ export function FormatFileInfo(info: FileInfo): string {
   b.push(' ')
 
   let size = info!.Size()
-  const usize = size >= 0 ? size : -size
-  if (size < 0) {
+  const usize = size >= 0n ? size : -size
+  if (size < 0n) {
     b.push('-')
   }
 

package/gs/io/fs/fs.ts

@@ -335,7 +335,7 @@ export type FileInfo = null | {
   // base name of the file
   Name(): string
   // length in bytes for regular files; system-dependent for others
-  Size(): number
+  Size(): bigint
   // underlying data source (can return nil)
   Sys(): null | any
 }
@@ -359,7 +359,7 @@ $.registerInterfaceType(
     {
       name: 'Size',
       args: [],
-      returns: [{ type: { kind: $.TypeKind.Basic, name: 'number' } }],
+      returns: [{ type: { kind: $.TypeKind.Basic, name: 'int64' } }],
     },
     {
       name: 'Sys',

package/gs/io/fs/stat.test.ts

@@ -17,8 +17,8 @@ function fileInfo(name: string, isDir = false): FileInfo {
     Name(): string {
       return name
     },
-    Size(): number {
-      return 0
+    Size(): bigint {
+      return 0n
     },
     Sys(): null {
       return null

package/gs/io/fs/sub.test.ts

@@ -17,8 +17,8 @@ function fileInfo(name: string, isDir = false): FileInfo {
     Name(): string {
       return name
     },
-    Size(): number {
-      return 0
+    Size(): bigint {
+      return 0n
     },
     Sys(): null {
       return null

package/gs/io/fs/walk.test.ts

@@ -26,8 +26,8 @@ class info implements FileInfo {
     return this.name
   }
 
-  Size(): number {
-    return 0
+  Size(): bigint {
+    return 0n
   }
 
   Sys(): null {

package/gs/io/io.test.ts

@@ -1,10 +1,12 @@
 import * as $ from '@goscript/builtin/index.js'
 import {
+  EOF,
   LimitedReader,
   MultiWriter,
   NewSectionReader,
   NopCloser,
   Pipe,
+  ReadAll,
   TeeReader,
 } from './index.js'
 import { describe, expect, test } from 'vitest'
@@ -32,8 +34,8 @@ class captureWriter {
 class syncReaderAt {
   constructor(private data: Uint8Array) {}
 
-  ReadAt(p: $.Bytes, off: number): [number, $.GoError] {
-    const n = $.copy(p, this.data.subarray(off))
+  ReadAt(p: $.Bytes, off: bigint): [number, $.GoError] {
+    const n = $.copy(p, this.data.subarray(Number(off)))
     return [n, n < $.len(p) ? (new Error('EOF') as $.GoError) : null]
   }
 }
@@ -42,7 +44,7 @@ describe('io override', () => {
   test('LimitedReader accepts generated struct-literal construction', async () => {
     const reader = new LimitedReader({
       R: new sliceReader($.stringToBytes('abcdef')),
-      N: 3,
+      N: 3n,
     })
     const buf = new Uint8Array(8)
 
@@ -154,10 +156,10 @@ describe('io override', () => {
   test('SectionReader awaits async ReaderAt', async () => {
     const reader = NewSectionReader(
       {
-        async ReadAt(p: $.Bytes, off: number): Promise<[number, $.GoError]> {
+        async ReadAt(p: $.Bytes, off: bigint): Promise<[number, $.GoError]> {
           await Promise.resolve()
           const data = $.stringToBytes('abcdef')
-          const n = $.copy(p, data.subarray(off))
+          const n = $.copy(p, data.subarray(Number(off)))
           return [n, n < $.len(p) ? (new Error('EOF') as $.GoError) : null]
         },
       } as any,
@@ -187,4 +189,44 @@ describe('io override', () => {
     expect(readBytes).toBe(5)
     expect(Buffer.from(buf).toString('utf8')).toBe('later')
   })
+
+  test('ReadAll returns the bytes already read with a non-EOF error', async () => {
+    const boom = new Error('boom') as $.GoError
+    let called = false
+    const reader = {
+      Read(p: $.Bytes): [number, $.GoError] {
+        if (called) {
+          return [0, EOF]
+        }
+        called = true
+        const data = $.stringToBytes('hello')
+        p!.set(data, 0)
+        return [$.len(data), boom]
+      },
+    }
+
+    const [data, err] = await ReadAll(reader)
+    expect(err).toBe(boom)
+    expect($.bytesToString(data)).toBe('hello')
+  })
+
+  test('ReadAll reports EOF as a nil error', async () => {
+    const data = $.stringToBytes('world')
+    let offset = 0
+    const reader = {
+      Read(p: $.Bytes): [number, $.GoError] {
+        if (offset >= $.len(data)) {
+          return [0, EOF]
+        }
+        const n = Math.min($.len(p), $.len(data) - offset)
+        p!.set((data as Uint8Array).subarray(offset, offset + n), 0)
+        offset += n
+        return [n, null]
+      },
+    }
+
+    const [out, err] = await ReadAll(reader)
+    expect(err).toBeNull()
+    expect($.bytesToString(out)).toBe('world')
+  })
 })