refactor: get rid of unnecessary dep

Author: xiaost

.github/CODEOWNERS

@@ -2,15 +2,6 @@ module github.com/cloudwego/frugal
 
 go 1.20
 
-require (
-	github.com/cloudwego/gopkg v0.1.2
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
-	github.com/stretchr/testify v1.9.0
-)
+require github.com/cloudwego/gopkg v0.2.0
 
-require (
-	github.com/bytedance/gopkg v0.1.1 // indirect
-	github.com/kr/text v0.2.0 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)
+require github.com/bytedance/gopkg v0.1.4 // indirect

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,18 +1,4 @@
-github.com/bytedance/gopkg v0.1.1 h1:3azzgSkiaw79u24a+w9arfH8OfnQQ4MHUt9lJFREEaE=
-github.com/bytedance/gopkg v0.1.1/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
-github.com/cloudwego/gopkg v0.1.2 h1:650t+RiZGht8qX+y0hl49JXJCuO44GhbGZuxDzr2PyI=
-github.com/cloudwego/gopkg v0.1.2/go.mod h1:WoNTdXDPdvL97cBmRUWXVGkh2l2UFmpd9BUvbW2r0Aw=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
-github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+github.com/bytedance/gopkg v0.1.4 h1:oZnQwnX82KAIWb7033bEwtxvTqXcYMxDBaQxo5JJHWM=
+github.com/bytedance/gopkg v0.1.4/go.mod h1:v1zWfPm21Fb+OsyXN2VAHdL6TBb2L88anLQgdyje6R4=
+github.com/cloudwego/gopkg v0.2.0 h1:EU8Ahrj0rCfKZQdah50zKnlrQ1o2AdPYM87UclIqLME=
+github.com/cloudwego/gopkg v0.2.0/go.mod h1:WjQPYI8PesfQalIVcLzVJBb1EAopioZ+D+3UGJ+dNBs=

go.mod

@@ -0,0 +1,104 @@
+// Copyright 2025 CloudWeGo Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package assert provides minimal test assertion helpers.
+// All functions stop the test immediately on failure (t.Fatalf).
+//
+// Design: keep this package small — avoid adding new functions unless
+// there is a clear need that cannot be covered by the existing ones.
+// Prefer: Equal for comparable types, BytesEqual for []byte,
+// DeepEqual for structs/maps/slices, True for boolean conditions,
+// and Nil for nil checks.
+package assert
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+// Equal asserts that two comparable values are equal using ==.
+func Equal[T comparable](t testing.TB, expected, actual T, a ...any) {
+	if expected != actual {
+		t.Helper()
+		t.Fatalf("expected %#v, got %#v%s", expected, actual, fmtInputs(a))
+	}
+}
+
+// BytesEqual asserts that two byte slices are equal.
+// On failure it reports the length mismatch or the first differing byte,
+// avoiding logging raw byte slices which can be large and unreadable.
+func BytesEqual(t testing.TB, expected, actual []byte, a ...any) {
+	if bytes.Equal(expected, actual) {
+		return
+	}
+	t.Helper()
+	if len(expected) != len(actual) {
+		t.Fatalf("bytes differ in length: expected %d, got %d%s", len(expected), len(actual), fmtInputs(a))
+		return
+	}
+	for i := range expected {
+		if expected[i] != actual[i] {
+			t.Fatalf("bytes differ at [%d]: expected 0x%02x, got 0x%02x%s", i, expected[i], actual[i], fmtInputs(a))
+			return
+		}
+	}
+}
+
+// DeepEqual asserts that two values are deeply equal using reflect.DeepEqual.
+// Use for structs, maps, and non-byte slices. Use BytesEqual for []byte.
+func DeepEqual(t testing.TB, expected, actual any, a ...any) {
+	if !reflect.DeepEqual(expected, actual) {
+		t.Helper()
+		t.Fatalf("expected %#v, got %#v%s", expected, actual, fmtInputs(a))
+	}
+}
+
+// True asserts that cond is true.
+func True(t testing.TB, cond bool, a ...any) {
+	if !cond {
+		t.Helper()
+		t.Fatalf("expected true%s", fmtInputs(a))
+	}
+}
+
+// Nil asserts that v is nil. Uses reflect to handle typed nils (e.g. (*T)(nil)).
+func Nil(t testing.TB, v any, a ...any) {
+	if !isNil(v) {
+		t.Helper()
+		t.Fatalf("expected nil, got: %v%s", v, fmtInputs(a))
+	}
+}
+
+func isNil(v any) bool {
+	if v == nil {
+		return true
+	}
+	rv := reflect.ValueOf(v)
+	switch rv.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return rv.IsNil()
+	case reflect.UnsafePointer:
+		return rv.Pointer() == 0
+	}
+	return false
+}
+
+func fmtInputs(a []any) string {
+	if len(a) == 0 {
+		return ""
+	}
+	return ": " + fmt.Sprint(a...)
+}

go.sum

