goscript 0.1.0 → 0.1.2

package/gs/syscall/net.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import {
+  Bind,
+  Close,
+  CloseOnExec,
+  Connect,
+  Dup,
+  EADDRNOTAVAIL,
+  EAGAIN,
+  EINTR,
+  EMFILE,
+  ENOSYS,
+  ENFILE,
+  ENOTSUP,
+  ETIMEDOUT,
+  Errno_Error,
+  Errno_Is,
+  Errno_Temporary,
+  Errno_Timeout,
+  GetsockoptInt,
+  Iovec,
+  IPPROTO_IPV6,
+  IPPROTO_TCP,
+  IPV6_V6ONLY,
+  Listen,
+  Pread,
+  Pwrite,
+  Read,
+  ReadDirent,
+  Recvfrom,
+  Recvmsg,
+  Seek,
+  SendmsgN,
+  Sendto,
+  SetReadDeadline,
+  SetNonblock,
+  SetsockoptInt,
+  SetWriteDeadline,
+  Shutdown,
+  SOCK_SEQPACKET,
+  SOMAXCONN,
+  Socket,
+  StopIO,
+  Write,
+  readv,
+  writev,
+} from './index.js'
+import type { Errno } from './index.js'
+
+describe('syscall network stubs', () => {
+  test('exports network constants used by generated net', () => {
+    expect(SOCK_SEQPACKET).toBe(5)
+    expect(IPPROTO_IPV6).toBe(0x29)
+    expect(IPPROTO_TCP).toBe(6)
+    expect(IPV6_V6ONLY).toBe(0x1a)
+    expect(SOMAXCONN).toBe(0x80)
+    expect(ENOTSUP.Error()).toBe('operation not supported')
+  })
+
+  test('models Errno numeric zero values and named primitive methods', () => {
+    const errno: $.VarRef<Errno> = $.varRef(0)
+
+    expect(Errno_Error(errno.value)).toBe('errno 0')
+    expect(Errno_Is(EADDRNOTAVAIL, EADDRNOTAVAIL)).toBe(true)
+    expect(Errno_Temporary(EINTR)).toBe(true)
+    expect(Errno_Temporary(EMFILE)).toBe(true)
+    expect(Errno_Temporary(ENFILE)).toBe(true)
+    expect(Errno_Timeout(EAGAIN)).toBe(true)
+    expect(Errno_Timeout(ETIMEDOUT)).toBe(true)
+    expect(Errno_Timeout(EADDRNOTAVAIL)).toBe(false)
+  })
+
+  test('reports unsupported socket operations as syscall errors', () => {
+    expect(Socket(0, 0, 0)).toEqual([-1, ENOSYS])
+    expect(Connect(-1, null)).toBe(ENOSYS)
+    expect(Listen(-1, 0)).toBe(ENOSYS)
+    expect(Bind(-1, null)).toBe(ENOSYS)
+    expect(StopIO(-1)).toBe(ENOSYS)
+    expect(Recvfrom(-1, null, 0)).toEqual([0, null, ENOSYS])
+    expect(Sendto(-1, null, 0, null)).toBe(ENOSYS)
+    expect(Recvmsg(-1, null, null, 0)).toEqual([0, 0, 0, null, ENOSYS])
+    expect(SendmsgN(-1, null, null, null, 0)).toEqual([0, ENOSYS])
+    expect(GetsockoptInt(-1, 0, 0)).toEqual([0, ENOSYS])
+    expect(SetsockoptInt(-1, 0, 0, 0)).toBeNull()
+    expect(SetReadDeadline(-1, 0)).toBe(ENOSYS)
+    expect(SetWriteDeadline(-1, 0)).toBe(ENOSYS)
+    expect(Shutdown(-1, 0)).toBe(ENOSYS)
+  })
+
+  test('exports JavaScript no-op descriptor flag helpers', () => {
+    expect(Close(1)).toBeNull()
+    expect(CloseOnExec(1)).toBeUndefined()
+    expect(SetNonblock(1, true)).toBeNull()
+    expect(SetNonblock(1, false)).toBeNull()
+  })
+
+  test('exports unsupported descriptor operations', () => {
+    expect(Read(-1, null)).toEqual([0, ENOSYS])
+    expect(ReadDirent(-1, null)).toEqual([0, ENOSYS])
+    expect(Pread(-1, null, 0)).toEqual([0, ENOSYS])
+    expect(Pwrite(-1, null, 0)).toEqual([0, ENOSYS])
+    expect(Seek(-1, 0, 0)).toEqual([0, ENOSYS])
+    expect(Write(-1, null)).toEqual([0, ENOSYS])
+    expect(Dup(-1)).toEqual([0, ENOSYS])
+    expect(readv(-1, [new Iovec()])).toEqual([0, ENOSYS])
+    expect(writev(-1, [new Iovec()])).toEqual([0, ENOSYS])
+  })
+})

package/gs/syscall/types.ts

@@ -3,10 +3,15 @@ import * as $ from '@goscript/builtin/index.js'
 // Essential type aliases
 export type uintptr = number
 
