Merge branch 'master' into add-python-abi3

Author: K0lb3

.gitattributes

@@ -33,6 +33,10 @@ docs/brotli-comparison-study-2015-09-22.pdf export-ignore
 python !export-ignore
 python/** !export-ignore
 
+# Add go bindings + tests
+go !export-ignore
+go/** !export-ignore
+
 # Add more build files.
 scripts !export-ignore
 scripts/download_testdata.sh !export-ignore

.github/workflows/build_test.yml

@@ -106,7 +106,7 @@ jobs:
             python_version: "3.10"
             # TODO: investigate why win-builds can't run tests
             py_setuptools_cmd: build_ext
-            os: windows-2019
+            os: windows-2022
 
           - name: maven
             build_system: maven
@@ -152,7 +152,7 @@ jobs:
             bazel_project: .
             os: windows-latest
 
-          # TODO: use single dll on windows, otherwise it fails to link
+          # TODO(eustas): restore when go is fixed
           #- name: bazel-win:go
           #  build_system: bazel
           #  bazel_project: go

go/BUILD.bazel

@@ -1,2 +1,3 @@
 # Description:
+#   brotli is a pure Go implementation of Brotli decoder.
 #   cbrotli is a CGo wrapper for Brotli, a generic-purpose lossless compression algorithm.

go/brotli/BUILD.bazel

@@ -0,0 +1,31 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])  # MIT
+
+go_library(
+    name = "brotli",
+    srcs = [
+        "decode.go",
+        "reader.go",
+    ],
+    importpath = "github.com/google/brotli/go/brotli",
+)
+
+go_test(
+    name = "brotli_test",
+    size = "small",
+    srcs = ["brotli_test.go"],
+    deps = [
+        ":brotli",
+        "//cbrotli",
+    ],
+)
+
+go_test(
+    name = "synth_test",
+    size = "small",
+    srcs = ["synth_test.go"],
+    deps = [":brotli"],
+)

go/brotli/brotli_test.go

@@ -0,0 +1,174 @@
+// Copyright 2025 Google Inc. All Rights Reserved.
+//
+// Distributed under MIT license.
+// See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+
+package brotli_test
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"math/rand"
+	"testing"
+
+	"github.com/google/brotli/go/brotli"
+	"github.com/google/brotli/go/cbrotli"
+)
+
+func TestReader(t *testing.T) {
+	content := bytes.Repeat([]byte("hello world!"), 10000)
+	encoded, _ := cbrotli.Encode(content, cbrotli.WriterOptions{Quality: 5})
+	r := brotli.NewReader(bytes.NewReader(encoded))
+	var decodedOutput bytes.Buffer
+	n, err := io.Copy(&decodedOutput, r)
+	if err != nil {
+		t.Fatalf("Copy(): n=%v, err=%v", n, err)
+	}
+	if err := r.Close(); err != nil {
+		t.Errorf("Close(): %v", err)
+	}
+	if got := decodedOutput.Bytes(); !bytes.Equal(got, content) {
+		t.Errorf(""+
+			"Reader output:\n"+
+			"%q\n"+
+			"want:\n"+
+			"<%d bytes>",
+			got, len(content))
+	}
+	buf := make([]byte, 4)
+	if _, err := r.Read(buf); err == nil {
+		t.Errorf("Read-after-Close expected to return error")
+	}
+}
+
+func TestDecode(t *testing.T) {
+	content := bytes.Repeat([]byte("hello world!"), 10000)
+	encoded, _ := cbrotli.Encode(content, cbrotli.WriterOptions{Quality: 5})
+	decoded, err := brotli.Decode(encoded)
+	if err != nil {
+		t.Errorf("Decode: %v", err)
+	}
+	if !bytes.Equal(decoded, content) {
+		t.Errorf(""+
+			"Decode content:\n"+
+			"%q\n"+
+			"want:\n"+
+			"<%d bytes>",
+			decoded, len(content))
+	}
+}
+
+func TestDecodeFuzz(t *testing.T) {
+	// Test that the decoder terminates with corrupted input.
+	content := bytes.Repeat([]byte("hello world!"), 100)
+	src := rand.NewSource(0)
+	encoded, err := cbrotli.Encode(content, cbrotli.WriterOptions{Quality: 5})
+	if err != nil {
+		t.Fatalf("Encode(<%d bytes>, _) = _, %s", len(content), err)
+	}
+	if len(encoded) == 0 {
+		t.Fatalf("Encode(<%d bytes>, _) produced empty output", len(content))
+	}
+	for i := 0; i < 100; i++ {
+		enc := append([]byte{}, encoded...)
+		for j := 0; j < 5; j++ {
+			enc[int(src.Int63())%len(enc)] = byte(src.Int63() % 256)
+		}
+		brotli.Decode(enc)
+	}
+}
+
+func TestDecodeTrailingData(t *testing.T) {
+	content := bytes.Repeat([]byte("hello world!"), 100)
+	encoded, _ := cbrotli.Encode(content, cbrotli.WriterOptions{Quality: 5})
+	_, err := brotli.Decode(append(encoded, 0))
+	if err == nil {
+		t.Errorf("Expected 'excessive input' error")
+	}
+}
+
+func TestEncodeDecode(t *testing.T) {
+	for _, test := range []struct {
+		data    []byte
+		repeats int
+	}{
+		{nil, 0},
+		{[]byte("A"), 1},
+		{[]byte("<html><body><H1>Hello world</H1></body></html>"), 10},
+		{[]byte("<html><body><H1>Hello world</H1></body></html>"), 1000},
+	} {
+		t.Logf("case %q x %d", test.data, test.repeats)
+		input := bytes.Repeat(test.data, test.repeats)
+		encoded, err := cbrotli.Encode(input, cbrotli.WriterOptions{Quality: 5})
+		if err != nil {
+			t.Errorf("Encode: %v", err)
+		}
+		// Inputs are compressible, but may be too small to compress.
+		if maxSize := len(input)/2 + 20; len(encoded) >= maxSize {
+			t.Errorf(""+
+				"Encode returned %d bytes, want <%d\n"+
+				"Encoded=%q",
+				len(encoded), maxSize, encoded)
+		}
+		decoded, err := brotli.Decode(encoded)
+		if err != nil {
+			t.Errorf("Decode: %v", err)
+		}
+		if !bytes.Equal(decoded, input) {
+			var want string
+			if len(input) > 320 {
+				want = fmt.Sprintf("<%d bytes>", len(input))
+			} else {
+				want = fmt.Sprintf("%q", input)
+			}
+			t.Errorf(""+
+				"Decode content:\n"+
+				"%q\n"+
+				"want:\n"+
+				"%s",
+				decoded, want)
+		}
+	}
+}
+
+func TestEncodeDecodeWithDictionary(t *testing.T) {
+	q := 5
+	l := 4096
+
+	input := make([]byte, l)
+	for i := 0; i < l; i++ {
+		input[i] = byte(i*7 + i*i*5)
+	}
+	// use dictionary same as input
+	pd := cbrotli.NewPreparedDictionary(input, cbrotli.DtRaw, q)
+	defer pd.Close()
+
+	encoded, err := cbrotli.Encode(input, cbrotli.WriterOptions{Quality: q, Dictionary: pd})
+	if err != nil {
+		t.Errorf("Encode: %v", err)
+	}
+	limit := 20
+	if len(encoded) > limit {
+		t.Errorf("Output length exceeds expectations: %d > %d", len(encoded), limit)
+	}
+
+	decoded, err := brotli.DecodeWithRawDictionary(encoded, input)
+	if err != nil {
+		t.Errorf("Decode: %v", err)
+	}
+	if !bytes.Equal(decoded, input) {
+		var want string
+		if len(input) > 320 {
+			want = fmt.Sprintf("<%d bytes>", len(input))
+		} else {
+			want = fmt.Sprintf("%q", input)
+		}
+		t.Errorf(""+
+			"Decode content:\n"+
+			"%q\n"+
+			"want:\n"+
+			"%s",
+			decoded, want)
+	}
+}