File: deep_equals.go

package info (click to toggle)
golang-github-jacobsa-oglematchers 0.0~git20150320-3
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 568 kB
  • sloc: makefile: 3
file content (88 lines) | stat: -rw-r--r-- 2,384 bytes parent folder | download | duplicates (8)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
// Copyright 2012 Aaron Jacobs. All Rights Reserved.
// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package oglematchers

import (
	"bytes"
	"errors"
	"fmt"
	"reflect"
)

var byteSliceType reflect.Type = reflect.TypeOf([]byte{})

// DeepEquals returns a matcher that matches based on 'deep equality', as
// defined by the reflect package. This matcher requires that values have
// identical types to x.
func DeepEquals(x interface{}) Matcher {
	return &deepEqualsMatcher{x}
}

type deepEqualsMatcher struct {
	x interface{}
}

func (m *deepEqualsMatcher) Description() string {
	xDesc := fmt.Sprintf("%v", m.x)
	xValue := reflect.ValueOf(m.x)

	// Special case: fmt.Sprintf presents nil slices as "[]", but
	// reflect.DeepEqual makes a distinction between nil and empty slices. Make
	// this less confusing.
	if xValue.Kind() == reflect.Slice && xValue.IsNil() {
		xDesc = "<nil slice>"
	}

	return fmt.Sprintf("deep equals: %s", xDesc)
}

func (m *deepEqualsMatcher) Matches(c interface{}) error {
	// Make sure the types match.
	ct := reflect.TypeOf(c)
	xt := reflect.TypeOf(m.x)

	if ct != xt {
		return NewFatalError(fmt.Sprintf("which is of type %v", ct))
	}

	// Special case: handle byte slices more efficiently.
	cValue := reflect.ValueOf(c)
	xValue := reflect.ValueOf(m.x)

	if ct == byteSliceType && !cValue.IsNil() && !xValue.IsNil() {
		xBytes := m.x.([]byte)
		cBytes := c.([]byte)

		if bytes.Equal(cBytes, xBytes) {
			return nil
		}

		return errors.New("")
	}

	// Defer to the reflect package.
	if reflect.DeepEqual(m.x, c) {
		return nil
	}

	// Special case: if the comparison failed because c is the nil slice, given
	// an indication of this (since its value is printed as "[]").
	if cValue.Kind() == reflect.Slice && cValue.IsNil() {
		return errors.New("which is nil")
	}

	return errors.New("")
}