func (matcher *MatchYAMLMatcher) equal(expected interface{}, actual interface{}) (bool, string, error) {
actualString, err := matcher.prettyPrint(actual)
if err != nil {
return false, "", err
}
expectedString, err := matcher.prettyPrint(expected)
if err != nil {
return false, "", err
}
var actualValue interface{}
var expectedValue interface{}
// this is guarded by prettyPrint
yaml.Unmarshal([]byte(actualString), &actualValue)
yaml.Unmarshal([]byte(expectedString), &expectedValue)
equal, difference := deepequal.Compare(expectedValue, actualValue)
return equal, prettyprint.ExpectationFailure(difference), nil
}
"uint64": {uint64(1), uint64(2)},
"uintptr": {uintptr(1), uintptr(2)},
"float32": {float32(1.0), float32(2.0)},
"float64": {float64(1.0), float64(2.0)},
"complex64": {complex64(1i), complex64(2i)},
"complex128": {complex128(1i), complex128(2i)},
}
It("returns true when the objects match", func() {
someObject := map[string]interface{}{
"a": 1,
"b": []int{1, 2, 3, 4},
"c": 3,
}
equal, difference := deepequal.Compare(someObject, someObject)
Expect(equal).To(BeTrue())
Expect(difference).To(Equal(diff.NoDifference{}))
})
It("returns a diff when the types are mismatched", func() {
for expectedName, expectedValues := range types {
for actualName, actualValues := range types {
if expectedName != actualName {
equal, difference := deepequal.Compare(expectedValues[0], actualValues[0])
Expect(equal).To(BeFalse())
Expect(difference).To(Equal(diff.PrimitiveTypeMismatch{
ExpectedType: reflect.TypeOf(expectedValues[0]),
ActualValue: actualValues[0],
}))