1package assert 2 3import ( 4 "bufio" 5 "bytes" 6 "encoding/json" 7 "errors" 8 "fmt" 9 "math" 10 "os" 11 "reflect" 12 "regexp" 13 "runtime" 14 "strings" 15 "time" 16 "unicode" 17 "unicode/utf8" 18 19 "github.com/davecgh/go-spew/spew" 20 "github.com/pmezard/go-difflib/difflib" 21) 22 23//go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_format.go.tmpl 24 25// TestingT is an interface wrapper around *testing.T 26type TestingT interface { 27 Errorf(format string, args ...interface{}) 28} 29 30// ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful 31// for table driven tests. 32type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) bool 33 34// ValueAssertionFunc is a common function prototype when validating a single value. Can be useful 35// for table driven tests. 36type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) bool 37 38// BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful 39// for table driven tests. 40type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool 41 42// ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful 43// for table driven tests. 44type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool 45 46// Comparison a custom function that returns true on success and false on failure 47type Comparison func() (success bool) 48 49/* 50 Helper functions 51*/ 52 53// ObjectsAreEqual determines if two objects are considered equal. 54// 55// This function does no assertion of any kind. 56func ObjectsAreEqual(expected, actual interface{}) bool { 57 if expected == nil || actual == nil { 58 return expected == actual 59 } 60 61 exp, ok := expected.([]byte) 62 if !ok { 63 return reflect.DeepEqual(expected, actual) 64 } 65 66 act, ok := actual.([]byte) 67 if !ok { 68 return false 69 } 70 if exp == nil || act == nil { 71 return exp == nil && act == nil 72 } 73 return bytes.Equal(exp, act) 74} 75 76// ObjectsAreEqualValues gets whether two objects are equal, or if their 77// values are equal. 78func ObjectsAreEqualValues(expected, actual interface{}) bool { 79 if ObjectsAreEqual(expected, actual) { 80 return true 81 } 82 83 actualType := reflect.TypeOf(actual) 84 if actualType == nil { 85 return false 86 } 87 expectedValue := reflect.ValueOf(expected) 88 if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) { 89 // Attempt comparison after type conversion 90 return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual) 91 } 92 93 return false 94} 95 96/* CallerInfo is necessary because the assert functions use the testing object 97internally, causing it to print the file:line of the assert method, rather than where 98the problem actually occurred in calling code.*/ 99 100// CallerInfo returns an array of strings containing the file and line number 101// of each stack frame leading from the current test to the assert call that 102// failed. 103func CallerInfo() []string { 104 105 pc := uintptr(0) 106 file := "" 107 line := 0 108 ok := false 109 name := "" 110 111 callers := []string{} 112 for i := 0; ; i++ { 113 pc, file, line, ok = runtime.Caller(i) 114 if !ok { 115 // The breaks below failed to terminate the loop, and we ran off the 116 // end of the call stack. 117 break 118 } 119 120 // This is a huge edge case, but it will panic if this is the case, see #180 121 if file == "<autogenerated>" { 122 break 123 } 124 125 f := runtime.FuncForPC(pc) 126 if f == nil { 127 break 128 } 129 name = f.Name() 130 131 // testing.tRunner is the standard library function that calls 132 // tests. Subtests are called directly by tRunner, without going through 133 // the Test/Benchmark/Example function that contains the t.Run calls, so 134 // with subtests we should break when we hit tRunner, without adding it 135 // to the list of callers. 136 if name == "testing.tRunner" { 137 break 138 } 139 140 parts := strings.Split(file, "/") 141 file = parts[len(parts)-1] 142 if len(parts) > 1 { 143 dir := parts[len(parts)-2] 144 if (dir != "assert" && dir != "mock" && dir != "require") || file == "mock_test.go" { 145 callers = append(callers, fmt.Sprintf("%s:%d", file, line)) 146 } 147 } 148 149 // Drop the package 150 segments := strings.Split(name, ".") 151 name = segments[len(segments)-1] 152 if isTest(name, "Test") || 153 isTest(name, "Benchmark") || 154 isTest(name, "Example") { 155 break 156 } 157 } 158 159 return callers 160} 161 162// Stolen from the `go test` tool. 163// isTest tells whether name looks like a test (or benchmark, according to prefix). 164// It is a Test (say) if there is a character after Test that is not a lower-case letter. 165// We don't want TesticularCancer. 166func isTest(name, prefix string) bool { 167 if !strings.HasPrefix(name, prefix) { 168 return false 169 } 170 if len(name) == len(prefix) { // "Test" is ok 171 return true 172 } 173 rune, _ := utf8.DecodeRuneInString(name[len(prefix):]) 174 return !unicode.IsLower(rune) 175} 176 177func messageFromMsgAndArgs(msgAndArgs ...interface{}) string { 178 if len(msgAndArgs) == 0 || msgAndArgs == nil { 179 return "" 180 } 181 if len(msgAndArgs) == 1 { 182 msg := msgAndArgs[0] 183 if msgAsStr, ok := msg.(string); ok { 184 return msgAsStr 185 } 186 return fmt.Sprintf("%+v", msg) 187 } 188 if len(msgAndArgs) > 1 { 189 return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...) 190 } 191 return "" 192} 193 194// Aligns the provided message so that all lines after the first line start at the same location as the first line. 195// Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab). 196// The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the 197// basis on which the alignment occurs). 198func indentMessageLines(message string, longestLabelLen int) string { 199 outBuf := new(bytes.Buffer) 200 201 for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ { 202 // no need to align first line because it starts at the correct location (after the label) 203 if i != 0 { 204 // append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab 205 outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t") 206 } 207 outBuf.WriteString(scanner.Text()) 208 } 209 210 return outBuf.String() 211} 212 213type failNower interface { 214 FailNow() 215} 216 217// FailNow fails test 218func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { 219 if h, ok := t.(tHelper); ok { 220 h.Helper() 221 } 222 Fail(t, failureMessage, msgAndArgs...) 223 224 // We cannot extend TestingT with FailNow() and 225 // maintain backwards compatibility, so we fallback 226 // to panicking when FailNow is not available in 227 // TestingT. 228 // See issue #263 229 230 if t, ok := t.(failNower); ok { 231 t.FailNow() 232 } else { 233 panic("test failed and t is missing `FailNow()`") 234 } 235 return false 236} 237 238// Fail reports a failure through 239func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { 240 if h, ok := t.(tHelper); ok { 241 h.Helper() 242 } 243 content := []labeledContent{ 244 {"Error Trace", strings.Join(CallerInfo(), "\n\t\t\t")}, 245 {"Error", failureMessage}, 246 } 247 248 // Add test name if the Go version supports it 249 if n, ok := t.(interface { 250 Name() string 251 }); ok { 252 content = append(content, labeledContent{"Test", n.Name()}) 253 } 254 255 message := messageFromMsgAndArgs(msgAndArgs...) 256 if len(message) > 0 { 257 content = append(content, labeledContent{"Messages", message}) 258 } 259 260 t.Errorf("\n%s", ""+labeledOutput(content...)) 261 262 return false 263} 264 265type labeledContent struct { 266 label string 267 content string 268} 269 270// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner: 271// 272// \t{{label}}:{{align_spaces}}\t{{content}}\n 273// 274// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label. 275// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this 276// alignment is achieved, "\t{{content}}\n" is added for the output. 277// 278// If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line. 279func labeledOutput(content ...labeledContent) string { 280 longestLabel := 0 281 for _, v := range content { 282 if len(v.label) > longestLabel { 283 longestLabel = len(v.label) 284 } 285 } 286 var output string 287 for _, v := range content { 288 output += "\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n" 289 } 290 return output 291} 292 293// Implements asserts that an object is implemented by the specified interface. 294// 295// assert.Implements(t, (*MyInterface)(nil), new(MyObject)) 296func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { 297 if h, ok := t.(tHelper); ok { 298 h.Helper() 299 } 300 interfaceType := reflect.TypeOf(interfaceObject).Elem() 301 302 if object == nil { 303 return Fail(t, fmt.Sprintf("Cannot check if nil implements %v", interfaceType), msgAndArgs...) 304 } 305 if !reflect.TypeOf(object).Implements(interfaceType) { 306 return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...) 307 } 308 309 return true 310} 311 312// IsType asserts that the specified objects are of the same type. 313func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool { 314 if h, ok := t.(tHelper); ok { 315 h.Helper() 316 } 317 318 if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) { 319 return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...) 320 } 321 322 return true 323} 324 325// Equal asserts that two objects are equal. 326// 327// assert.Equal(t, 123, 123) 328// 329// Pointer variable equality is determined based on the equality of the 330// referenced values (as opposed to the memory addresses). Function equality 331// cannot be determined and will always fail. 332func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { 333 if h, ok := t.(tHelper); ok { 334 h.Helper() 335 } 336 if err := validateEqualArgs(expected, actual); err != nil { 337 return Fail(t, fmt.Sprintf("Invalid operation: %#v == %#v (%s)", 338 expected, actual, err), msgAndArgs...) 339 } 340 341 if !ObjectsAreEqual(expected, actual) { 342 diff := diff(expected, actual) 343 expected, actual = formatUnequalValues(expected, actual) 344 return Fail(t, fmt.Sprintf("Not equal: \n"+ 345 "expected: %s\n"+ 346 "actual : %s%s", expected, actual, diff), msgAndArgs...) 347 } 348 349 return true 350 351} 352 353// formatUnequalValues takes two values of arbitrary types and returns string 354// representations appropriate to be presented to the user. 355// 356// If the values are not of like type, the returned strings will be prefixed 357// with the type name, and the value will be enclosed in parenthesis similar 358// to a type conversion in the Go grammar. 359func formatUnequalValues(expected, actual interface{}) (e string, a string) { 360 if reflect.TypeOf(expected) != reflect.TypeOf(actual) { 361 return fmt.Sprintf("%T(%#v)", expected, expected), 362 fmt.Sprintf("%T(%#v)", actual, actual) 363 } 364 365 return fmt.Sprintf("%#v", expected), 366 fmt.Sprintf("%#v", actual) 367} 368 369// EqualValues asserts that two objects are equal or convertable to the same types 370// and equal. 371// 372// assert.EqualValues(t, uint32(123), int32(123)) 373func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { 374 if h, ok := t.(tHelper); ok { 375 h.Helper() 376 } 377 378 if !ObjectsAreEqualValues(expected, actual) { 379 diff := diff(expected, actual) 380 expected, actual = formatUnequalValues(expected, actual) 381 return Fail(t, fmt.Sprintf("Not equal: \n"+ 382 "expected: %s\n"+ 383 "actual : %s%s", expected, actual, diff), msgAndArgs...) 384 } 385 386 return true 387 388} 389 390// Exactly asserts that two objects are equal in value and type. 391// 392// assert.Exactly(t, int32(123), int64(123)) 393func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { 394 if h, ok := t.(tHelper); ok { 395 h.Helper() 396 } 397 398 aType := reflect.TypeOf(expected) 399 bType := reflect.TypeOf(actual) 400 401 if aType != bType { 402 return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...) 403 } 404 405 return Equal(t, expected, actual, msgAndArgs...) 406 407} 408 409// NotNil asserts that the specified object is not nil. 410// 411// assert.NotNil(t, err) 412func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { 413 if h, ok := t.(tHelper); ok { 414 h.Helper() 415 } 416 if !isNil(object) { 417 return true 418 } 419 return Fail(t, "Expected value not to be nil.", msgAndArgs...) 420} 421 422// containsKind checks if a specified kind in the slice of kinds. 423func containsKind(kinds []reflect.Kind, kind reflect.Kind) bool { 424 for i := 0; i < len(kinds); i++ { 425 if kind == kinds[i] { 426 return true 427 } 428 } 429 430 return false 431} 432 433// isNil checks if a specified object is nil or not, without Failing. 434func isNil(object interface{}) bool { 435 if object == nil { 436 return true 437 } 438 439 value := reflect.ValueOf(object) 440 kind := value.Kind() 441 isNilableKind := containsKind( 442 []reflect.Kind{ 443 reflect.Chan, reflect.Func, 444 reflect.Interface, reflect.Map, 445 reflect.Ptr, reflect.Slice}, 446 kind) 447 448 if isNilableKind && value.IsNil() { 449 return true 450 } 451 452 return false 453} 454 455// Nil asserts that the specified object is nil. 456// 457// assert.Nil(t, err) 458func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { 459 if h, ok := t.(tHelper); ok { 460 h.Helper() 461 } 462 if isNil(object) { 463 return true 464 } 465 return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...) 466} 467 468// isEmpty gets whether the specified object is considered empty or not. 469func isEmpty(object interface{}) bool { 470 471 // get nil case out of the way 472 if object == nil { 473 return true 474 } 475 476 objValue := reflect.ValueOf(object) 477 478 switch objValue.Kind() { 479 // collection types are empty when they have no element 480 case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: 481 return objValue.Len() == 0 482 // pointers are empty if nil or if the value they point to is empty 483 case reflect.Ptr: 484 if objValue.IsNil() { 485 return true 486 } 487 deref := objValue.Elem().Interface() 488 return isEmpty(deref) 489 // for all other types, compare against the zero value 490 default: 491 zero := reflect.Zero(objValue.Type()) 492 return reflect.DeepEqual(object, zero.Interface()) 493 } 494} 495 496// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either 497// a slice or a channel with len == 0. 498// 499// assert.Empty(t, obj) 500func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { 501 if h, ok := t.(tHelper); ok { 502 h.Helper() 503 } 504 505 pass := isEmpty(object) 506 if !pass { 507 Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...) 508 } 509 510 return pass 511 512} 513 514// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either 515// a slice or a channel with len == 0. 516// 517// if assert.NotEmpty(t, obj) { 518// assert.Equal(t, "two", obj[1]) 519// } 520func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { 521 if h, ok := t.(tHelper); ok { 522 h.Helper() 523 } 524 525 pass := !isEmpty(object) 526 if !pass { 527 Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...) 528 } 529 530 return pass 531 532} 533 534// getLen try to get length of object. 535// return (false, 0) if impossible. 536func getLen(x interface{}) (ok bool, length int) { 537 v := reflect.ValueOf(x) 538 defer func() { 539 if e := recover(); e != nil { 540 ok = false 541 } 542 }() 543 return true, v.Len() 544} 545 546// Len asserts that the specified object has specific length. 547// Len also fails if the object has a type that len() not accept. 548// 549// assert.Len(t, mySlice, 3) 550func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool { 551 if h, ok := t.(tHelper); ok { 552 h.Helper() 553 } 554 ok, l := getLen(object) 555 if !ok { 556 return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...) 557 } 558 559 if l != length { 560 return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...) 561 } 562 return true 563} 564 565// True asserts that the specified value is true. 566// 567// assert.True(t, myBool) 568func True(t TestingT, value bool, msgAndArgs ...interface{}) bool { 569 if h, ok := t.(tHelper); ok { 570 h.Helper() 571 } 572 if h, ok := t.(interface { 573 Helper() 574 }); ok { 575 h.Helper() 576 } 577 578 if value != true { 579 return Fail(t, "Should be true", msgAndArgs...) 580 } 581 582 return true 583 584} 585 586// False asserts that the specified value is false. 587// 588// assert.False(t, myBool) 589func False(t TestingT, value bool, msgAndArgs ...interface{}) bool { 590 if h, ok := t.(tHelper); ok { 591 h.Helper() 592 } 593 594 if value != false { 595 return Fail(t, "Should be false", msgAndArgs...) 596 } 597 598 return true 599 600} 601 602// NotEqual asserts that the specified values are NOT equal. 603// 604// assert.NotEqual(t, obj1, obj2) 605// 606// Pointer variable equality is determined based on the equality of the 607// referenced values (as opposed to the memory addresses). 608func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { 609 if h, ok := t.(tHelper); ok { 610 h.Helper() 611 } 612 if err := validateEqualArgs(expected, actual); err != nil { 613 return Fail(t, fmt.Sprintf("Invalid operation: %#v != %#v (%s)", 614 expected, actual, err), msgAndArgs...) 615 } 616 617 if ObjectsAreEqual(expected, actual) { 618 return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...) 619 } 620 621 return true 622 623} 624 625// containsElement try loop over the list check if the list includes the element. 626// return (false, false) if impossible. 627// return (true, false) if element was not found. 628// return (true, true) if element was found. 629func includeElement(list interface{}, element interface{}) (ok, found bool) { 630 631 listValue := reflect.ValueOf(list) 632 elementValue := reflect.ValueOf(element) 633 defer func() { 634 if e := recover(); e != nil { 635 ok = false 636 found = false 637 } 638 }() 639 640 if reflect.TypeOf(list).Kind() == reflect.String { 641 return true, strings.Contains(listValue.String(), elementValue.String()) 642 } 643 644 if reflect.TypeOf(list).Kind() == reflect.Map { 645 mapKeys := listValue.MapKeys() 646 for i := 0; i < len(mapKeys); i++ { 647 if ObjectsAreEqual(mapKeys[i].Interface(), element) { 648 return true, true 649 } 650 } 651 return true, false 652 } 653 654 for i := 0; i < listValue.Len(); i++ { 655 if ObjectsAreEqual(listValue.Index(i).Interface(), element) { 656 return true, true 657 } 658 } 659 return true, false 660 661} 662 663// Contains asserts that the specified string, list(array, slice...) or map contains the 664// specified substring or element. 665// 666// assert.Contains(t, "Hello World", "World") 667// assert.Contains(t, ["Hello", "World"], "World") 668// assert.Contains(t, {"Hello": "World"}, "Hello") 669func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { 670 if h, ok := t.(tHelper); ok { 671 h.Helper() 672 } 673 674 ok, found := includeElement(s, contains) 675 if !ok { 676 return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...) 677 } 678 if !found { 679 return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", s, contains), msgAndArgs...) 680 } 681 682 return true 683 684} 685 686// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the 687// specified substring or element. 688// 689// assert.NotContains(t, "Hello World", "Earth") 690// assert.NotContains(t, ["Hello", "World"], "Earth") 691// assert.NotContains(t, {"Hello": "World"}, "Earth") 692func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { 693 if h, ok := t.(tHelper); ok { 694 h.Helper() 695 } 696 697 ok, found := includeElement(s, contains) 698 if !ok { 699 return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...) 700 } 701 if found { 702 return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...) 703 } 704 705 return true 706 707} 708 709// Subset asserts that the specified list(array, slice...) contains all 710// elements given in the specified subset(array, slice...). 711// 712// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") 713func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { 714 if h, ok := t.(tHelper); ok { 715 h.Helper() 716 } 717 if subset == nil { 718 return true // we consider nil to be equal to the nil set 719 } 720 721 subsetValue := reflect.ValueOf(subset) 722 defer func() { 723 if e := recover(); e != nil { 724 ok = false 725 } 726 }() 727 728 listKind := reflect.TypeOf(list).Kind() 729 subsetKind := reflect.TypeOf(subset).Kind() 730 731 if listKind != reflect.Array && listKind != reflect.Slice { 732 return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...) 733 } 734 735 if subsetKind != reflect.Array && subsetKind != reflect.Slice { 736 return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...) 737 } 738 739 for i := 0; i < subsetValue.Len(); i++ { 740 element := subsetValue.Index(i).Interface() 741 ok, found := includeElement(list, element) 742 if !ok { 743 return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...) 744 } 745 if !found { 746 return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", list, element), msgAndArgs...) 747 } 748 } 749 750 return true 751} 752 753// NotSubset asserts that the specified list(array, slice...) contains not all 754// elements given in the specified subset(array, slice...). 755// 756// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") 757func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { 758 if h, ok := t.(tHelper); ok { 759 h.Helper() 760 } 761 if subset == nil { 762 return Fail(t, fmt.Sprintf("nil is the empty set which is a subset of every set"), msgAndArgs...) 763 } 764 765 subsetValue := reflect.ValueOf(subset) 766 defer func() { 767 if e := recover(); e != nil { 768 ok = false 769 } 770 }() 771 772 listKind := reflect.TypeOf(list).Kind() 773 subsetKind := reflect.TypeOf(subset).Kind() 774 775 if listKind != reflect.Array && listKind != reflect.Slice { 776 return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...) 777 } 778 779 if subsetKind != reflect.Array && subsetKind != reflect.Slice { 780 return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...) 781 } 782 783 for i := 0; i < subsetValue.Len(); i++ { 784 element := subsetValue.Index(i).Interface() 785 ok, found := includeElement(list, element) 786 if !ok { 787 return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...) 788 } 789 if !found { 790 return true 791 } 792 } 793 794 return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...) 795} 796 797// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified 798// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, 799// the number of appearances of each of them in both lists should match. 800// 801// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2]) 802func ElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) { 803 if h, ok := t.(tHelper); ok { 804 h.Helper() 805 } 806 if isEmpty(listA) && isEmpty(listB) { 807 return true 808 } 809 810 aKind := reflect.TypeOf(listA).Kind() 811 bKind := reflect.TypeOf(listB).Kind() 812 813 if aKind != reflect.Array && aKind != reflect.Slice { 814 return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listA, aKind), msgAndArgs...) 815 } 816 817 if bKind != reflect.Array && bKind != reflect.Slice { 818 return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listB, bKind), msgAndArgs...) 819 } 820 821 aValue := reflect.ValueOf(listA) 822 bValue := reflect.ValueOf(listB) 823 824 aLen := aValue.Len() 825 bLen := bValue.Len() 826 827 if aLen != bLen { 828 return Fail(t, fmt.Sprintf("lengths don't match: %d != %d", aLen, bLen), msgAndArgs...) 829 } 830 831 // Mark indexes in bValue that we already used 832 visited := make([]bool, bLen) 833 for i := 0; i < aLen; i++ { 834 element := aValue.Index(i).Interface() 835 found := false 836 for j := 0; j < bLen; j++ { 837 if visited[j] { 838 continue 839 } 840 if ObjectsAreEqual(bValue.Index(j).Interface(), element) { 841 visited[j] = true 842 found = true 843 break 844 } 845 } 846 if !found { 847 return Fail(t, fmt.Sprintf("element %s appears more times in %s than in %s", element, aValue, bValue), msgAndArgs...) 848 } 849 } 850 851 return true 852} 853 854// Condition uses a Comparison to assert a complex condition. 855func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool { 856 if h, ok := t.(tHelper); ok { 857 h.Helper() 858 } 859 result := comp() 860 if !result { 861 Fail(t, "Condition failed!", msgAndArgs...) 862 } 863 return result 864} 865 866// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics 867// methods, and represents a simple func that takes no arguments, and returns nothing. 868type PanicTestFunc func() 869 870// didPanic returns true if the function passed to it panics. Otherwise, it returns false. 871func didPanic(f PanicTestFunc) (bool, interface{}) { 872 873 didPanic := false 874 var message interface{} 875 func() { 876 877 defer func() { 878 if message = recover(); message != nil { 879 didPanic = true 880 } 881 }() 882 883 // call the target function 884 f() 885 886 }() 887 888 return didPanic, message 889 890} 891 892// Panics asserts that the code inside the specified PanicTestFunc panics. 893// 894// assert.Panics(t, func(){ GoCrazy() }) 895func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { 896 if h, ok := t.(tHelper); ok { 897 h.Helper() 898 } 899 900 if funcDidPanic, panicValue := didPanic(f); !funcDidPanic { 901 return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...) 902 } 903 904 return true 905} 906 907// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that 908// the recovered panic value equals the expected panic value. 909// 910// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() }) 911func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { 912 if h, ok := t.(tHelper); ok { 913 h.Helper() 914 } 915 916 funcDidPanic, panicValue := didPanic(f) 917 if !funcDidPanic { 918 return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...) 919 } 920 if panicValue != expected { 921 return Fail(t, fmt.Sprintf("func %#v should panic with value:\t%#v\n\tPanic value:\t%#v", f, expected, panicValue), msgAndArgs...) 922 } 923 924 return true 925} 926 927// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. 928// 929// assert.NotPanics(t, func(){ RemainCalm() }) 930func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { 931 if h, ok := t.(tHelper); ok { 932 h.Helper() 933 } 934 935 if funcDidPanic, panicValue := didPanic(f); funcDidPanic { 936 return Fail(t, fmt.Sprintf("func %#v should not panic\n\tPanic value:\t%v", f, panicValue), msgAndArgs...) 937 } 938 939 return true 940} 941 942// WithinDuration asserts that the two times are within duration delta of each other. 943// 944// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second) 945func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { 946 if h, ok := t.(tHelper); ok { 947 h.Helper() 948 } 949 950 dt := expected.Sub(actual) 951 if dt < -delta || dt > delta { 952 return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...) 953 } 954 955 return true 956} 957 958func toFloat(x interface{}) (float64, bool) { 959 var xf float64 960 xok := true 961 962 switch xn := x.(type) { 963 case uint8: 964 xf = float64(xn) 965 case uint16: 966 xf = float64(xn) 967 case uint32: 968 xf = float64(xn) 969 case uint64: 970 xf = float64(xn) 971 case int: 972 xf = float64(xn) 973 case int8: 974 xf = float64(xn) 975 case int16: 976 xf = float64(xn) 977 case int32: 978 xf = float64(xn) 979 case int64: 980 xf = float64(xn) 981 case float32: 982 xf = float64(xn) 983 case float64: 984 xf = float64(xn) 985 case time.Duration: 986 xf = float64(xn) 987 default: 988 xok = false 989 } 990 991 return xf, xok 992} 993 994// InDelta asserts that the two numerals are within delta of each other. 995// 996// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01) 997func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { 998 if h, ok := t.(tHelper); ok { 999 h.Helper() 1000 } 1001 1002 af, aok := toFloat(expected) 1003 bf, bok := toFloat(actual) 1004 1005 if !aok || !bok { 1006 return Fail(t, fmt.Sprintf("Parameters must be numerical"), msgAndArgs...) 1007 } 1008 1009 if math.IsNaN(af) { 1010 return Fail(t, fmt.Sprintf("Expected must not be NaN"), msgAndArgs...) 1011 } 1012 1013 if math.IsNaN(bf) { 1014 return Fail(t, fmt.Sprintf("Expected %v with delta %v, but was NaN", expected, delta), msgAndArgs...) 1015 } 1016 1017 dt := af - bf 1018 if dt < -delta || dt > delta { 1019 return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...) 1020 } 1021 1022 return true 1023} 1024 1025// InDeltaSlice is the same as InDelta, except it compares two slices. 1026func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { 1027 if h, ok := t.(tHelper); ok { 1028 h.Helper() 1029 } 1030 if expected == nil || actual == nil || 1031 reflect.TypeOf(actual).Kind() != reflect.Slice || 1032 reflect.TypeOf(expected).Kind() != reflect.Slice { 1033 return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...) 1034 } 1035 1036 actualSlice := reflect.ValueOf(actual) 1037 expectedSlice := reflect.ValueOf(expected) 1038 1039 for i := 0; i < actualSlice.Len(); i++ { 1040 result := InDelta(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta, msgAndArgs...) 1041 if !result { 1042 return result 1043 } 1044 } 1045 1046 return true 1047} 1048 1049// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. 1050func InDeltaMapValues(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { 1051 if h, ok := t.(tHelper); ok { 1052 h.Helper() 1053 } 1054 if expected == nil || actual == nil || 1055 reflect.TypeOf(actual).Kind() != reflect.Map || 1056 reflect.TypeOf(expected).Kind() != reflect.Map { 1057 return Fail(t, "Arguments must be maps", msgAndArgs...) 1058 } 1059 1060 expectedMap := reflect.ValueOf(expected) 1061 actualMap := reflect.ValueOf(actual) 1062 1063 if expectedMap.Len() != actualMap.Len() { 1064 return Fail(t, "Arguments must have the same number of keys", msgAndArgs...) 1065 } 1066 1067 for _, k := range expectedMap.MapKeys() { 1068 ev := expectedMap.MapIndex(k) 1069 av := actualMap.MapIndex(k) 1070 1071 if !ev.IsValid() { 1072 return Fail(t, fmt.Sprintf("missing key %q in expected map", k), msgAndArgs...) 1073 } 1074 1075 if !av.IsValid() { 1076 return Fail(t, fmt.Sprintf("missing key %q in actual map", k), msgAndArgs...) 1077 } 1078 1079 if !InDelta( 1080 t, 1081 ev.Interface(), 1082 av.Interface(), 1083 delta, 1084 msgAndArgs..., 1085 ) { 1086 return false 1087 } 1088 } 1089 1090 return true 1091} 1092 1093func calcRelativeError(expected, actual interface{}) (float64, error) { 1094 af, aok := toFloat(expected) 1095 if !aok { 1096 return 0, fmt.Errorf("expected value %q cannot be converted to float", expected) 1097 } 1098 if af == 0 { 1099 return 0, fmt.Errorf("expected value must have a value other than zero to calculate the relative error") 1100 } 1101 bf, bok := toFloat(actual) 1102 if !bok { 1103 return 0, fmt.Errorf("actual value %q cannot be converted to float", actual) 1104 } 1105 1106 return math.Abs(af-bf) / math.Abs(af), nil 1107} 1108 1109// InEpsilon asserts that expected and actual have a relative error less than epsilon 1110func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { 1111 if h, ok := t.(tHelper); ok { 1112 h.Helper() 1113 } 1114 actualEpsilon, err := calcRelativeError(expected, actual) 1115 if err != nil { 1116 return Fail(t, err.Error(), msgAndArgs...) 1117 } 1118 if actualEpsilon > epsilon { 1119 return Fail(t, fmt.Sprintf("Relative error is too high: %#v (expected)\n"+ 1120 " < %#v (actual)", epsilon, actualEpsilon), msgAndArgs...) 1121 } 1122 1123 return true 1124} 1125 1126// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. 1127func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { 1128 if h, ok := t.(tHelper); ok { 1129 h.Helper() 1130 } 1131 if expected == nil || actual == nil || 1132 reflect.TypeOf(actual).Kind() != reflect.Slice || 1133 reflect.TypeOf(expected).Kind() != reflect.Slice { 1134 return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...) 1135 } 1136 1137 actualSlice := reflect.ValueOf(actual) 1138 expectedSlice := reflect.ValueOf(expected) 1139 1140 for i := 0; i < actualSlice.Len(); i++ { 1141 result := InEpsilon(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), epsilon) 1142 if !result { 1143 return result 1144 } 1145 } 1146 1147 return true 1148} 1149 1150/* 1151 Errors 1152*/ 1153 1154// NoError asserts that a function returned no error (i.e. `nil`). 1155// 1156// actualObj, err := SomeFunction() 1157// if assert.NoError(t, err) { 1158// assert.Equal(t, expectedObj, actualObj) 1159// } 1160func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { 1161 if h, ok := t.(tHelper); ok { 1162 h.Helper() 1163 } 1164 if err != nil { 1165 return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...) 1166 } 1167 1168 return true 1169} 1170 1171// Error asserts that a function returned an error (i.e. not `nil`). 1172// 1173// actualObj, err := SomeFunction() 1174// if assert.Error(t, err) { 1175// assert.Equal(t, expectedError, err) 1176// } 1177func Error(t TestingT, err error, msgAndArgs ...interface{}) bool { 1178 if h, ok := t.(tHelper); ok { 1179 h.Helper() 1180 } 1181 1182 if err == nil { 1183 return Fail(t, "An error is expected but got nil.", msgAndArgs...) 1184 } 1185 1186 return true 1187} 1188 1189// EqualError asserts that a function returned an error (i.e. not `nil`) 1190// and that it is equal to the provided error. 1191// 1192// actualObj, err := SomeFunction() 1193// assert.EqualError(t, err, expectedErrorString) 1194func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool { 1195 if h, ok := t.(tHelper); ok { 1196 h.Helper() 1197 } 1198 if !Error(t, theError, msgAndArgs...) { 1199 return false 1200 } 1201 expected := errString 1202 actual := theError.Error() 1203 // don't need to use deep equals here, we know they are both strings 1204 if expected != actual { 1205 return Fail(t, fmt.Sprintf("Error message not equal:\n"+ 1206 "expected: %q\n"+ 1207 "actual : %q", expected, actual), msgAndArgs...) 1208 } 1209 return true 1210} 1211 1212// matchRegexp return true if a specified regexp matches a string. 1213func matchRegexp(rx interface{}, str interface{}) bool { 1214 1215 var r *regexp.Regexp 1216 if rr, ok := rx.(*regexp.Regexp); ok { 1217 r = rr 1218 } else { 1219 r = regexp.MustCompile(fmt.Sprint(rx)) 1220 } 1221 1222 return (r.FindStringIndex(fmt.Sprint(str)) != nil) 1223 1224} 1225 1226// Regexp asserts that a specified regexp matches a string. 1227// 1228// assert.Regexp(t, regexp.MustCompile("start"), "it's starting") 1229// assert.Regexp(t, "start...$", "it's not starting") 1230func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { 1231 if h, ok := t.(tHelper); ok { 1232 h.Helper() 1233 } 1234 1235 match := matchRegexp(rx, str) 1236 1237 if !match { 1238 Fail(t, fmt.Sprintf("Expect \"%v\" to match \"%v\"", str, rx), msgAndArgs...) 1239 } 1240 1241 return match 1242} 1243 1244// NotRegexp asserts that a specified regexp does not match a string. 1245// 1246// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") 1247// assert.NotRegexp(t, "^start", "it's not starting") 1248func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { 1249 if h, ok := t.(tHelper); ok { 1250 h.Helper() 1251 } 1252 match := matchRegexp(rx, str) 1253 1254 if match { 1255 Fail(t, fmt.Sprintf("Expect \"%v\" to NOT match \"%v\"", str, rx), msgAndArgs...) 1256 } 1257 1258 return !match 1259 1260} 1261 1262// Zero asserts that i is the zero value for its type. 1263func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { 1264 if h, ok := t.(tHelper); ok { 1265 h.Helper() 1266 } 1267 if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { 1268 return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...) 1269 } 1270 return true 1271} 1272 1273// NotZero asserts that i is not the zero value for its type. 1274func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { 1275 if h, ok := t.(tHelper); ok { 1276 h.Helper() 1277 } 1278 if i == nil || reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { 1279 return Fail(t, fmt.Sprintf("Should not be zero, but was %v", i), msgAndArgs...) 1280 } 1281 return true 1282} 1283 1284// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. 1285func FileExists(t TestingT, path string, msgAndArgs ...interface{}) bool { 1286 if h, ok := t.(tHelper); ok { 1287 h.Helper() 1288 } 1289 info, err := os.Lstat(path) 1290 if err != nil { 1291 if os.IsNotExist(err) { 1292 return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) 1293 } 1294 return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) 1295 } 1296 if info.IsDir() { 1297 return Fail(t, fmt.Sprintf("%q is a directory", path), msgAndArgs...) 1298 } 1299 return true 1300} 1301 1302// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. 1303func DirExists(t TestingT, path string, msgAndArgs ...interface{}) bool { 1304 if h, ok := t.(tHelper); ok { 1305 h.Helper() 1306 } 1307 info, err := os.Lstat(path) 1308 if err != nil { 1309 if os.IsNotExist(err) { 1310 return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) 1311 } 1312 return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) 1313 } 1314 if !info.IsDir() { 1315 return Fail(t, fmt.Sprintf("%q is a file", path), msgAndArgs...) 1316 } 1317 return true 1318} 1319 1320// JSONEq asserts that two JSON strings are equivalent. 1321// 1322// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) 1323func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool { 1324 if h, ok := t.(tHelper); ok { 1325 h.Helper() 1326 } 1327 var expectedJSONAsInterface, actualJSONAsInterface interface{} 1328 1329 if err := json.Unmarshal([]byte(expected), &expectedJSONAsInterface); err != nil { 1330 return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid json.\nJSON parsing error: '%s'", expected, err.Error()), msgAndArgs...) 1331 } 1332 1333 if err := json.Unmarshal([]byte(actual), &actualJSONAsInterface); err != nil { 1334 return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid json.\nJSON parsing error: '%s'", actual, err.Error()), msgAndArgs...) 1335 } 1336 1337 return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...) 1338} 1339 1340func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) { 1341 t := reflect.TypeOf(v) 1342 k := t.Kind() 1343 1344 if k == reflect.Ptr { 1345 t = t.Elem() 1346 k = t.Kind() 1347 } 1348 return t, k 1349} 1350 1351// diff returns a diff of both values as long as both are of the same type and 1352// are a struct, map, slice, array or string. Otherwise it returns an empty string. 1353func diff(expected interface{}, actual interface{}) string { 1354 if expected == nil || actual == nil { 1355 return "" 1356 } 1357 1358 et, ek := typeAndKind(expected) 1359 at, _ := typeAndKind(actual) 1360 1361 if et != at { 1362 return "" 1363 } 1364 1365 if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array && ek != reflect.String { 1366 return "" 1367 } 1368 1369 var e, a string 1370 if et != reflect.TypeOf("") { 1371 e = spewConfig.Sdump(expected) 1372 a = spewConfig.Sdump(actual) 1373 } else { 1374 e = expected.(string) 1375 a = actual.(string) 1376 } 1377 1378 diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{ 1379 A: difflib.SplitLines(e), 1380 B: difflib.SplitLines(a), 1381 FromFile: "Expected", 1382 FromDate: "", 1383 ToFile: "Actual", 1384 ToDate: "", 1385 Context: 1, 1386 }) 1387 1388 return "\n\nDiff:\n" + diff 1389} 1390 1391// validateEqualArgs checks whether provided arguments can be safely used in the 1392// Equal/NotEqual functions. 1393func validateEqualArgs(expected, actual interface{}) error { 1394 if isFunction(expected) || isFunction(actual) { 1395 return errors.New("cannot take func type as argument") 1396 } 1397 return nil 1398} 1399 1400func isFunction(arg interface{}) bool { 1401 if arg == nil { 1402 return false 1403 } 1404 return reflect.TypeOf(arg).Kind() == reflect.Func 1405} 1406 1407var spewConfig = spew.ConfigState{ 1408 Indent: " ", 1409 DisablePointerAddresses: true, 1410 DisableCapacities: true, 1411 SortKeys: true, 1412} 1413 1414type tHelper interface { 1415 Helper() 1416} 1417