package godump_test import ( "bytes" "fmt" "os" "testing" "unsafe" "github.com/yassinebenaid/godump" ) func TestCanDumpPrimitives(t *testing.T) { type IntType int type Int8Type int8 type Int16Type int16 type Int32Type int32 type Int64Type int64 type UintType uint type Uint8Type uint8 type Uint16Type uint16 type Uint32Type uint32 type Uint64Type uint64 type Float32Type float32 type Float64Type float64 type Complex64Type complex64 type Complex128Type complex128 type Bool1Type bool type Bool2Type bool type StringType string type UintptrType uintptr type IntPtrType *int type Int8PtrType *int8 type Int16PtrType *int16 type Int32PtrType *int32 type Int64PtrType *int64 type UintPtrType *uint type Uint8PtrType *uint8 type Uint16PtrType *uint16 type Uint32PtrType *uint32 type Uint64PtrType *uint64 type Float32PtrType *float32 type Float64PtrType *float64 type Complex64PtrType *complex64 type Complex128PtrType *complex128 type Bool1PtrType *bool type Bool2PtrType *bool type StringPtrType *string type UintptrPtrType *uintptr type FuncType func() type Func2Type func(int) float64 type Func3Type func(...*any) any type Func4Type func(byte, ...[]*complex128) bool type ChanType chan struct{} type Chan1Type <-chan struct{} type Chan2Type chan<- struct{} type UnsafePointer unsafe.Pointer type Node struct { Int int Int8 int8 Int16 int16 Int32 int32 Int64 int64 Uint uint Uint8 uint8 Uint16 uint16 Uint32 uint32 Uint64 uint64 Float32 float32 Float64 float64 Complex64 complex64 Complex128 complex128 Bool1 bool Bool2 bool String string Uintptr uintptr IntPtr *int Int8Ptr *int8 Int16Ptr *int16 Int32Ptr *int32 Int64Ptr *int64 UintPtr *uint Uint8Ptr *uint8 Uint16Ptr *uint16 Uint32Ptr *uint32 Uint64Ptr *uint64 Float32Ptr *float32 Float64Ptr *float64 Complex64Ptr *complex64 Complex128Ptr *complex128 Bool1Ptr *bool Bool2Ptr *bool StringPtr *string UintptrPtr *uintptr TypedInt IntType TypedInt8 Int8Type TypedInt16 Int16Type TypedInt32 Int32Type TypedInt64 Int64Type TypedUint UintType TypedUint8 Uint8Type TypedUint16 Uint16Type TypedUint32 Uint32Type TypedUint64 Uint64Type TypedFloat32 Float32Type TypedFloat64 Float64Type TypedComplex64 Complex64Type TypedComplex128 Complex128Type TypedBool1 Bool1Type TypedBool2 Bool2Type TypedString StringType TypedUintptr UintptrType TypedIntPtr IntPtrType TypedInt8Ptr Int8PtrType TypedInt16Ptr Int16PtrType TypedInt32Ptr Int32PtrType TypedInt64Ptr Int64PtrType TypedUintPtr UintPtrType TypedUint8Ptr Uint8PtrType TypedUint16Ptr Uint16PtrType TypedUint32Ptr Uint32PtrType TypedUint64Ptr Uint64PtrType TypedFloat32Ptr Float32PtrType TypedFloat64Ptr Float64PtrType TypedComplex64Ptr Complex64PtrType TypedComplex128Ptr Complex128PtrType TypedBool1Ptr Bool1PtrType TypedBool2Ptr Bool2PtrType TypedStringPtr StringPtrType TypedUintptrPtr UintptrPtrType PtrTypedInt *IntType PtrTypedInt8 *Int8Type PtrTypedInt16 *Int16Type PtrTypedInt32 *Int32Type PtrTypedInt64 *Int64Type PtrTypedUint *UintType PtrTypedUint8 *Uint8Type PtrTypedUint16 *Uint16Type PtrTypedUint32 *Uint32Type PtrTypedUint64 *Uint64Type PtrTypedFloat32 *Float32Type PtrTypedFloat64 *Float64Type PtrTypedComplex64 *Complex64Type PtrTypedComplex128 *Complex128Type PtrTypedBool1 *Bool1Type PtrTypedBool2 *Bool2Type PtrTypedString *StringType PtrTypedUintptr *UintptrType NilPointer *int Func func() Func2 func(int) float64 Func3 func(...*any) any Func4 func(byte, ...[]*complex128) bool FuncPtr *func() Func2Ptr *func(int) float64 Func3Ptr *func(...*any) any Func4Ptr *func(byte, ...[]*complex128) bool TypedFunc FuncType TypedFunc2 Func2Type TypedFunc3 Func3Type TypedFunc4 Func4Type PtrTypedFunc *FuncType PtrTypedFunc2 *Func2Type PtrTypedFunc3 *Func3Type PtrTypedFunc4 *Func4Type NilFunc func() Chan chan struct{} Chan1 <-chan struct{} Chan2 chan<- struct{} ChanPtr *chan struct{} Chan1Ptr *<-chan struct{} Chan2Ptr *chan<- struct{} TypedChan ChanType TypedChan1 Chan1Type TypedChan2 Chan2Type PtrTypedChan *ChanType PtrTypedChan1 *Chan1Type PtrTypedChan2 *Chan2Type BufferedChan chan struct{} NilChan chan struct{} UnsafePointer1 unsafe.Pointer UnsafePointer2 *unsafe.Pointer NamedUnsafePointer UnsafePointer } node := Node{ Int: 123, Int8: -45, Int16: 6789, Int32: -987, Int64: 3849876543247876432, Uint: 837, Uint8: 38, Uint16: 3847, Uint32: 9843, Uint64: 2834, Float32: 123.475, Float64: -12345.09876, Complex64: 12.987i, Complex128: -473i, Bool1: true, Bool2: false, String: "foo bar", Uintptr: 1234567890, TypedInt: IntType(123), TypedInt8: Int8Type(-45), TypedInt16: Int16Type(6789), TypedInt32: Int32Type(-987), TypedInt64: Int64Type(3849876543247876432), TypedUint: UintType(837), TypedUint8: Uint8Type(38), TypedUint16: Uint16Type(3847), TypedUint32: Uint32Type(9843), TypedUint64: Uint64Type(2834), TypedFloat32: Float32Type(123.475), TypedFloat64: Float64Type(-12345.09876), TypedComplex64: Complex64Type(12.987i), TypedComplex128: Complex128Type(-473i), TypedBool1: Bool1Type(true), TypedBool2: Bool2Type(false), TypedString: StringType("foo bar"), TypedUintptr: UintptrType(1234567890), UnsafePointer1: nil, NamedUnsafePointer: nil, Chan: make(chan struct{}), Chan1: make(chan struct{}), Chan2: make(chan struct{}), BufferedChan: make(chan struct{}, 255), } node.IntPtr = &node.Int node.Int8Ptr = &node.Int8 node.Int16Ptr = &node.Int16 node.Int32Ptr = &node.Int32 node.Int64Ptr = &node.Int64 node.UintPtr = &node.Uint node.Uint8Ptr = &node.Uint8 node.Uint16Ptr = &node.Uint16 node.Uint32Ptr = &node.Uint32 node.Uint64Ptr = &node.Uint64 node.Float32Ptr = &node.Float32 node.Float64Ptr = &node.Float64 node.Complex64Ptr = &node.Complex64 node.Complex128Ptr = &node.Complex128 node.Bool1Ptr = &node.Bool1 node.Bool2Ptr = &node.Bool2 node.StringPtr = &node.String node.UintptrPtr = &node.Uintptr node.TypedIntPtr = node.IntPtr node.TypedInt8Ptr = node.Int8Ptr node.TypedInt16Ptr = node.Int16Ptr node.TypedInt32Ptr = node.Int32Ptr node.TypedInt64Ptr = node.Int64Ptr node.TypedUintPtr = node.UintPtr node.TypedUint8Ptr = node.Uint8Ptr node.TypedUint16Ptr = node.Uint16Ptr node.TypedUint32Ptr = node.Uint32Ptr node.TypedUint64Ptr = node.Uint64Ptr node.TypedFloat32Ptr = node.Float32Ptr node.TypedFloat64Ptr = node.Float64Ptr node.TypedComplex64Ptr = node.Complex64Ptr node.TypedComplex128Ptr = node.Complex128Ptr node.TypedBool1Ptr = node.Bool1Ptr node.TypedBool2Ptr = node.Bool2Ptr node.TypedStringPtr = node.StringPtr node.TypedUintptrPtr = node.UintptrPtr node.PtrTypedInt = &node.TypedInt node.PtrTypedInt8 = &node.TypedInt8 node.PtrTypedInt16 = &node.TypedInt16 node.PtrTypedInt32 = &node.TypedInt32 node.PtrTypedInt64 = &node.TypedInt64 node.PtrTypedUint = &node.TypedUint node.PtrTypedUint8 = &node.TypedUint8 node.PtrTypedUint16 = &node.TypedUint16 node.PtrTypedUint32 = &node.TypedUint32 node.PtrTypedUint64 = &node.TypedUint64 node.PtrTypedFloat32 = &node.TypedFloat32 node.PtrTypedFloat64 = &node.TypedFloat64 node.PtrTypedComplex64 = &node.TypedComplex64 node.PtrTypedComplex128 = &node.TypedComplex128 node.PtrTypedBool1 = &node.TypedBool1 node.PtrTypedBool2 = &node.TypedBool2 node.PtrTypedString = &node.TypedString node.PtrTypedUintptr = &node.TypedUintptr node.Func = func() {} node.Func2 = func(int) float64 { return 0 } node.Func3 = func(...*any) any { return nil } node.Func4 = func(byte, ...[]*complex128) bool { return false } node.TypedFunc = func() {} node.TypedFunc2 = func(int) float64 { return 0 } node.TypedFunc3 = func(...*any) any { return nil } node.TypedFunc4 = func(byte, ...[]*complex128) bool { return false } node.FuncPtr = &node.Func node.Func2Ptr = &node.Func2 node.Func3Ptr = &node.Func3 node.Func4Ptr = &node.Func4 node.PtrTypedFunc = &node.TypedFunc node.PtrTypedFunc2 = &node.TypedFunc2 node.PtrTypedFunc3 = &node.TypedFunc3 node.PtrTypedFunc4 = &node.TypedFunc4 ch := make(chan struct{}) var ch2 <-chan struct{} = ch var ch3 chan<- struct{} = ch tch := ChanType(ch) tch1 := Chan1Type(ch2) tch2 := Chan2Type(ch3) node.ChanPtr = &ch node.Chan1Ptr = &ch2 node.Chan2Ptr = &ch3 node.TypedChan = ch node.TypedChan1 = ch2 node.TypedChan2 = ch3 node.PtrTypedChan = &tch node.PtrTypedChan1 = &tch1 node.PtrTypedChan2 = &tch2 node.UnsafePointer2 = (*unsafe.Pointer)(unsafe.Pointer(&node)) var d godump.Dumper result := d.Sprint(node) checkFromFeed(t, []byte(result), "./testdata/primitives.txt") } func TestCanDumpNamedPrimitives(t *testing.T) { type IntType int type Int8Type int8 type Int16Type int16 type Int32Type int32 type Int64Type int64 type UintType uint type Uint8Type uint8 type Uint16Type uint16 type Uint32Type uint32 type Uint64Type uint64 type Float32Type float32 type Float64Type float64 type Complex64Type complex64 type Complex128Type complex128 type Bool1Type bool type Bool2Type bool type StringType string type UintptrType uintptr type Node struct { Int IntType Int8 Int8Type Int16 Int16Type Int32 Int32Type Int64 Int64Type Uint UintType Uint8 Uint8Type Uint16 Uint16Type Uint32 Uint32Type Uint64 Uint64Type Float32 Float32Type Float64 Float64Type Complex64 Complex64Type Complex128 Complex128Type Bool1 Bool1Type Bool2 Bool2Type String StringType Uintptr UintptrType PtrInt *IntType PtrInt8 *Int8Type PtrInt16 *Int16Type PtrInt32 *Int32Type PtrInt64 *Int64Type PtrUint *UintType PtrUint8 *Uint8Type PtrUint16 *Uint16Type PtrUint32 *Uint32Type PtrUint64 *Uint64Type PtrFloat32 *Float32Type PtrFloat64 *Float64Type PtrComplex64 *Complex64Type PtrComplex128 *Complex128Type PtrBool1 *Bool1Type PtrBool2 *Bool2Type PtrString *StringType PtrUintptr *UintptrType } node := Node{ Int: IntType(123), Int8: Int8Type(-45), Int16: Int16Type(6789), Int32: Int32Type(-987), Int64: Int64Type(3849876543247876432), Uint: UintType(837), Uint8: Uint8Type(38), Uint16: Uint16Type(3847), Uint32: Uint32Type(9843), Uint64: Uint64Type(2834), Float32: Float32Type(123.475), Float64: Float64Type(-12345.09876), Complex64: Complex64Type(12.987i), Complex128: Complex128Type(-473i), Bool1: Bool1Type(true), Bool2: Bool2Type(false), String: StringType("foo bar"), Uintptr: UintptrType(1234567890), } node.PtrInt = &node.Int node.PtrInt8 = &node.Int8 node.PtrInt16 = &node.Int16 node.PtrInt32 = &node.Int32 node.PtrInt64 = &node.Int64 node.PtrUint = &node.Uint node.PtrUint8 = &node.Uint8 node.PtrUint16 = &node.Uint16 node.PtrUint32 = &node.Uint32 node.PtrUint64 = &node.Uint64 node.PtrFloat32 = &node.Float32 node.PtrFloat64 = &node.Float64 node.PtrComplex64 = &node.Complex64 node.PtrComplex128 = &node.Complex128 node.PtrBool1 = &node.Bool1 node.PtrBool2 = &node.Bool2 node.PtrString = &node.String node.PtrUintptr = &node.Uintptr var d godump.Dumper d.ShowPrimitiveNamedTypes = true result := d.Sprint(node) checkFromFeed(t, []byte(result), "./testdata/named-primitives.txt") } func TestCanDumpStructs(t *testing.T) { type Number int type Child1 struct { X int Y float64 Z Number } type Child struct { Field1 Child1 Field2 *Child } type Node struct { Inline struct { Field1 struct { X int Y float64 Z Number } Field2 Child } Typed Child Ptr **int Empty struct{} Ref *Node } num := 123 numaddr := &num node := Node{ Inline: struct { Field1 struct { X int Y float64 Z Number } Field2 Child }{ Field1: struct { X int Y float64 Z Number }{ X: 123, Y: 123.456, Z: Number(987), }, Field2: Child{ Field1: Child1{ X: 12344, Y: 578, Z: Number(9876543), }, Field2: &Child{ Field1: Child1{ X: 12344, Y: 578, Z: Number(9876543), }, }, }, }, Ptr: &numaddr, } node.Inline.Field2.Field2.Field2 = node.Inline.Field2.Field2 node.Typed.Field2 = &node.Inline.Field2 node.Ref = &node var d godump.Dumper result := d.Sprint(node) checkFromFeed(t, []byte(result), "./testdata/structs.txt") } func TestCannotDumpPrivateStructsWhenHidingOptionIsEnabled(t *testing.T) { type number int type child1 struct { x int y float64 z number } type child struct { field1 child1 field2 *child } type node struct { inline struct { field1 struct { x int y float64 z number } field2 child } typed child empty struct{} ref *node } n := node{ inline: struct { field1 struct { x int y float64 z number } field2 child }{ field1: struct { x int y float64 z number }{ x: 123, y: 123.456, z: number(987), }, field2: child{ field1: child1{ x: 12344, y: 578, z: number(9876543), }, field2: &child{ field1: child1{ x: 12344, y: 578, z: number(9876543), }, }, }, }, empty: struct{}{}, } n.inline.field2.field2.field2 = n.inline.field2.field2 n.typed.field2 = &n.inline.field2 n.ref = &n var d godump.Dumper d.HidePrivateFields = true result := d.Sprint(n) if result != "godump_test.node {}" { t.Fatalf("unexpected result when trying to dump a private struct with hide private fields option enabled, expected `godump.node {}`, got `%v`", result) } } func TestCanDumpPrivateStructs(t *testing.T) { type number int type child1 struct { x int y float64 z number } type child struct { field1 child1 field2 *child } type node struct { inline struct { field1 struct { x int y float64 z number } field2 child } typed child empty struct{} ref *node } n := node{ inline: struct { field1 struct { x int y float64 z number } field2 child }{ field1: struct { x int y float64 z number }{ x: 123, y: 123.456, z: number(987), }, field2: child{ field1: child1{ x: 12344, y: 578, z: number(9876543), }, field2: &child{ field1: child1{ x: 12344, y: 578, z: number(9876543), }, }, }, }, empty: struct{}{}, } n.inline.field2.field2.field2 = n.inline.field2.field2 n.typed.field2 = &n.inline.field2 n.ref = &n var d godump.Dumper result := d.Sprint(n) checkFromFeed(t, []byte(result), "./testdata/private-structs.txt") } func TestCanDumpSlices(t *testing.T) { type Slice []any var nilSlice []Slice var zeroArray [2]any foo := "foo" bar := "bar" baz := "baz" s := Slice{ 1, 2.3, true, false, nil, []*string{ &foo, &bar, &baz, }, []any{}, &[]bool{ true, false, }, make([]any, 3, 8), nilSlice, [2]int{1, 2}, zeroArray, } s = append(s, &s) var d godump.Dumper result := d.Sprint(s) checkFromFeed(t, []byte(result), "./testdata/slices.txt") } func TestCanDumpMaps(t *testing.T) { type SomeMap map[*SomeMap]*SomeMap sm := &SomeMap{} var nilMap SomeMap m := map[any]any{12: 34} maps := []any{ make(map[string]string), map[any]int{ &m: 123, }, map[string]any{ "cyclic": &m, }, SomeMap{ &SomeMap{}: &SomeMap{sm: sm}, }, nilMap, } var d godump.Dumper result := d.Sprint(maps) checkFromFeed(t, []byte(result), "./testdata/maps.txt") } func TestCanCustomizeIndentation(t *testing.T) { type User struct { Name string Age int hobbies []string bestFriend *User } me := User{ Name: "yassinebenaid", Age: 22, hobbies: []string{ "Dev", "Go", "Web", "DevOps", }, } me.bestFriend = &me d := godump.Dumper{ Indentation: " ", } result := d.Sprint(me) checkFromFeed(t, []byte(result), "./testdata/indentation.txt") } type CSSColor struct { R, G, B int } func (c CSSColor) Apply(s string) string { return fmt.Sprintf(`
%s
`, c.R, c.G, c.B, s) } func TestCanCustomizeTheme(t *testing.T) { type User struct { Name string Age int hobbies []string bestFriend *User } me := User{ Name: "yassinebenaid", Age: 22, hobbies: []string{ "Dev", "Go", "Web", "DevOps", }, } me.bestFriend = &me var d godump.Dumper d.Theme = godump.Theme{ String: CSSColor{138, 201, 38}, Quotes: CSSColor{112, 214, 255}, Bool: CSSColor{249, 87, 56}, Number: CSSColor{10, 178, 242}, Types: CSSColor{0, 150, 199}, Address: CSSColor{205, 93, 0}, PointerTag: CSSColor{110, 110, 110}, Nil: CSSColor{219, 57, 26}, Func: CSSColor{160, 90, 220}, Fields: CSSColor{189, 176, 194}, Chan: CSSColor{195, 154, 76}, UnsafePointer: CSSColor{89, 193, 180}, Braces: CSSColor{185, 86, 86}, } result := d.Sprint(me) checkFromFeed(t, []byte(result), "./testdata/theme.txt") } func TestDumperPrint_Sprint_And_Fprint(t *testing.T) { type User struct { Name string Age int hobbies []string } me := User{ Name: "yassinebenaid", Age: 22, hobbies: []string{ "Dev", "Go", "Web", "DevOps", }, } expected := `godump_test.User { Name: "yassinebenaid", Age: 22, hobbies: []string:4:4 { "Dev", "Go", "Web", "DevOps", }, }` var d godump.Dumper if r := d.Sprint(me); expected != r { t.Fatalf("unexpected result by Dumper.Sprint : `%s`", r) } if r := d.Sprintln(me); expected+"\n" != r { t.Fatalf("unexpected result by Dumper.Sprintln : `%s`", r) } var buf bytes.Buffer if err := d.Fprint(&buf, me); err != nil { t.Fatalf("unexpected error by Dumper.Fprint : `%s`", err) } else if expected != buf.String() { t.Fatalf("unexpected result by Dumper.Fprint : `%s`", buf.String()) } buf.Reset() if err := d.Fprintln(&buf, me); err != nil { t.Fatalf("unexpected error by Dumper.Fprintln : `%s`", err) } else if expected+"\n" != buf.String() { t.Fatalf("unexpected result by Dumper.Fprintln : `%s`", buf.String()) } } type X int func (X) Write(_ []byte) (n int, err error) { return 0, fmt.Errorf("foobar") } func TestDumperFprintReturnsAWriteErrorIfEncountered(t *testing.T) { var d godump.Dumper var x X if err := d.Fprint(x, nil); err == nil { t.Fatalf("unexpected nil error returned by Dumper.Fprint") } else if err.Error() != "dumper error: encountered unexpected write error, foobar" { t.Fatalf("unexpected error by Dumper.Fprint : `%s`", err.Error()) } if err := d.Fprintln(x, nil); err == nil { t.Fatalf("unexpected nil error returned by Dumper.Fprintln") } else if err.Error() != "dumper error: encountered unexpected write error, foobar" { t.Fatalf("unexpected error by Dumper.Fprintln : `%s`", err.Error()) } } func TestDump(t *testing.T) { if err := godump.Dump(nil); err != nil { t.Fatalf("unexpected error returned by Dump") } } func checkFromFeed(t *testing.T, result []byte, feedPath string) { t.Helper() expectedOutput, err := os.ReadFile(feedPath) if err != nil { t.Fatal(err) } resultLines := bytes.Split(result, []byte("\n")) expectedLines := bytes.Split(expectedOutput, []byte("\n")) if len(resultLines) != len(expectedLines) { t.Fatalf("expected %d lines, got %d", len(expectedLines), len(resultLines)) } for i, line := range expectedLines { if string(line) != string(resultLines[i]) { t.Fatalf(`mismatch at line %d: --- "%s" (%d) +++ "%s" (%d)`, i+1, line, len(line), resultLines[i], len(resultLines[i])) } } }