modernc.org/sortutil v1.2.1

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:golang/modernc.org/sortutil@v1.2.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/modernc.org/sortutil@v1.2.1

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:027f713d67d0805af5235cd701e74a301d1680ba2f63c057f66a75ebc334e001","contract":["sortutil.Dedupe removes duplicate elements from a sorted sort.Interface and returns the count of unique elements placed in the prefix","sortutil.Int32Slice implements sort.Interface and sorts int32 values in ascending order","sortutil.SearchInt32s returns the index of the target in a sorted int32 slice or the insertion point if not found","sortutil.ByteSlice implements sort.Interface and sorts byte values in ascending order","sortutil.SearchBytes returns the index of the target byte in a sorted byte slice"],"goal":"verify pkg:golang/modernc.org/sortutil@v1.2.1","kind":"HOW","packages":["pkg:golang/modernc.org/sortutil@v1.2.1"],"schemaVersion":1},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/modernc.org/sortutil@v1.2.1"],"schemaVersion":1,"subject":"pkg:golang/modernc.org/sortutil@v1.2.1","verifierAdapter":"golang@1"}

module sample

go 1.26.6

require modernc.org/sortutil v1.2.1

github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=

package main

import (
	"fmt"
	"sort"

	"modernc.org/sortutil"
)

func main() {
	numbers := []int{5, 2, 8, 2, 5, 1, 9, 8}
	sort.Ints(numbers)
	uniqueCount := sortutil.Dedupe(sort.IntSlice(numbers))
	deduped := numbers[:uniqueCount]
	fmt.Printf("Deduped ints: %v\n", deduped)

	int32s := sortutil.Int32Slice{50, 10, 40, 20, 30}
	int32s.Sort()
	fmt.Printf("Sorted int32s: %v\n", []int32(int32s))

	idx := sortutil.SearchInt32s(int32s, 30)
	fmt.Printf("SearchInt32s index for 30: %d\n", idx)
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/modernc.org/sortutil@v1.2.1",
  "kind": "HOW",
  "packages": [
    "pkg:golang/modernc.org/sortutil@v1.2.1"
  ]
}

package main

import (
	"fmt"
	"os"
	"reflect"
	"sort"

	"modernc.org/sortutil"
)

func main() {
	if err := runContractTests(); err != nil {
		fmt.Fprintf(os.Stderr, "Contract test failed: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("All contract assertions passed successfully.")
}

func runContractTests() error {
	// 1. sortutil.Dedupe removes duplicate elements from a sorted sort.Interface and returns the count of unique elements placed in the prefix
	{
		data := []int{1, 2, 2, 3, 3, 3, 4, 5, 5}
		n := sortutil.Dedupe(sort.IntSlice(data))
		if n != 5 {
			return fmt.Errorf("Dedupe expected 5 unique elements, got %d", n)
		}
		expected := []int{1, 2, 3, 4, 5}
		if !reflect.DeepEqual(data[:n], expected) {
			return fmt.Errorf("Dedupe expected prefix %v, got %v", expected, data[:n])
		}

		allSame := []int{9, 9, 9, 9}
		nSame := sortutil.Dedupe(sort.IntSlice(allSame))
		if nSame != 1 || allSame[0] != 9 {
			return fmt.Errorf("Dedupe expected 1 unique element of 9, got %d with %v", nSame, allSame[:nSame])
		}

		var empty []int
		nEmpty := sortutil.Dedupe(sort.IntSlice(empty))
		if nEmpty != 0 {
			return fmt.Errorf("Dedupe on empty slice expected 0, got %d", nEmpty)
		}
	}

	// 2. sortutil.Int32Slice implements sort.Interface and sorts int32 values in ascending order
	{
		slice := sortutil.Int32Slice{42, -10, 100, 0, -50}
		if slice.Len() != 5 {
			return fmt.Errorf("Int32Slice Len expected 5, got %d", slice.Len())
		}
		slice.Sort()
		expected := sortutil.Int32Slice{-50, -10, 0, 42, 100}
		if !reflect.DeepEqual(slice, expected) {
			return fmt.Errorf("Int32Slice Sort expected %v, got %v", expected, slice)
		}
	}

	// 3. sortutil.SearchInt32s returns the index of the target in a sorted int32 slice or the insertion point if not found
	{
		sorted := []int32{10, 20, 30, 40, 50}
		if idx := sortutil.SearchInt32s(sorted, 30); idx != 2 {
			return fmt.Errorf("SearchInt32s(30) expected index 2, got %d", idx)
		}
		if idx := sortutil.SearchInt32s(sorted, 10); idx != 0 {
			return fmt.Errorf("SearchInt32s(10) expected index 0, got %d", idx)
		}
		if idx := sortutil.SearchInt32s(sorted, 50); idx != 4 {
			return fmt.Errorf("SearchInt32s(50) expected index 4, got %d", idx)
		}
		if idx := sortutil.SearchInt32s(sorted, 25); idx != 2 {
			return fmt.Errorf("SearchInt32s(25) insertion point expected 2, got %d", idx)
		}
		if idx := sortutil.SearchInt32s(sorted, 5); idx != 0 {
			return fmt.Errorf("SearchInt32s(5) insertion point expected 0, got %d", idx)
		}
		if idx := sortutil.SearchInt32s(sorted, 60); idx != 5 {
			return fmt.Errorf("SearchInt32s(60) insertion point expected 5, got %d", idx)
		}
	}

	// 4. sortutil.ByteSlice implements sort.Interface and sorts byte values in ascending order
	{
		bytes := sortutil.ByteSlice{'z', 'a', 'm', 'b', 'c'}
		bytes.Sort()
		expected := sortutil.ByteSlice{'a', 'b', 'c', 'm', 'z'}
		if !reflect.DeepEqual(bytes, expected) {
			return fmt.Errorf("ByteSlice Sort expected %v, got %v", expected, bytes)
		}
	}

	// 5. sortutil.SearchBytes returns the index of the target byte in a sorted byte slice
	{
		sortedBytes := []byte{'a', 'c', 'e', 'g'}
		if idx := sortutil.SearchBytes(sortedBytes, 'e'); idx != 2 {
			return fmt.Errorf("SearchBytes('e') expected index 2, got %d", idx)
		}
		if idx := sortutil.SearchBytes(sortedBytes, 'a'); idx != 0 {
			return fmt.Errorf("SearchBytes('a') expected index 0, got %d", idx)
		}
		if idx := sortutil.SearchBytes(sortedBytes, 'd'); idx != 2 {
			return fmt.Errorf("SearchBytes('d') expected insertion index 2, got %d", idx)
		}
	}

	return nil
}