excluded_unless bug fix (#1307)

## Fixes Or Enhances

The verbiage in the documentation for both `excluded_unless` and
`required_unless` is very similar. One would expect the opposite
behavior for each when using multiple values of the same field that is
being validated against.

For example:

This fails in all 3  cases in sample code
```go
package main

import (
	"fmt"
	"github.com/go-playground/validator/v10"
)


type TestStruct struct {
	Foo int
	Bar string `validate:"excluded_unless=Foo 1 Foo 2"`
}

func main() {

	validator := validator.New()

	testA := TestStruct{
		Foo: 1,
		Bar: "test",
	}
	testB := TestStruct{
		Foo: 2,
		Bar: "test",
	}
	testC := TestStruct{
		Foo: 3,
		Bar: "test",
	}

	err := validator.Struct(testA)
	if err != nil {
		fmt.Println(err.Error())
	}

	err = validator.Struct(testB)
	if err != nil {
		fmt.Println(err.Error())
	}

	err = validator.Struct(testC)
	if err != nil {
		fmt.Println(err.Error())
	}

}
```

However, the equivilant opposite of this only fails in TestC

```go
type TestStruct struct {
	Foo int
	Bar string `validate:"required_unless=Foo 1 Foo 2"`
}

func main() {

	validator := validator.New()

	testA := TestStruct{
		Foo: 1,
	}
	testB := TestStruct{
		Foo: 2,
	}
	
	err := validator.Struct(testA)
	if err != nil {
		fmt.Println(err.Error())
	}

	err = validator.Struct(testB)
	if err != nil {
		fmt.Println(err.Error())
	}

}
```

resolves #1306

Author: chargraves85

baked_in.go

@@ -1989,11 +1989,12 @@ func excludedUnless(fl FieldLevel) bool {
 		panic(fmt.Sprintf("Bad param number for excluded_unless %s", fl.FieldName()))
 	}
 	for i := 0; i < len(params); i += 2 {
-		if !requireCheckFieldValue(fl, params[i], params[i+1], false) {
-			return !hasValue(fl)
+		if requireCheckFieldValue(fl, params[i], params[i+1], false) {
+			return true
 		}
 	}
-	return true
+
+	return !hasValue(fl)
 }
 
 // excludedWith is the validation function

validator_test.go

@@ -11443,6 +11443,21 @@ func TestRequiredUnless(t *testing.T) {
 	}
 	errs = validate.Struct(test6)
 	NotEqual(t, errs, nil)
+
+	test7 := struct {
+		Field1 int
+		Field2 string `validate:"required_unless=Field1 1 Field1 2"`
+		Field3 int
+		Field4 string `validate:"required_unless=Field3 1 Field3 2"`
+	}{
+		Field1: 1,
+		Field3: 3,
+	}
+
+	errs = validate.Struct(test7)
+	NotEqual(t, errs, nil)
+
+	AssertError(t, errs, "Field4", "Field4", "Field4", "Field4", "required_unless")
 }
 
 func TestSkipUnless(t *testing.T) {
@@ -12474,6 +12489,26 @@ func TestExcludedUnless(t *testing.T) {
 		Inner: &Inner{Field: &fieldVal},
 	}
 	_ = validate.Struct(panicTest)
+
+	test9 := struct {
+		Field1 int
+		Field2 string `validate:"excluded_unless=Field1 1 Field1 2"`
+		Field3 int
+		Field4 string `validate:"excluded_unless=Field3 1 Field3 2"`
+	}{
+		Field1: 1,
+		Field2: "foo",
+		Field3: 3,
+		Field4: "foo",
+	}
+
+	errs = validate.Struct(test9)
+	NotEqual(t, errs, nil)
+
+	ve = errs.(ValidationErrors)
+	Equal(t, len(ve), 1)
+
+	AssertError(t, errs, "Field4", "Field4", "Field4", "Field4", "excluded_unless")
 }
 
 func TestLookup(t *testing.T) {