jcarr
/
go-spew
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
go-spew/dump_test.go

1043 lines
33 KiB
Go
Raw Permalink Normal View History

Initial implementation.
2013-01-08 23:35:50 -06:00
/*
Update license copyright years. Several files had been updated since the listed years. This updates them accordingly.
2016-10-29 15:38:27 -05:00
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
Initial implementation.
2013-01-08 23:35:50 -06:00
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
Test Summary:
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
NOTE: For each test, a nil pointer, a single pointer and double pointer to the
base test element are also tested to ensure proper indirection across all types.
Initial implementation.
2013-01-08 23:35:50 -06:00
- Max int8, int16, int32, int64, int
- Max uint8, uint16, uint32, uint64, uint
- Boolean true and false
- Standard complex64 and complex128
- Array containing standard ints
- Array containing type with custom formatter on pointer receiver only
Update test summaries.
2013-01-17 21:40:54 -06:00
- Array containing interfaces
Add tests for byte arrays and slices. This commit adds tests for the new byte array and slice hexdump functionality as specified in issue #9.
2013-03-08 22:20:54 -06:00
- Array containing bytes
Initial implementation.
2013-01-08 23:35:50 -06:00
- Slice containing standard float32 values
- Slice containing type with custom formatter on pointer receiver only
Update test summaries.
2013-01-17 21:40:54 -06:00
- Slice containing interfaces
Add tests for byte arrays and slices. This commit adds tests for the new byte array and slice hexdump functionality as specified in issue #9.
2013-03-08 22:20:54 -06:00
- Slice containing bytes
Add tests for nil slice change. This commit adds tests for the nil slice change.
2013-09-09 20:42:50 -05:00
- Nil slice
Initial implementation.
2013-01-08 23:35:50 -06:00
- Standard string
- Nil interface
Add tests for sub-interfaces.
2013-01-20 15:27:57 -06:00
- Sub-interface
Initial implementation.
2013-01-08 23:35:50 -06:00
- Map with string keys and int vals
- Map with custom formatter type on pointer receiver only keys and vals
- Map with interface keys and values
Add tests for packed nil interfaces. This commit adds tests for nil interfaces packed inside maps and slices to test the recently added fix for issue #12.
2013-03-27 22:44:40 -05:00
- Map with nil interface value
Initial implementation.
2013-01-08 23:35:50 -06:00
- Struct with primitives
- Struct that contains another struct
- Struct that contains custom type with Stringer pointer interface via both
exported and unexported fields
Add tests for structs with multiple equiv fields. This commit adds tests for a struct which has an embedded struct pointer and a field that is a pointer to the same object. This ensures the cycle detection is properly reset between fields.
2013-01-20 19:55:55 -06:00
- Struct that contains embedded struct and field to same struct
Initial implementation.
2013-01-08 23:35:50 -06:00
- Uintptr to 0 (null pointer)
- Uintptr address of real variable
- Unsafe.Pointer to 0 (null pointer)
- Unsafe.Pointer to address of real variable
- Nil channel
- Standard int channel
- Function with no params and no returns
- Function with param and no returns
- Function with multiple params and multiple returns
- Struct that is circular through self referencing
- Structs that are circular through cross referencing
- Structs that are indirectly circular
Add tests for custom type that panics in Stringer.
2013-01-20 12:31:42 -06:00
- Type that panics in its Stringer interface
Initial implementation.
2013-01-08 23:35:50 -06:00
*/
package spew_test
import (
"bytes"
"fmt"
"testing"
"unsafe"
Enable methods to sort map keys and spew itself as last resort If enabled by flags, try to use methods to stringify map keys and sort on that. If we can't use primitive sorting and we can't use methods, we can still fall back on spew itself. If SpewKeys is enabled, use Sprintf("%#v") to generate a string and sort by that.
2015-03-31 15:55:04 -05:00
flatten paths Signed-off-by: Jeff Carr <jcarr@wit.com>
2024-01-14 12:21:06 -06:00
"go.wit.com/dev/davecgh/spew"
Initial implementation.
2013-01-08 23:35:50 -06:00
)
Correct a copy of misspellings found by misspell.
2016-10-29 15:57:26 -05:00
// dumpTest is used to describe a test to be performed against the Dump method.
Initial implementation.
2013-01-08 23:35:50 -06:00
type dumpTest struct {
Add tests for maps with multiple entries. Previously, the tests did not include maps with more than a single entry since the iteration order is randomized and the tests only accepted a single valid expected value. This commit modifies the tests to accept multiple valid expected values and adds tests for a multi-entry map to both Dump and Formatter.
2013-01-20 12:02:36 -06:00
in interface{}
wants []string
Initial implementation.
2013-01-08 23:35:50 -06:00
}
// dumpTests houses all of the tests to be performed against the Dump method.
var dumpTests = make([]dumpTest, 0)
// addDumpTest is a helper method to append the passed input and desired result
// to dumpTests
Add tests for maps with multiple entries. Previously, the tests did not include maps with more than a single entry since the iteration order is randomized and the tests only accepted a single valid expected value. This commit modifies the tests to accept multiple valid expected values and adds tests for a multi-entry map to both Dump and Formatter.
2013-01-20 12:02:36 -06:00
func addDumpTest(in interface{}, wants ...string) {
test := dumpTest{in, wants}
Initial implementation.
2013-01-08 23:35:50 -06:00
dumpTests = append(dumpTests, test)
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addIntDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max int8.
v := int8(127)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*int8)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "int8"
vs := "127"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max int16.
v2 := int16(32767)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv2 := (*int16)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "int16"
v2s := "32767"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max int32.
v3 := int32(2147483647)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv3 := (*int32)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "int32"
v3s := "2147483647"
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max int64.
v4 := int64(9223372036854775807)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv4 := (*int64)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "int64"
v4s := "9223372036854775807"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max int.
v5 := int(2147483647)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv5 := (*int)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv5 := &v5
v5Addr := fmt.Sprintf("%p", pv5)
pv5Addr := fmt.Sprintf("%p", &pv5)
v5t := "int"
v5s := "2147483647"
addDumpTest(v5, "("+v5t+") "+v5s+"\n")
addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addUintDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max uint8.
v := uint8(255)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*uint8)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "uint8"
vs := "255"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max uint16.
v2 := uint16(65535)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv2 := (*uint16)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "uint16"
v2s := "65535"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max uint32.
v3 := uint32(4294967295)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv3 := (*uint32)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "uint32"
v3s := "4294967295"
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max uint64.
v4 := uint64(18446744073709551615)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv4 := (*uint64)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "uint64"
v4s := "18446744073709551615"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Max uint.
v5 := uint(4294967295)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv5 := (*uint)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv5 := &v5
v5Addr := fmt.Sprintf("%p", pv5)
pv5Addr := fmt.Sprintf("%p", &pv5)
v5t := "uint"
v5s := "4294967295"
addDumpTest(v5, "("+v5t+") "+v5s+"\n")
addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addBoolDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Boolean true.
v := bool(true)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*bool)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "bool"
vs := "true"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Boolean false.
v2 := bool(false)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "bool"
v2s := "false"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addFloatDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Standard float32.
v := float32(3.1415)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*float32)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "float32"
vs := "3.1415"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Standard float64.
v2 := float64(3.1415926)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv2 := (*float64)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "float64"
v2s := "3.1415926"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addComplexDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Standard complex64.
v := complex(float32(6), -2)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*complex64)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "complex64"
vs := "(6-2i)"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Standard complex128.
v2 := complex(float64(-6), 2)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv2 := (*complex128)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "complex128"
v2s := "(-6+2i)"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addArrayDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Array containing standard ints.
v := [3]int{1, 2, 3}
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
vLen := fmt.Sprintf("%d", len(v))
vCap := fmt.Sprintf("%d", cap(v))
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*[3]int)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "int"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 1,\n (" +
vt + ") 2,\n (" + vt + ") 3\n}"
Initial implementation.
2013-01-08 23:35:50 -06:00
addDumpTest(v, "([3]"+vt+") "+vs+"\n")
addDumpTest(pv, "(*[3]"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**[3]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*[3]"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Array containing type with custom formatter on pointer receiver only.
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v2i0 := pstringer("1")
v2i1 := pstringer("2")
v2i2 := pstringer("3")
v2 := [3]pstringer{v2i0, v2i1, v2i2}
v2i0Len := fmt.Sprintf("%d", len(v2i0))
v2i1Len := fmt.Sprintf("%d", len(v2i1))
v2i2Len := fmt.Sprintf("%d", len(v2i2))
v2Len := fmt.Sprintf("%d", len(v2))
v2Cap := fmt.Sprintf("%d", cap(v2))
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv2 := (*[3]pstringer)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "spew_test.pstringer"
Add support for limited mode without unsafe pkg. This commit adds support for compiling spew without the unsafe package. When compiled without the unsafe package, some of the more advanced features such as invoking stringers on pointers from non-pointer variables and unexported struct fields are not available. By default, spew will be compiled in the limited mode for Google App Engine since the unsafe package is not available there. Additionally, spew can be compiled without the unsafe package manually by specifying the "disableunsafe" build tag. Finally, a new package-level constant named "UnsafeDisabled" has been exposed which can be used to programmatically determine if spew was compiled with access to the unsafe package.
2015-06-17 22:34:22 -05:00
v2sp := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t +
") (len=" + v2i0Len + ") stringer 1,\n (" + v2t +
") (len=" + v2i1Len + ") stringer 2,\n (" + v2t +
") (len=" + v2i2Len + ") " + "stringer 3\n}"
v2s := v2sp
if spew.UnsafeDisabled {
v2s = "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t +
") (len=" + v2i0Len + ") \"1\",\n (" + v2t + ") (len=" +
v2i1Len + ") \"2\",\n (" + v2t + ") (len=" + v2i2Len +
") " + "\"3\"\n}"
}
Initial implementation.
2013-01-08 23:35:50 -06:00
addDumpTest(v2, "([3]"+v2t+") "+v2s+"\n")
Add support for limited mode without unsafe pkg. This commit adds support for compiling spew without the unsafe package. When compiled without the unsafe package, some of the more advanced features such as invoking stringers on pointers from non-pointer variables and unexported struct fields are not available. By default, spew will be compiled in the limited mode for Google App Engine since the unsafe package is not available there. Additionally, spew can be compiled without the unsafe package manually by specifying the "disableunsafe" build tag. Finally, a new package-level constant named "UnsafeDisabled" has been exposed which can be used to programmatically determine if spew was compiled with access to the unsafe package.
2015-06-17 22:34:22 -05:00
addDumpTest(pv2, "(*[3]"+v2t+")("+v2Addr+")("+v2sp+")\n")
addDumpTest(&pv2, "(**[3]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2sp+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv2, "(*[3]"+v2t+")(<nil>)\n")
Add dump tests for interface arrays and slices.
2013-01-17 21:35:19 -06:00
// Array containing interfaces.
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v3i0 := "one"
v3 := [3]interface{}{v3i0, int(2), uint(3)}
v3i0Len := fmt.Sprintf("%d", len(v3i0))
v3Len := fmt.Sprintf("%d", len(v3))
v3Cap := fmt.Sprintf("%d", cap(v3))
Add dump tests for interface arrays and slices.
2013-01-17 21:35:19 -06:00
nv3 := (*[3]interface{})(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "[3]interface {}"
v3t2 := "string"
v3t3 := "int"
v3t4 := "uint"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
"(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
v3t4 + ") 3\n}"
Add dump tests for interface arrays and slices.
2013-01-17 21:35:19 -06:00
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
Add tests for byte arrays and slices. This commit adds tests for the new byte array and slice hexdump functionality as specified in issue #9.
2013-03-08 22:20:54 -06:00
// Array containing bytes.
v4 := [34]byte{
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
0x31, 0x32,
}
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v4Len := fmt.Sprintf("%d", len(v4))
v4Cap := fmt.Sprintf("%d", cap(v4))
Add tests for byte arrays and slices. This commit adds tests for the new byte array and slice hexdump functionality as specified in issue #9.
2013-03-08 22:20:54 -06:00
nv4 := (*[34]byte)(nil)
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "[34]uint8"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
"{\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20" +
Add tests for byte arrays and slices. This commit adds tests for the new byte array and slice hexdump functionality as specified in issue #9.
2013-03-08 22:20:54 -06:00
" |............... |\n" +
" 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30" +
" |!\"#$%&'()*+,-./0|\n" +
" 00000020 31 32 " +
" |12|\n}"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addSliceDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Slice containing standard float32 values.
v := []float32{3.14, 6.28, 12.56}
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
vLen := fmt.Sprintf("%d", len(v))
vCap := fmt.Sprintf("%d", cap(v))
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*[]float32)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "float32"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 3.14,\n (" +
vt + ") 6.28,\n (" + vt + ") 12.56\n}"
Initial implementation.
2013-01-08 23:35:50 -06:00
addDumpTest(v, "([]"+vt+") "+vs+"\n")
addDumpTest(pv, "(*[]"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**[]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*[]"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Slice containing type with custom formatter on pointer receiver only.
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v2i0 := pstringer("1")
v2i1 := pstringer("2")
v2i2 := pstringer("3")
v2 := []pstringer{v2i0, v2i1, v2i2}
v2i0Len := fmt.Sprintf("%d", len(v2i0))
v2i1Len := fmt.Sprintf("%d", len(v2i1))
v2i2Len := fmt.Sprintf("%d", len(v2i2))
v2Len := fmt.Sprintf("%d", len(v2))
v2Cap := fmt.Sprintf("%d", cap(v2))
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv2 := (*[]pstringer)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "spew_test.pstringer"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v2s := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t + ") (len=" +
v2i0Len + ") stringer 1,\n (" + v2t + ") (len=" + v2i1Len +
") stringer 2,\n (" + v2t + ") (len=" + v2i2Len + ") " +
"stringer 3\n}"
Initial implementation.
2013-01-08 23:35:50 -06:00
addDumpTest(v2, "([]"+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*[]"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**[]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv2, "(*[]"+v2t+")(<nil>)\n")
Add dump tests for interface arrays and slices.
2013-01-17 21:35:19 -06:00
// Slice containing interfaces.
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v3i0 := "one"
v3 := []interface{}{v3i0, int(2), uint(3), nil}
v3i0Len := fmt.Sprintf("%d", len(v3i0))
v3Len := fmt.Sprintf("%d", len(v3))
v3Cap := fmt.Sprintf("%d", cap(v3))
Add dump tests for interface arrays and slices.
2013-01-17 21:35:19 -06:00
nv3 := (*[]interface{})(nil)
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "[]interface {}"
v3t2 := "string"
v3t3 := "int"
v3t4 := "uint"
Add tests for packed nil interfaces. This commit adds tests for nil interfaces packed inside maps and slices to test the recently added fix for issue #12.
2013-03-27 22:44:40 -05:00
v3t5 := "interface {}"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
"(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
v3t4 + ") 3,\n (" + v3t5 + ") <nil>\n}"
Add dump tests for interface arrays and slices.
2013-01-17 21:35:19 -06:00
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
Add tests for byte arrays and slices. This commit adds tests for the new byte array and slice hexdump functionality as specified in issue #9.
2013-03-08 22:20:54 -06:00
// Slice containing bytes.
v4 := []byte{
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
0x31, 0x32,
}
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v4Len := fmt.Sprintf("%d", len(v4))
v4Cap := fmt.Sprintf("%d", cap(v4))
Add tests for byte arrays and slices. This commit adds tests for the new byte array and slice hexdump functionality as specified in issue #9.
2013-03-08 22:20:54 -06:00
nv4 := (*[]byte)(nil)
pv4 := &v4
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "[]uint8"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
"{\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20" +
Add tests for byte arrays and slices. This commit adds tests for the new byte array and slice hexdump functionality as specified in issue #9.
2013-03-08 22:20:54 -06:00
" |............... |\n" +
" 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30" +
" |!\"#$%&'()*+,-./0|\n" +
" 00000020 31 32 " +
" |12|\n}"
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
Add tests for nil slice change. This commit adds tests for the nil slice change.
2013-09-09 20:42:50 -05:00
// Nil slice.
v5 := []int(nil)
nv5 := (*[]int)(nil)
pv5 := &v5
v5Addr := fmt.Sprintf("%p", pv5)
pv5Addr := fmt.Sprintf("%p", &pv5)
v5t := "[]int"
v5s := "<nil>"
addDumpTest(v5, "("+v5t+") "+v5s+"\n")
addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addStringDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Standard string.
v := "test"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
vLen := fmt.Sprintf("%d", len(v))
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*string)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "string"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
vs := "(len=" + vLen + ") \"test\""
Initial implementation.
2013-01-08 23:35:50 -06:00
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Add tests for sub-interfaces.
2013-01-20 15:27:57 -06:00
func addInterfaceDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Nil interface.
var v interface{}
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*interface{})(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "interface {}"
vs := "<nil>"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Add tests for sub-interfaces.
2013-01-20 15:27:57 -06:00
// Sub-interface.
v2 := interface{}(uint16(65535))
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "uint16"
v2s := "65535"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addMapDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Map with string keys and int vals.
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
k := "one"
kk := "two"
m := map[string]int{k: 1, kk: 2}
klen := fmt.Sprintf("%d", len(k)) // not kLen to shut golint up
kkLen := fmt.Sprintf("%d", len(kk))
mLen := fmt.Sprintf("%d", len(m))
make nil maps appear different than empty maps
2015-01-19 09:22:19 -06:00
nilMap := map[string]int(nil)
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
nm := (*map[string]int)(nil)
pm := &m
mAddr := fmt.Sprintf("%p", pm)
pmAddr := fmt.Sprintf("%p", &pm)
mt := "map[string]int"
mt1 := "string"
mt2 := "int"
ms := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + klen + ") " +
"\"one\": (" + mt2 + ") 1,\n (" + mt1 + ") (len=" + kkLen +
") \"two\": (" + mt2 + ") 2\n}"
ms2 := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + kkLen + ") " +
"\"two\": (" + mt2 + ") 2,\n (" + mt1 + ") (len=" + klen +
") \"one\": (" + mt2 + ") 1\n}"
addDumpTest(m, "("+mt+") "+ms+"\n", "("+mt+") "+ms2+"\n")
addDumpTest(pm, "(*"+mt+")("+mAddr+")("+ms+")\n",
"(*"+mt+")("+mAddr+")("+ms2+")\n")
addDumpTest(&pm, "(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms+")\n",
"(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms2+")\n")
addDumpTest(nm, "(*"+mt+")(<nil>)\n")
make nil maps appear different than empty maps
2015-01-19 09:22:19 -06:00
addDumpTest(nilMap, "("+mt+") <nil>\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Map with custom formatter type on pointer receiver only keys and vals.
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
k2 := pstringer("one")
v2 := pstringer("1")
m2 := map[pstringer]pstringer{k2: v2}
k2Len := fmt.Sprintf("%d", len(k2))
v2Len := fmt.Sprintf("%d", len(v2))
m2Len := fmt.Sprintf("%d", len(m2))
make nil maps appear different than empty maps
2015-01-19 09:22:19 -06:00
nilMap2 := map[pstringer]pstringer(nil)
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
nm2 := (*map[pstringer]pstringer)(nil)
pm2 := &m2
m2Addr := fmt.Sprintf("%p", pm2)
pm2Addr := fmt.Sprintf("%p", &pm2)
m2t := "map[spew_test.pstringer]spew_test.pstringer"
m2t1 := "spew_test.pstringer"
m2t2 := "spew_test.pstringer"
m2s := "(len=" + m2Len + ") {\n (" + m2t1 + ") (len=" + k2Len + ") " +
"stringer one: (" + m2t2 + ") (len=" + v2Len + ") stringer 1\n}"
Add support for limited mode without unsafe pkg. This commit adds support for compiling spew without the unsafe package. When compiled without the unsafe package, some of the more advanced features such as invoking stringers on pointers from non-pointer variables and unexported struct fields are not available. By default, spew will be compiled in the limited mode for Google App Engine since the unsafe package is not available there. Additionally, spew can be compiled without the unsafe package manually by specifying the "disableunsafe" build tag. Finally, a new package-level constant named "UnsafeDisabled" has been exposed which can be used to programmatically determine if spew was compiled with access to the unsafe package.
2015-06-17 22:34:22 -05:00
if spew.UnsafeDisabled {
m2s = "(len=" + m2Len + ") {\n (" + m2t1 + ") (len=" + k2Len +
") " + "\"one\": (" + m2t2 + ") (len=" + v2Len +
") \"1\"\n}"
}
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
addDumpTest(m2, "("+m2t+") "+m2s+"\n")
addDumpTest(pm2, "(*"+m2t+")("+m2Addr+")("+m2s+")\n")
addDumpTest(&pm2, "(**"+m2t+")("+pm2Addr+"->"+m2Addr+")("+m2s+")\n")
addDumpTest(nm2, "(*"+m2t+")(<nil>)\n")
make nil maps appear different than empty maps
2015-01-19 09:22:19 -06:00
addDumpTest(nilMap2, "("+m2t+") <nil>\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Map with interface keys and values.
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
k3 := "one"
k3Len := fmt.Sprintf("%d", len(k3))
m3 := map[interface{}]interface{}{k3: 1}
m3Len := fmt.Sprintf("%d", len(m3))
make nil maps appear different than empty maps
2015-01-19 09:22:19 -06:00
nilMap3 := map[interface{}]interface{}(nil)
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
nm3 := (*map[interface{}]interface{})(nil)
pm3 := &m3
m3Addr := fmt.Sprintf("%p", pm3)
pm3Addr := fmt.Sprintf("%p", &pm3)
m3t := "map[interface {}]interface {}"
m3t1 := "string"
m3t2 := "int"
m3s := "(len=" + m3Len + ") {\n (" + m3t1 + ") (len=" + k3Len + ") " +
"\"one\": (" + m3t2 + ") 1\n}"
addDumpTest(m3, "("+m3t+") "+m3s+"\n")
addDumpTest(pm3, "(*"+m3t+")("+m3Addr+")("+m3s+")\n")
addDumpTest(&pm3, "(**"+m3t+")("+pm3Addr+"->"+m3Addr+")("+m3s+")\n")
addDumpTest(nm3, "(*"+m3t+")(<nil>)\n")
make nil maps appear different than empty maps
2015-01-19 09:22:19 -06:00
addDumpTest(nilMap3, "("+m3t+") <nil>\n")
Add tests for packed nil interfaces. This commit adds tests for nil interfaces packed inside maps and slices to test the recently added fix for issue #12.
2013-03-27 22:44:40 -05:00
// Map with nil interface value.
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
k4 := "nil"
k4Len := fmt.Sprintf("%d", len(k4))
m4 := map[string]interface{}{k4: nil}
m4Len := fmt.Sprintf("%d", len(m4))
make nil maps appear different than empty maps
2015-01-19 09:22:19 -06:00
nilMap4 := map[string]interface{}(nil)
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
nm4 := (*map[string]interface{})(nil)
pm4 := &m4
m4Addr := fmt.Sprintf("%p", pm4)
pm4Addr := fmt.Sprintf("%p", &pm4)
m4t := "map[string]interface {}"
m4t1 := "string"
m4t2 := "interface {}"
m4s := "(len=" + m4Len + ") {\n (" + m4t1 + ") (len=" + k4Len + ")" +
" \"nil\": (" + m4t2 + ") <nil>\n}"
addDumpTest(m4, "("+m4t+") "+m4s+"\n")
addDumpTest(pm4, "(*"+m4t+")("+m4Addr+")("+m4s+")\n")
addDumpTest(&pm4, "(**"+m4t+")("+pm4Addr+"->"+m4Addr+")("+m4s+")\n")
addDumpTest(nm4, "(*"+m4t+")(<nil>)\n")
make nil maps appear different than empty maps
2015-01-19 09:22:19 -06:00
addDumpTest(nilMap4, "("+m4t+") <nil>\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addStructDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Struct with primitives.
type s1 struct {
a int8
b uint8
}
v := s1{127, 255}
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*s1)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "spew_test.s1"
vt2 := "int8"
vt3 := "uint8"
vs := "{\n a: (" + vt2 + ") 127,\n b: (" + vt3 + ") 255\n}"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Struct that contains another struct.
type s2 struct {
s1 s1
b bool
}
v2 := s2{s1{127, 255}, true}
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv2 := (*s2)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "spew_test.s2"
v2t2 := "spew_test.s1"
v2t3 := "int8"
v2t4 := "uint8"
v2t5 := "bool"
v2s := "{\n s1: (" + v2t2 + ") {\n a: (" + v2t3 + ") 127,\n b: (" +
v2t4 + ") 255\n },\n b: (" + v2t5 + ") true\n}"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Struct that contains custom type with Stringer pointer interface via both
// exported and unexported fields.
type s3 struct {
s pstringer
S pstringer
}
v3 := s3{"test", "test2"}
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv3 := (*s3)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "spew_test.s3"
v3t2 := "spew_test.pstringer"
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
v3s := "{\n s: (" + v3t2 + ") (len=4) stringer test,\n S: (" + v3t2 +
") (len=5) stringer test2\n}"
Add support for limited mode without unsafe pkg. This commit adds support for compiling spew without the unsafe package. When compiled without the unsafe package, some of the more advanced features such as invoking stringers on pointers from non-pointer variables and unexported struct fields are not available. By default, spew will be compiled in the limited mode for Google App Engine since the unsafe package is not available there. Additionally, spew can be compiled without the unsafe package manually by specifying the "disableunsafe" build tag. Finally, a new package-level constant named "UnsafeDisabled" has been exposed which can be used to programmatically determine if spew was compiled with access to the unsafe package.
2015-06-17 22:34:22 -05:00
v3sp := v3s
if spew.UnsafeDisabled {
v3s = "{\n s: (" + v3t2 + ") (len=4) \"test\",\n S: (" +
v3t2 + ") (len=5) \"test2\"\n}"
v3sp = "{\n s: (" + v3t2 + ") (len=4) \"test\",\n S: (" +
v3t2 + ") (len=5) stringer test2\n}"
}
Initial implementation.
2013-01-08 23:35:50 -06:00
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
Add support for limited mode without unsafe pkg. This commit adds support for compiling spew without the unsafe package. When compiled without the unsafe package, some of the more advanced features such as invoking stringers on pointers from non-pointer variables and unexported struct fields are not available. By default, spew will be compiled in the limited mode for Google App Engine since the unsafe package is not available there. Additionally, spew can be compiled without the unsafe package manually by specifying the "disableunsafe" build tag. Finally, a new package-level constant named "UnsafeDisabled" has been exposed which can be used to programmatically determine if spew was compiled with access to the unsafe package.
2015-06-17 22:34:22 -05:00
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3sp+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3sp+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
Add tests for structs with multiple equiv fields. This commit adds tests for a struct which has an embedded struct pointer and a field that is a pointer to the same object. This ensures the cycle detection is properly reset between fields.
2013-01-20 19:55:55 -06:00
// Struct that contains embedded struct and field to same struct.
e := embed{"embedstr"}
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
eLen := fmt.Sprintf("%d", len("embedstr"))
Add tests for structs with multiple equiv fields. This commit adds tests for a struct which has an embedded struct pointer and a field that is a pointer to the same object. This ensures the cycle detection is properly reset between fields.
2013-01-20 19:55:55 -06:00
v4 := embedwrap{embed: &e, e: &e}
nv4 := (*embedwrap)(nil)
pv4 := &v4
eAddr := fmt.Sprintf("%p", &e)
v4Addr := fmt.Sprintf("%p", pv4)
pv4Addr := fmt.Sprintf("%p", &pv4)
v4t := "spew_test.embedwrap"
v4t2 := "spew_test.embed"
v4t3 := "string"
v4s := "{\n embed: (*" + v4t2 + ")(" + eAddr + ")({\n a: (" + v4t3 +
Dump non-zero len and cap for applicable types. Closes #16.
2014-05-05 22:09:56 -05:00
") (len=" + eLen + ") \"embedstr\"\n }),\n e: (*" + v4t2 +
")(" + eAddr + ")({\n a: (" + v4t3 + ") (len=" + eLen + ")" +
" \"embedstr\"\n })\n}"
Add tests for structs with multiple equiv fields. This commit adds tests for a struct which has an embedded struct pointer and a field that is a pointer to the same object. This ensures the cycle detection is properly reset between fields.
2013-01-20 19:55:55 -06:00
addDumpTest(v4, "("+v4t+") "+v4s+"\n")
addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addUintptrDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Null pointer.
v := uintptr(0)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "uintptr"
vs := "<nil>"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
// Address of real variable.
i := 1
v2 := uintptr(unsafe.Pointer(&i))
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv2 := (*uintptr)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "uintptr"
v2s := fmt.Sprintf("%p", &i)
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addUnsafePointerDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Null pointer.
vet: fix vet warnings
2018-01-21 10:36:22 -06:00
v := unsafe.Pointer(nil)
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*unsafe.Pointer)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "unsafe.Pointer"
vs := "<nil>"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Address of real variable.
i := 1
v2 := unsafe.Pointer(&i)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "unsafe.Pointer"
v2s := fmt.Sprintf("%p", &i)
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addChanDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Nil channel.
var v chan int
pv := &v
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*chan int)(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "chan int"
vs := "<nil>"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Real channel.
v2 := make(chan int)
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "chan int"
v2s := fmt.Sprintf("%p", v2)
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addFuncDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Function with no params and no returns.
Namespace dump tests.
2013-01-14 08:52:16 -06:00
v := addIntDumpTests
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv := (*func())(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "func()"
vs := fmt.Sprintf("%p", v)
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Function with param and no returns.
v2 := TestDump
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
nv2 := (*func(*testing.T))(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv2 := &v2
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "func(*testing.T)"
v2s := fmt.Sprintf("%p", v2)
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
// Function with multiple params and multiple returns.
var v3 = func(i int, s string) (b bool, err error) {
return true, nil
}
Fix a comment and a apply few gofmt changes.
2013-01-16 23:30:06 -06:00
nv3 := (*func(int, string) (bool, error))(nil)
Initial implementation.
2013-01-08 23:35:50 -06:00
pv3 := &v3
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "func(int, string) (bool, error)"
v3s := fmt.Sprintf("%p", v3)
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
Add tests for non-interface nil pointers. These tests are a slight adaptation of tests provided by kortschak@ in issue #4. Credits go to him.
2013-01-12 23:33:31 -06:00
addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
Initial implementation.
2013-01-08 23:35:50 -06:00
}
Namespace dump tests.
2013-01-14 08:52:16 -06:00
func addCircularDumpTests() {
Initial implementation.
2013-01-08 23:35:50 -06:00
// Struct that is circular through self referencing.
type circular struct {
c *circular
}
v := circular{nil}
v.c = &v
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "spew_test.circular"
vs := "{\n c: (*" + vt + ")(" + vAddr + ")({\n c: (*" + vt + ")(" +
vAddr + ")(<already shown>)\n })\n}"
vs2 := "{\n c: (*" + vt + ")(" + vAddr + ")(<already shown>)\n}"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs2+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs2+")\n")
// Structs that are circular through cross referencing.
v2 := xref1{nil}
ts2 := xref2{&v2}
v2.ps2 = &ts2
pv2 := &v2
ts2Addr := fmt.Sprintf("%p", &ts2)
v2Addr := fmt.Sprintf("%p", pv2)
pv2Addr := fmt.Sprintf("%p", &pv2)
v2t := "spew_test.xref1"
v2t2 := "spew_test.xref2"
v2s := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n ps1: (*" + v2t +
")(" + v2Addr + ")({\n ps2: (*" + v2t2 + ")(" + ts2Addr +
")(<already shown>)\n })\n })\n}"
v2s2 := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n ps1: (*" + v2t +
")(" + v2Addr + ")(<already shown>)\n })\n}"
addDumpTest(v2, "("+v2t+") "+v2s+"\n")
addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s2+")\n")
addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s2+")\n")
// Structs that are indirectly circular.
v3 := indirCir1{nil}
tic2 := indirCir2{nil}
tic3 := indirCir3{&v3}
tic2.ps3 = &tic3
v3.ps2 = &tic2
pv3 := &v3
tic2Addr := fmt.Sprintf("%p", &tic2)
tic3Addr := fmt.Sprintf("%p", &tic3)
v3Addr := fmt.Sprintf("%p", pv3)
pv3Addr := fmt.Sprintf("%p", &pv3)
v3t := "spew_test.indirCir1"
v3t2 := "spew_test.indirCir2"
v3t3 := "spew_test.indirCir3"
v3s := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n ps3: (*" + v3t3 +
")(" + tic3Addr + ")({\n ps1: (*" + v3t + ")(" + v3Addr +
")({\n ps2: (*" + v3t2 + ")(" + tic2Addr +
")(<already shown>)\n })\n })\n })\n}"
v3s2 := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n ps3: (*" + v3t3 +
")(" + tic3Addr + ")({\n ps1: (*" + v3t + ")(" + v3Addr +
")(<already shown>)\n })\n })\n}"
addDumpTest(v3, "("+v3t+") "+v3s+"\n")
addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s2+")\n")
addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s2+")\n")
}
Add tests for custom type that panics in Stringer.
2013-01-20 12:31:42 -06:00
func addPanicDumpTests() {
// Type that panics in its Stringer interface.
v := panicer(127)
nv := (*panicer)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "spew_test.panicer"
vs := "(PANIC=test panic)127"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
}
Add tests for types with custom Error interface.
2013-01-20 13:41:53 -06:00
func addErrorDumpTests() {
// Type that has a custom Error interface.
v := customError(127)
nv := (*customError)(nil)
pv := &v
vAddr := fmt.Sprintf("%p", pv)
pvAddr := fmt.Sprintf("%p", &pv)
vt := "spew_test.customError"
vs := "error: 127"
addDumpTest(v, "("+vt+") "+vs+"\n")
addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
addDumpTest(nv, "(*"+vt+")(<nil>)\n")
}
Initial implementation.
2013-01-08 23:35:50 -06:00
// TestDump executes all of the tests described by dumpTests.
func TestDump(t *testing.T) {
Namespace dump tests.
2013-01-14 08:52:16 -06:00
// Setup tests.
addIntDumpTests()
addUintDumpTests()
addBoolDumpTests()
addFloatDumpTests()
addComplexDumpTests()
addArrayDumpTests()
addSliceDumpTests()
addStringDumpTests()
Add tests for sub-interfaces.
2013-01-20 15:27:57 -06:00
addInterfaceDumpTests()
Namespace dump tests.
2013-01-14 08:52:16 -06:00
addMapDumpTests()
addStructDumpTests()
addUintptrDumpTests()
addUnsafePointerDumpTests()
addChanDumpTests()
addFuncDumpTests()
addCircularDumpTests()
Add tests for custom type that panics in Stringer.
2013-01-20 12:31:42 -06:00
addPanicDumpTests()
Add tests for types with custom Error interface.
2013-01-20 13:41:53 -06:00
addErrorDumpTests()
Add tests for recent cgo handling updates. This commit adds tests for the recent cgo handling of char, unsigned char, and uint8_t arrays. In addition, it adds an architecture for the cgo specific testing based on build constraints. This was done because spew itself does not require cgo, but in order to test its handling of the cgo types it needs to be fed cgo data. Rather than force all users to have a system which supports cgo and an external compiler just to run the tests, the cgo test support must explicitly be turned on via a build tag.
2013-09-21 21:50:00 -05:00
addCgoDumpTests()
Namespace dump tests.
2013-01-14 08:52:16 -06:00
Initial implementation.
2013-01-08 23:35:50 -06:00
t.Logf("Running %d tests", len(dumpTests))
for i, test := range dumpTests {
buf := new(bytes.Buffer)
spew.Fdump(buf, test.in)
s := buf.String()
Add tests for maps with multiple entries. Previously, the tests did not include maps with more than a single entry since the iteration order is randomized and the tests only accepted a single valid expected value. This commit modifies the tests to accept multiple valid expected values and adds tests for a multi-entry map to both Dump and Formatter.
2013-01-20 12:02:36 -06:00
if testFailed(s, test.wants) {
t.Errorf("Dump #%d\n got: %s %s", i, s, stringizeWants(test.wants))
Initial implementation.
2013-01-08 23:35:50 -06:00
continue
}
}
}
config: add SortKeys option to sort native map keys before display If ConfigState.SortKeys is true, then dump and format will sort map keys before displaying them. Only native types (bool, ints, uint, uintptr, string) are supported, other slices are left unchanged. The motivation is to have more diffable output, mostly for test purpose.
2013-10-27 17:44:49 -05:00
func TestDumpSortedKeys(t *testing.T) {
cfg := spew.ConfigState{SortKeys: true}
s := cfg.Sdump(map[int]string{1: "1", 3: "3", 2: "2"})
Add support for limited mode without unsafe pkg. This commit adds support for compiling spew without the unsafe package. When compiled without the unsafe package, some of the more advanced features such as invoking stringers on pointers from non-pointer variables and unexported struct fields are not available. By default, spew will be compiled in the limited mode for Google App Engine since the unsafe package is not available there. Additionally, spew can be compiled without the unsafe package manually by specifying the "disableunsafe" build tag. Finally, a new package-level constant named "UnsafeDisabled" has been exposed which can be used to programmatically determine if spew was compiled with access to the unsafe package.
2015-06-17 22:34:22 -05:00
expected := "(map[int]string) (len=3) {\n(int) 1: (string) (len=1) " +
"\"1\",\n(int) 2: (string) (len=1) \"2\",\n(int) 3: (string) " +
"(len=1) \"3\"\n" +
"}\n"
config: add SortKeys option to sort native map keys before display If ConfigState.SortKeys is true, then dump and format will sort map keys before displaying them. Only native types (bool, ints, uint, uintptr, string) are supported, other slices are left unchanged. The motivation is to have more diffable output, mostly for test purpose.
2013-10-27 17:44:49 -05:00
if s != expected {
t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
}
Enable methods to sort map keys and spew itself as last resort If enabled by flags, try to use methods to stringify map keys and sort on that. If we can't use primitive sorting and we can't use methods, we can still fall back on spew itself. If SpewKeys is enabled, use Sprintf("%#v") to generate a string and sort by that.
2015-03-31 15:55:04 -05:00
s = cfg.Sdump(map[stringer]int{"1": 1, "3": 3, "2": 2})
Add support for limited mode without unsafe pkg. This commit adds support for compiling spew without the unsafe package. When compiled without the unsafe package, some of the more advanced features such as invoking stringers on pointers from non-pointer variables and unexported struct fields are not available. By default, spew will be compiled in the limited mode for Google App Engine since the unsafe package is not available there. Additionally, spew can be compiled without the unsafe package manually by specifying the "disableunsafe" build tag. Finally, a new package-level constant named "UnsafeDisabled" has been exposed which can be used to programmatically determine if spew was compiled with access to the unsafe package.
2015-06-17 22:34:22 -05:00
expected = "(map[spew_test.stringer]int) (len=3) {\n" +
"(spew_test.stringer) (len=1) stringer 1: (int) 1,\n" +
"(spew_test.stringer) (len=1) stringer 2: (int) 2,\n" +
"(spew_test.stringer) (len=1) stringer 3: (int) 3\n" +
"}\n"
Enable methods to sort map keys and spew itself as last resort If enabled by flags, try to use methods to stringify map keys and sort on that. If we can't use primitive sorting and we can't use methods, we can still fall back on spew itself. If SpewKeys is enabled, use Sprintf("%#v") to generate a string and sort by that.
2015-03-31 15:55:04 -05:00
if s != expected {
t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
}
s = cfg.Sdump(map[pstringer]int{pstringer("1"): 1, pstringer("3"): 3, pstringer("2"): 2})
Add support for limited mode without unsafe pkg. This commit adds support for compiling spew without the unsafe package. When compiled without the unsafe package, some of the more advanced features such as invoking stringers on pointers from non-pointer variables and unexported struct fields are not available. By default, spew will be compiled in the limited mode for Google App Engine since the unsafe package is not available there. Additionally, spew can be compiled without the unsafe package manually by specifying the "disableunsafe" build tag. Finally, a new package-level constant named "UnsafeDisabled" has been exposed which can be used to programmatically determine if spew was compiled with access to the unsafe package.
2015-06-17 22:34:22 -05:00
expected = "(map[spew_test.pstringer]int) (len=3) {\n" +
"(spew_test.pstringer) (len=1) stringer 1: (int) 1,\n" +
"(spew_test.pstringer) (len=1) stringer 2: (int) 2,\n" +
"(spew_test.pstringer) (len=1) stringer 3: (int) 3\n" +
"}\n"
if spew.UnsafeDisabled {
expected = "(map[spew_test.pstringer]int) (len=3) {\n" +
"(spew_test.pstringer) (len=1) \"1\": (int) 1,\n" +
"(spew_test.pstringer) (len=1) \"2\": (int) 2,\n" +
"(spew_test.pstringer) (len=1) \"3\": (int) 3\n" +
"}\n"
}
Enable methods to sort map keys and spew itself as last resort If enabled by flags, try to use methods to stringify map keys and sort on that. If we can't use primitive sorting and we can't use methods, we can still fall back on spew itself. If SpewKeys is enabled, use Sprintf("%#v") to generate a string and sort by that.
2015-03-31 15:55:04 -05:00
if s != expected {
t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
}
s = cfg.Sdump(map[customError]int{customError(1): 1, customError(3): 3, customError(2): 2})
Add support for limited mode without unsafe pkg. This commit adds support for compiling spew without the unsafe package. When compiled without the unsafe package, some of the more advanced features such as invoking stringers on pointers from non-pointer variables and unexported struct fields are not available. By default, spew will be compiled in the limited mode for Google App Engine since the unsafe package is not available there. Additionally, spew can be compiled without the unsafe package manually by specifying the "disableunsafe" build tag. Finally, a new package-level constant named "UnsafeDisabled" has been exposed which can be used to programmatically determine if spew was compiled with access to the unsafe package.
2015-06-17 22:34:22 -05:00
expected = "(map[spew_test.customError]int) (len=3) {\n" +
"(spew_test.customError) error: 1: (int) 1,\n" +
"(spew_test.customError) error: 2: (int) 2,\n" +
"(spew_test.customError) error: 3: (int) 3\n" +
"}\n"
Enable methods to sort map keys and spew itself as last resort If enabled by flags, try to use methods to stringify map keys and sort on that. If we can't use primitive sorting and we can't use methods, we can still fall back on spew itself. If SpewKeys is enabled, use Sprintf("%#v") to generate a string and sort by that.
2015-03-31 15:55:04 -05:00
if s != expected {
t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
}
config: add SortKeys option to sort native map keys before display If ConfigState.SortKeys is true, then dump and format will sort map keys before displaying them. Only native types (bool, ints, uint, uintptr, string) are supported, other slices are left unchanged. The motivation is to have more diffable output, mostly for test purpose.
2013-10-27 17:44:49 -05:00
}