Function assertOpts

mock/mock.go:1214–1275

(expected, actual interface{})

}

func assertOpts(expected, actual interface{}) (expectedFmt, actualFmt string) {
	expectedOpts := reflect.ValueOf(expected)
	actualOpts := reflect.ValueOf(actual)

	var expectedFuncs []*runtime.Func
	var expectedNames []string
	for i := 0; i < expectedOpts.Len(); i++ {
		f := runtimeFunc(expectedOpts.Index(i).Interface())
		expectedFuncs = append(expectedFuncs, f)
		expectedNames = append(expectedNames, funcName(f))
	}
	var actualFuncs []*runtime.Func
	var actualNames []string
	for i := 0; i < actualOpts.Len(); i++ {
		f := runtimeFunc(actualOpts.Index(i).Interface())
		actualFuncs = append(actualFuncs, f)
		actualNames = append(actualNames, funcName(f))
	}

	if expectedOpts.Len() != actualOpts.Len() {
		expectedFmt = fmt.Sprintf("%v", expectedNames)
		actualFmt = fmt.Sprintf("%v", actualNames)
		return
	}

	for i := 0; i < expectedOpts.Len(); i++ {
		if !isFuncSame(expectedFuncs[i], actualFuncs[i]) {
			expectedFmt = expectedNames[i]
			actualFmt = actualNames[i]
			return
		}

		expectedOpt := expectedOpts.Index(i).Interface()
		actualOpt := actualOpts.Index(i).Interface()

		ot := reflect.TypeOf(expectedOpt)
		var expectedValues []reflect.Value
		var actualValues []reflect.Value
		if ot.NumIn() == 0 {
			return
		}

		for i := 0; i < ot.NumIn(); i++ {
			vt := ot.In(i).Elem()
			expectedValues = append(expectedValues, reflect.New(vt))
			actualValues = append(actualValues, reflect.New(vt))
		}

		reflect.ValueOf(expectedOpt).Call(expectedValues)
		reflect.ValueOf(actualOpt).Call(actualValues)

		for i := 0; i < ot.NumIn(); i++ {
			if expectedArg, actualArg := expectedValues[i].Interface(), actualValues[i].Interface(); !assert.ObjectsAreEqual(expectedArg, actualArg) {
				expectedFmt = fmt.Sprintf("%s(%T) -> %#v", expectedNames[i], expectedArg, expectedArg)
				actualFmt = fmt.Sprintf("%s(%T) -> %#v", expectedNames[i], actualArg, actualArg)
				return
			}
		}