-// Errno type for syscall errors
-export interface Errno {
+// Errno is a named numeric Go type. Constants use object values so they can
+// satisfy error interfaces, while generated zero values may still be numbers.
+export type Errno = number | ErrnoObject
+
+export interface ErrnoObject {
   Error(): string
   Is(target: $.GoError): boolean
+  Temporary?(): boolean
+  Timeout?(): boolean
   Errno(): number
 }
 
@@ -16,3 +21,59 @@ export interface RawConn {
   Read(f: (fd: uintptr) => boolean): $.GoError
   Write(f: (fd: uintptr) => boolean): $.GoError
 }
+
+export interface Sockaddr {}
+
+export class SockaddrInet4 implements Sockaddr {
+  public Port: number = 0
+  public Addr: Uint8Array = new Uint8Array(4)
+
+  constructor(init?: Partial<SockaddrInet4>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
+
+  public clone(): SockaddrInet4 {
+    return new SockaddrInet4({
+      Port: this.Port,
+      Addr: new Uint8Array(this.Addr),
+    })
+  }
+}
+
+export class SockaddrInet6 implements Sockaddr {
+  public Port: number = 0
+  public ZoneId: number = 0
+  public Addr: Uint8Array = new Uint8Array(16)
+
+  constructor(init?: Partial<SockaddrInet6>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
+
+  public clone(): SockaddrInet6 {
+    return new SockaddrInet6({
+      Port: this.Port,
+      ZoneId: this.ZoneId,
+      Addr: new Uint8Array(this.Addr),
+    })
+  }
+}
+
+export class SockaddrUnix implements Sockaddr {
+  public Name: string = ''
+
+  constructor(init?: Partial<SockaddrUnix>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
+
+  public clone(): SockaddrUnix {
+    return new SockaddrUnix({ Name: this.Name })
+  }
+}
+
+export class Iovec {}

package/gs/testing/index.ts

@@ -0,0 +1 @@
+export * from './testing.js'

package/gs/testing/meta.json

@@ -0,0 +1,5 @@
+{
+  "asyncMethods": {
+    "T.Run": true
+  }
+}

package/gs/testing/testing.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it } from 'vitest'
+
+import { B, F, Short, T, type TB } from './testing.js'
+import { runTests } from './testing.js'
+
+describe('testing.T', () => {
+  it('runs passing subtests', async () => {
+    const t = new T('root')
+
+    const ok = await t.Run('child', (child) => {
+      expect(child.Name()).toBe('root/child')
+    })
+
+    expect(ok).toBe(true)
+    expect(t.Failed()).toBe(false)
+  })
+
+  it('runs async subtests before returning', async () => {
+    const t = new T('root')
+    let completed = false
+
+    const ok = await t.Run('child', async (child) => {
+      await Promise.resolve()
+      expect(child.Name()).toBe('root/child')
+      completed = true
+    })
+
+    expect(ok).toBe(true)
+    expect(completed).toBe(true)
+    expect(t.Failed()).toBe(false)
+  })
+
+  it('propagates failed subtests', async () => {
+    const t = new T('root')
+
+    const ok = await t.Run('child', (child) => {
+      child.Error('failed')
+    })
+
+    expect(ok).toBe(false)
+    expect(t.Failed()).toBe(true)
+  })
+
+  it('exports the benchmark and fuzz test surfaces used by compiled tests', async () => {
+    const b = new B('bench')
+    b.N = 2
+    b.ReportAllocs()
+    b.ResetTimer()
+    b.SetBytes(12)
+    b.ReportMetric(3, 'items')
+
+    let ran = false
+    const ok = await b.Run('child', (child) => {
+      ran = true
+      expect(child.Name()).toBe('bench/child')
+    })
+
+    const f = new F('fuzz')
+    f.Add('seed')
+    f.Fuzz(() => {})
+
+    const tb: TB = b
+    tb.Helper()
+
+    expect(ok).toBe(true)
+    expect(ran).toBe(true)
+    expect(Short()).toBe(false)
+  })
+
+  it('reports short mode while a short run is active', async () => {
+    let observed = false
+
+    const result = await runTests(
+      'example.test/short',
+      [
+        {
+          name: 'TestShort',
+          fn: () => {
+            observed = Short()
+          },
+        },
+      ],
+      { short: true },
+    )
+
+    expect(result.ok).toBe(true)
+    expect(observed).toBe(true)
+    expect(Short()).toBe(false)
+  })
+
+  it('accepts parallel tests in the sequential runner', () => {
+    const t = new T('root')
+
+    t.Parallel()
+
+    expect(t.Failed()).toBe(false)
+  })
+
+  it('accepts nil cleanup values and fails when cleanup runs', async () => {
+    const t = new T('root')
+
+    t.Cleanup(null)
+
+    await expect(t.runCleanups()).rejects.toThrow('testing: nil cleanup function')
+  })
+
+  it('returns a non-nil context', () => {
+    const t = new T('root')
+
+    expect(t.Context()).not.toBeNull()
+  })
+
+  it('formats common testing printf verbs', () => {
+    const t = new T('root')
+    const messages: string[] = []
+    const originalLog = console.log
+    console.log = (message?: unknown) => {
+      messages.push(String(message))
+    }
+    try {
+      t.Logf('quoted=%q value=%#v plus=%+v number=%d string=%s plain=%v', 'key', 7, { ok: true }, 3, 'ok', true)
+      t.flushLogs()
+    } finally {
+      console.log = originalLog
+    }
+
+    expect(messages).toEqual(['    quoted="key" value=7 plus=[object Object] number=3 string=ok plain=true'])
+  })
+
+  it('formats Go-style error objects with Error methods', () => {
+    const t = new T('root')
+    const messages: string[] = []
+    const originalLog = console.log
+    console.log = (message?: unknown) => {
+      messages.push(String(message))
+    }
+    try {
+      t.Logf('err=%v', { Error: () => 'host path missing' })
+      t.flushLogs()
+    } finally {
+      console.log = originalLog
+    }
+
+    expect(messages).toEqual(['    err=host path missing'])
+  })
+})