restic/vendor/github.com/marstr/guid/guid_test.go

332 lines
7.0 KiB
Go
Raw Normal View History

package guid
import (
"encoding/json"
"fmt"
"io/ioutil"
"testing"
)
func Test_DefaultIsVersion4(t *testing.T) {
subject := NewGUID()
if ver := subject.Version(); ver != 4 {
t.Logf("Default GUID should be produced using algorithm: version 4. Actual: version %d\n%s", ver, subject.String())
t.Fail()
}
}
func Test_NewGUIDs_NotEmpty(t *testing.T) {
for strat := range knownStrategies {
t.Run(string(strat), func(subT *testing.T) {
subject, err := NewGUIDs(strat)
if err != nil {
subT.Error(err)
}
if subject == Empty() {
subT.Logf("unexpected empty encountered")
subT.Fail()
}
})
}
}
func Test_NewGUIDs_Unsupported(t *testing.T) {
fauxStrategy := CreationStrategy("invalidStrategy")
subject, err := NewGUIDs(fauxStrategy)
if subject != Empty() {
t.Fail()
}
if err.Error() != "Unsupported CreationStrategy" {
t.Fail()
}
}
func Test_Format_Empty(t *testing.T) {
subject := Empty()
testCases := []struct {
shortFormat Format
expected string
}{
{FormatP, "(00000000-0000-0000-0000-000000000000)"},
{FormatX, "{0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}"},
{FormatN, "00000000000000000000000000000000"},
{FormatD, "00000000-0000-0000-0000-000000000000"},
{FormatB, "{00000000-0000-0000-0000-000000000000}"},
}
for _, scenario := range testCases {
t.Run("", func(subT *testing.T) {
result := subject.Stringf(scenario.shortFormat)
if result != scenario.expected {
subT.Logf("\nwant:\t%s\ngot: \t%s", scenario.expected, result)
subT.Fail()
}
})
}
}
func Test_Parse_Roundtrip(t *testing.T) {
subject := NewGUID()
for format := range knownFormats {
t.Run(string(format), func(subT *testing.T) {
serialized := subject.Stringf(format)
parsed, parseErr := Parse(serialized)
if nil != parseErr {
subT.Error(parseErr)
}
if parsed != subject {
subT.Logf("\nwant:\t%s\ngot: \t%s", subject.String(), parsed.String())
subT.Fail()
}
})
}
}
func Test_Parse_Failures(t *testing.T) {
testCases := []string{
"",
"abc",
"00000000-0000-0000-0000-000000", // Missing digits
}
for _, tc := range testCases {
t.Run("", func(t *testing.T) {
result, err := Parse(tc)
if expected := fmt.Sprintf(`"%s" is not in a recognized format`, tc); nil == err || expected != err.Error() {
t.Logf("\nwant:\t%s\ngot: \t%v", expected, err)
t.Fail()
}
if result != Empty() {
t.Logf("\nwant:\t%s\ngot: \t%s", Empty().String(), result.String())
t.Fail()
}
})
}
}
func Test_version4_ReservedBits(t *testing.T) {
for i := 0; i < 500; i++ {
result, _ := version4()
if result.clockSeqHighAndReserved&0xc0 != 0x80 {
t.Fail()
}
}
}
func Test_version4_NoOctetisReliablyZero(t *testing.T) {
results := make(map[string]uint)
const iterations uint = 500
const suspicionThreshold uint = iterations / 10
results["time_low"] = 0
results["time_mid"] = 0
results["time_hi_and_version"] = 0
results["clock_seq_hi_and_reserved"] = 0
results["clock_seq_low"] = 0
results["node"] = 0
for i := uint(0); i < iterations; i++ {
current, _ := version4()
if 0 == current.timeLow {
results["time_low"]++
}
if 0 == current.timeMid {
results["time_mid"]++
}
if 0 == current.timeHighAndVersion {
results["time_hi_and_version"]++
}
if 0 == current.clockSeqHighAndReserved {
results["clock_seq_hi_and_reserved"]++
}
if 0 == current.clockSeqLow {
results["clock_seq_low"]++
}
}
anySuspicious := false
for key, val := range results {
if val > suspicionThreshold {
anySuspicious = true
t.Logf("%s reported value 0 enough times (%d of %d) to be suspicious.", key, val, iterations)
}
}
if anySuspicious {
t.Fail()
}
}
func Test_SubsequentCallsDiffer(t *testing.T) {
for strat := range knownStrategies {
t.Run(string(strat), func(subT *testing.T) {
seen := make(map[GUID]struct{})
for i := 0; i < 500; i++ {
result, err := NewGUIDs(strat)
if err != nil {
subT.Error(err)
}
if _, present := seen[result]; present == true {
subT.Logf("The value %s was generated multiple times.", result.String())
subT.Fail()
}
seen[result] = struct{}{}
}
})
}
}
func Test_JSONRoundTrip(t *testing.T) {
testCases := []GUID{
Empty(),
NewGUID(),
}
for _, tc := range testCases {
t.Run("", func(t *testing.T) {
marshaled, err := json.Marshal(tc)
if err != nil {
t.Error(err)
}
var unmarshaled GUID
err = json.Unmarshal(marshaled, &unmarshaled)
if err != nil {
t.Error(err)
}
if tc != unmarshaled {
t.Logf("\ngot: \t%s\nwant:\t%s", unmarshaled.String(), tc.String())
t.Fail()
}
})
}
}
func TestGUID_UnmarshalJSON_Failure(t *testing.T) {
testCases := []string{
``,
`"`,
`a`,
}
for _, tc := range testCases {
t.Run("", func(t *testing.T) {
var unmarshaled GUID
err := json.Unmarshal([]byte(tc), &unmarshaled)
if err == nil {
t.Logf("\ngot: \t%v\nwant:\t%v", err, nil)
t.Fail()
}
if unmarshaled != Empty() {
t.Logf("\ngot: \t%s\nwant:\t%v", unmarshaled.String(), Empty().String())
t.Fail()
}
})
}
}
func Test_getMACAddress(t *testing.T) {
subject, err := getMACAddress()
t.Logf("MAC returned: %02x:%02x:%02x:%02x:%02x:%02x", subject[0], subject[1], subject[2], subject[3], subject[4], subject[5])
if nil != err {
t.Error(err)
}
nonZeroSeen := false
for _, octet := range subject {
if 0 != octet {
nonZeroSeen = true
break
}
}
if !nonZeroSeen {
t.Fail()
}
}
func Test_setVersion_bounds(t *testing.T) {
testCases := []uint16{0, 6}
for _, tc := range testCases {
t.Run(fmt.Sprint(tc), func(t *testing.T) {
var fodder GUID
err := fodder.setVersion(tc)
if nil == err {
t.Log("error expected but unfound when version set to 0")
t.Fail()
}
})
}
}
func Benchmark_NewGUIDs(b *testing.B) {
for strat := range knownStrategies {
b.Run(string(strat), func(b *testing.B) {
for i := 0; i < b.N; i++ {
NewGUIDs(strat)
}
})
}
}
func Benchmark_String(b *testing.B) {
rand, _ := NewGUIDs(CreationStrategyVersion4)
b.ResetTimer()
for i := 0; i < b.N; i++ {
fmt.Fprint(ioutil.Discard, rand.String()) // This slows down the call, but lets `go vet` pass.
}
}
func Benchmark_Stringf(b *testing.B) {
rand := NewGUID()
b.ResetTimer()
for format := range knownFormats {
b.Run(string(format), func(b *testing.B) {
for i := 0; i < b.N; i++ {
rand.Stringf(format)
}
})
}
}
func Benchmark_Parse(b *testing.B) {
rand := NewGUID()
b.ResetTimer()
for format := range knownFormats {
printed := rand.Stringf(format)
b.Run(string(format), func(b *testing.B) {
for i := 0; i < b.N; i++ {
Parse(printed)
}
})
}
}
func ExampleGUID_Stringf() {
fmt.Printf(Empty().Stringf(FormatB))
// Output: {00000000-0000-0000-0000-000000000000}
}
func ExampleGUID_String() {
fmt.Printf(Empty().String())
// Output: 00000000-0000-0000-0000-000000000000
}
func ExampleEmpty() {
var example GUID
if example == Empty() {
fmt.Print("Example is Empty")
} else {
fmt.Print("Example is not Empty")
}
// Output: Example is Empty
}