@@ -0,0 +1,118 @@
+// Copyright 2025 CloudWeGo Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package assert
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+	"unsafe"
+)
+
+// mockT captures Fatalf calls without stopping execution.
+type mockT struct {
+	testing.TB // embed to satisfy interface; only Helper/Fatalf are called
+	msg        string
+}
+
+func (m *mockT) Helper()                   {}
+func (m *mockT) Fatalf(f string, a ...any) { m.msg = fmt.Sprintf(f, a...) }
+func (m *mockT) failed() bool              { return m.msg != "" }
+
+func TestEqual(t *testing.T) {
+	m := &mockT{}
+	Equal(m, 1, 1)
+	True(t, !m.failed())
+
+	Equal(m, 1, 2)
+	True(t, m.failed())
+}
+
+func TestBytesEqual(t *testing.T) {
+	m := &mockT{}
+
+	BytesEqual(m, []byte("abc"), []byte("abc"))
+	True(t, !m.failed())
+
+	// length diff
+	BytesEqual(m, []byte("ab"), []byte("abc"))
+	True(t, strings.Contains(m.msg, "length"))
+
+	// content diff
+	m.msg = ""
+	BytesEqual(m, []byte{0x01, 0x02}, []byte{0x01, 0x03})
+	True(t, strings.Contains(m.msg, "[1]"))
+	True(t, strings.Contains(m.msg, "0x02"))
+	True(t, strings.Contains(m.msg, "0x03"))
+}
+
+func TestDeepEqual(t *testing.T) {
+	m := &mockT{}
+
+	DeepEqual(m, []int{1, 2}, []int{1, 2})
+	True(t, !m.failed())
+
+	DeepEqual(m, []int{1, 2}, []int{1, 3})
+	True(t, m.failed())
+}
+
+func TestTrue(t *testing.T) {
+	m := &mockT{}
+
+	True(m, true)
+	True(t, !m.failed())
+
+	True(m, false)
+	True(t, m.failed())
+}
+
+func TestNil(t *testing.T) {
+	m := &mockT{}
+
+	// untyped nil
+	Nil(m, nil)
+	True(t, !m.failed())
+
+	// typed nil pointer
+	var p *int
+	Nil(m, p)
+	True(t, !m.failed())
+
+	// typed nil slice
+	var s []byte
+	Nil(m, s)
+	True(t, !m.failed())
+
+	// typed nil map
+	var mp map[string]int
+	Nil(m, mp)
+	True(t, !m.failed())
+
+	// unsafe.Pointer nil
+	Nil(m, unsafe.Pointer(nil))
+	True(t, !m.failed())
+
+	// non-nil value should fail
+	x := 42
+	Nil(m, &x)
+	True(t, m.failed())
+}
+
+func TestFmtInputs(t *testing.T) {
+	m := &mockT{}
+
+	Equal(m, 1, 2, "context", "info")
+	True(t, strings.Contains(m.msg, "context"))
+}

internal/assert/assert.go

@@ -21,8 +21,7 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/davecgh/go-spew/spew"
-	"github.com/stretchr/testify/require"
+	"github.com/cloudwego/frugal/internal/assert"
 )
 
 type CtorTestStruct struct {
@@ -42,9 +41,7 @@ func (p *CtorTestStruct) InitDefault() {
 func TestDefaults_Resolve(t *testing.T) {
 	fp := (*CtorTestStruct).InitDefault
 	fa := **(**unsafe.Pointer)(unsafe.Pointer(&fp))
-	spew.Dump(fa)
 	fn, err := GetDefaultInitializer(reflect.TypeOf(CtorTestStruct{}))
-	require.NoError(t, err)
-	spew.Dump(fn)
-	require.Equal(t, fa, fn)
+	assert.Nil(t, err)
+	assert.Equal(t, fa, fn)
 }

internal/assert/assert_test.go

@@ -18,10 +18,10 @@ package defs
 
 import (
 	"reflect"
+	"strings"
 	"testing"
 
-	"github.com/davecgh/go-spew/spew"
-	"github.com/stretchr/testify/require"
+	"github.com/cloudwego/frugal/internal/assert"
 )
 
 type NoCopyStringFields struct {
@@ -35,10 +35,8 @@ type NoCopyStringFields struct {
 func TestResolver_StringOptions(t *testing.T) {
 	var vv NoCopyStringFields
 	ret, err := ResolveFields(reflect.TypeOf(vv))
-	require.NoError(t, err)
-	spew.Config.SortKeys = true
-	spew.Config.DisablePointerMethods = true
-	spew.Dump(ret)
+	assert.Nil(t, err)
+	assert.Equal(t, 5, len(ret))
 }
 
 func TestLookupStructTag(t *testing.T) {
@@ -83,8 +81,8 @@ func TestLookupStructTag(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			result, ok := lookupStructTag(tt.tag)
-			require.Equal(t, tt.ok, ok)
-			require.Equal(t, tt.expected, result)
+			assert.Equal(t, tt.ok, ok)
+			assert.DeepEqual(t, tt.expected, result)
 		})
 	}
 }
@@ -103,17 +101,17 @@ type DuplicateIDFields struct {
 func TestResolveFields_ThriftTagRequiredness(t *testing.T) {
 	var vv ThriftTagFields
 	ret, err := ResolveFields(reflect.TypeOf(vv))
-	require.NoError(t, err)
-	require.Len(t, ret, 3)
+	assert.Nil(t, err)
+	assert.Equal(t, 3, len(ret))
 
-	require.Equal(t, Required, ret[0].Spec)
-	require.Equal(t, Default, ret[1].Spec)
-	require.Equal(t, Optional, ret[2].Spec)
+	assert.Equal(t, Required, ret[0].Spec)
+	assert.Equal(t, Default, ret[1].Spec)
+	assert.Equal(t, Optional, ret[2].Spec)
 }
 
 func TestResolveFields_DuplicateID(t *testing.T) {
 	var vv DuplicateIDFields
 	_, err := ResolveFields(reflect.TypeOf(vv))
-	require.Error(t, err)
-	require.Contains(t, err.Error(), "duplicated field ID 1")
+	assert.True(t, err != nil)
+	assert.True(t, strings.Contains(err.Error(), "duplicated field ID 1"))
 }