Packages, Testing, Fuzzing & Benchmarks

package mathx

import "testing"

func Max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func TestMax(t *testing.T) {
    tests := []struct {
        name     string
        a, b, want int
    }{
        {"a bigger", 3, 2, 3},
        {"b bigger", 1, 4, 4},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := Max(tt.a, tt.b); got != tt.want {
                t.Fatalf("got %d want %d", got, tt.want)
            }
        })
    }
}

import { describe, it, expect } from "vitest";

function max(a: number, b: number) {
  return a > b ? a : b;
}

describe("max", () => {
  it.each([
    ["a bigger", 3, 2, 3],
    ["b bigger", 1, 4, 4],
  ])("%s", (_name, a, b, want) => {
    expect(max(a, b)).toBe(want);
  });
});

import pytest

def max2(a: int, b: int) -> int:
    return a if a > b else b

@pytest.mark.parametrize("a,b,want", [(3, 2, 3), (1, 4, 4)])
def test_max(a, b, want):
    assert max2(a, b) == want

package parse

import "testing"

func Parse(s string) ([]int, error) { return nil, nil }

func FuzzParse(f *testing.F) {
    f.Add("1,2,3")
    f.Fuzz(func(t *testing.T, s string) {
        _, _ = Parse(s)
    })
}

func BenchmarkParse(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _, _ = Parse("1,2,3")
    }
}

// go test -fuzz=FuzzParse -fuzztime=30s
// go test -bench=. -benchmem -race

import fc from "fast-check";

function parseOk(s: string): boolean {
  return typeof s === "string";
}

// fc is the default export. A named import { fc } does not resolve.
fc.assert(fc.property(fc.string(), (s) => parseOk(s)));

def parse_ok(text: str) -> bool:
    return isinstance(text, str)