test examples

Author: lanrat

.cspell.json

@@ -21,8 +21,10 @@
         "lessfunc",
         "memprofile",
         "pprof",
+        "Println",
         "psilva",
         "staticcheck",
+        "strconv",
         "tempfile",
         "tempfiles",
         "timsort"

Makefile

@@ -4,15 +4,12 @@ include version.mk
 
 ALL_SOURCES := $(shell find . -type f -name '*.go')
 
-.PHONY: fmt check test cover coverhtml example
+.PHONY: fmt check test cover coverhtml examples
 
 test:
 	go test -timeout=90s -v ./...
 	@echo "< ALL TESTS PASS >"
 
-example:
-	go run example/example.go >/dev/null
-
 update-deps: go.mod
 	GOPROXY=direct go get -u ./...
 	go mod tidy
@@ -37,4 +34,12 @@ check:
 	staticcheck -checks all ./...
 
 benchmark:
-	./run_benchmarks.sh
+	./run_benchmarks.sh
+
+examples:
+	@for dir in examples/*/; do \
+		if [ -f "$$dir"*.go ]; then \
+			echo "Running example in $$dir"; \
+			(cd "$$dir" && go run *.go > /dev/null); \
+		fi; \
+	done

README.md

@@ -55,7 +55,7 @@ func main() {
 
     // Process sorted results
     for value := range outputChan {
-        fmt.Println(value)
+        fmt.pintle(value)
     }
 
     // Check for errors
@@ -494,4 +494,4 @@ This project is licensed under the Apache License - see the LICENSE file for det
 
 ## Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+Contributions are welcome! Please feel free to submit a Pull Request.

example/example.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/gob"
+	"fmt"
+
+	"github.com/lanrat/extsort"
+)
+
+type Person struct {
+	Name string
+	Age  int
+}
+
+func personToBytes(p Person) []byte {
+	var buf bytes.Buffer
+	enc := gob.NewEncoder(&buf)
+	enc.Encode(p)
+	return buf.Bytes()
+}
+
+func personFromBytes(data []byte) Person {
+	var p Person
+	buf := bytes.NewReader(data)
+	dec := gob.NewDecoder(buf)
+	dec.Decode(&p)
+	return p
+}
+
+func comparePersons(a, b Person) bool {
+	return a.Age < b.Age // Sort by age
+}
+
+func main() {
+	people := []Person{
+		{"Alice", 30},
+		{"Bob", 25},
+		{"Charlie", 35},
+	}
+
+	inputChan := make(chan Person, len(people))
+	for _, person := range people {
+		inputChan <- person
+	}
+	close(inputChan)
+
+	sorter, outputChan, errChan := extsort.Generic(
+		inputChan,
+		personFromBytes,
+		personToBytes,
+		comparePersons,
+		nil,
+	)
+
+	go sorter.Sort(context.Background())
+
+	fmt.Println("People sorted by age:")
+	for person := range outputChan {
+		fmt.Printf("%s (age %d)\n", person.Name, person.Age)
+	}
+
+	if err := <-errChan; err != nil {
+		panic(err)
+	}
+}

examples/custom_types/custom_types.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/lanrat/extsort/diff"
+)
+
+func main() {
+	// Create two sorted string channels
+	streamA := make(chan string, 5)
+	streamB := make(chan string, 5)
+
+	// Populate stream A
+	go func() {
+		defer close(streamA)
+		for _, item := range []string{"apple", "banana", "cherry", "elderberry"} {
+			streamA <- item
+		}
+	}()
+
+	// Populate stream B
+	go func() {
+		defer close(streamB)
+		for _, item := range []string{"banana", "cherry", "date", "fig"} {
+			streamB <- item
+		}
+	}()
+
+	// Create error channels
+	errA := make(chan error, 1)
+	errB := make(chan error, 1)
+	close(errA)
+	close(errB)
+
+	// Process differences
+	result, err := diff.Strings(
+		context.Background(),
+		streamA, streamB,
+		errA, errB,
+		func(delta diff.Delta, item string) error {
+			switch delta {
+			case diff.OLD:
+				fmt.Printf("Only in A: %s\n", item)
+			case diff.NEW:
+				fmt.Printf("Only in B: %s\n", item)
+			}
+			return nil
+		},
+	)
+
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Printf("Summary: %d items only in A, %d items only in B, %d common items\n",
+		result.ExtraA, result.ExtraB, result.Common)
+}

examples/diff/diff.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/lanrat/extsort/diff"
+)
+
+func main() {
+	// Create channels with integer data
+	streamA := make(chan int, 5)
+	streamB := make(chan int, 5)
+	errA := make(chan error, 1)
+	errB := make(chan error, 1)
+
+	// Populate streams
+	go func() {
+		defer close(streamA)
+		defer close(errA)
+		for _, num := range []int{1, 3, 5, 7, 9} {
+			streamA <- num
+		}
+	}()
+
+	go func() {
+		defer close(streamB)
+		defer close(errB)
+		for _, num := range []int{2, 4, 5, 6, 8} {
+			streamB <- num
+		}
+	}()
+
+	// Compare using generic diff
+	compareFunc := func(a, b int) int {
+		if a < b {
+			return -1
+		}
+		if a > b {
+			return 1
+		}
+		return 0
+	}
+
+	resultFunc := func(delta diff.Delta, item int) error {
+		symbol := map[diff.Delta]string{diff.OLD: "<", diff.NEW: ">"}[delta]
+		fmt.Printf("%s %d\n", symbol, item)
+		return nil
+	}
+
+	result, err := diff.Generic(
+		context.Background(),
+		streamA, streamB,
+		errA, errB,
+		compareFunc,
+		resultFunc,
+	)
+
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Printf("Differences found: %d\n", result.ExtraA+result.ExtraB)
+}

examples/diff_generic/diff_generic.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/lanrat/extsort/diff"
+)
+
+func main() {
+	streamA := make(chan string, 100)
+	streamB := make(chan string, 100)
+	errA := make(chan error, 1)
+	errB := make(chan error, 1)
+
+	// Populate streams with test data
+	go func() {
+		defer close(streamA)
+		defer close(errA)
+		for i := 0; i < 50; i += 2 {
+			streamA <- fmt.Sprintf("item_%03d", i)
+		}
+	}()
+
+	go func() {
+		defer close(streamB)
+		defer close(errB)
+		for i := 1; i < 50; i += 2 {
+			streamB <- fmt.Sprintf("item_%03d", i)
+		}
+	}()
+
+	// Use channel-based result processing for parallel handling
+	resultFunc, resultChan := diff.StringResultChan()
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	// Process results in parallel
+	go func() {
+		defer wg.Done()
+		for result := range resultChan {
+			fmt.Printf("Difference: %s %s\n", result.D, result.S)
+		}
+	}()
+
+	// Start diff operation
+	go func() {
+		defer close(resultChan)
+		_, err := diff.Strings(
+			context.Background(),
+			streamA, streamB,
+			errA, errB,
+			resultFunc,
+		)
+		if err != nil {
+			fmt.Printf("Diff error: %v\n", err)
+		}
+	}()
+
+	wg.Wait()
+	fmt.Println("Diff processing complete")
+}