Update c/common to an unreleased version

... to get https://github.com/containers/common/pull/1106 .

Signed-off-by: Miloslav Trmač <mitr@redhat.com>

4 files changed, 106 insertions, 9 deletions

diff --git a/vendor/github.com/onsi/gomega/matchers/be_comparable_to_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_comparable_to_matcher.go
new file mode 100644
index 000000000..8ab4bb919
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_comparable_to_matcher.go
@@ -0,0 +1,49 @@
+package matchers
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/onsi/gomega/format"
+)
+
+type BeComparableToMatcher struct {
+	Expected interface{}
+	Options  cmp.Options
+}
+
+func (matcher *BeComparableToMatcher) Match(actual interface{}) (success bool, matchErr error) {
+	if actual == nil && matcher.Expected == nil {
+		return false, fmt.Errorf("Refusing to compare <nil> to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
+	}
+	// Shortcut for byte slices.
+	// Comparing long byte slices with reflect.DeepEqual is very slow,
+	// so use bytes.Equal if actual and expected are both byte slices.
+	if actualByteSlice, ok := actual.([]byte); ok {
+		if expectedByteSlice, ok := matcher.Expected.([]byte); ok {
+			return bytes.Equal(actualByteSlice, expectedByteSlice), nil
+		}
+	}
+
+	defer func() {
+		if r := recover(); r != nil {
+			success = false
+			if err, ok := r.(error); ok {
+				matchErr = err
+			} else if errMsg, ok := r.(string); ok {
+				matchErr = fmt.Errorf(errMsg)
+			}
+		}
+	}()
+
+	return cmp.Equal(actual, matcher.Expected, matcher.Options...), nil
+}
+
+func (matcher *BeComparableToMatcher) FailureMessage(actual interface{}) (message string) {
+	return cmp.Diff(matcher.Expected, actual, matcher.Options)
+}
+
+func (matcher *BeComparableToMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to equal", matcher.Expected)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_existing_field_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_existing_field_matcher.go
new file mode 100644
index 000000000..b57018745
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_existing_field_matcher.go
@@ -0,0 +1,36 @@
+package matchers
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type HaveExistingFieldMatcher struct {
+	Field string
+}
+
+func (matcher *HaveExistingFieldMatcher) Match(actual interface{}) (success bool, err error) {
+	// we don't care about the field's actual value, just about any error in
+	// trying to find the field (or method).
+	_, err = extractField(actual, matcher.Field, "HaveExistingField")
+	if err == nil {
+		return true, nil
+	}
+	var mferr missingFieldError
+	if errors.As(err, &mferr) {
+		// missing field errors aren't errors in this context, but instead
+		// unsuccessful matches.
+		return false, nil
+	}
+	return false, err
+}
+
+func (matcher *HaveExistingFieldMatcher) FailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected\n%s\nto have field '%s'", format.Object(actual, 1), matcher.Field)
+}
+
+func (matcher *HaveExistingFieldMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected\n%s\nnot to have field '%s'", format.Object(actual, 1), matcher.Field)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_field.go b/vendor/github.com/onsi/gomega/matchers/have_field.go
index e1fe934d5..6989f78c4 100644
--- a/vendor/github.com/onsi/gomega/matchers/have_field.go
+++ b/vendor/github.com/onsi/gomega/matchers/have_field.go
@@ -8,7 +8,16 @@ import (
 	"github.com/onsi/gomega/format"
 )
 
-func extractField(actual interface{}, field string) (interface{}, error) {
+// missingFieldError represents a missing field extraction error that
+// HaveExistingFieldMatcher can ignore, as opposed to other, sever field
+// extraction errors, such as nil pointers, et cetera.
+type missingFieldError string
+
+func (e missingFieldError) Error() string {
+	return string(e)
+}
+
+func extractField(actual interface{}, field string, matchername string) (interface{}, error) {
 	fields := strings.SplitN(field, ".", 2)
 	actualValue := reflect.ValueOf(actual)
 
@@ -16,36 +25,39 @@ func extractField(actual interface{}, field string) (interface{}, error) {
 		actualValue = actualValue.Elem()
 	}
 	if actualValue == (reflect.Value{}) {
-		return nil, fmt.Errorf("HaveField encountered nil while dereferencing a pointer of type %T.", actual)
+		return nil, fmt.Errorf("%s encountered nil while dereferencing a pointer of type %T.", matchername, actual)
 	}
 
 	if actualValue.Kind() != reflect.Struct {
-		return nil, fmt.Errorf("HaveField encountered:\n%s\nWhich is not a struct.", format.Object(actual, 1))
+		return nil, fmt.Errorf("%s encountered:\n%s\nWhich is not a struct.", matchername, format.Object(actual, 1))
 	}
 
 	var extractedValue reflect.Value
 
 	if strings.HasSuffix(fields[0], "()") {
 		extractedValue = actualValue.MethodByName(strings.TrimSuffix(fields[0], "()"))
+		if extractedValue == (reflect.Value{}) && actualValue.CanAddr() {
+			extractedValue = actualValue.Addr().MethodByName(strings.TrimSuffix(fields[0], "()"))
+		}
 		if extractedValue == (reflect.Value{}) {
-			return nil, fmt.Errorf("HaveField could not find method named '%s' in struct of type %T.", fields[0], actual)
+			return nil, missingFieldError(fmt.Sprintf("%s could not find method named '%s' in struct of type %T.", matchername, fields[0], actual))
 		}
 		t := extractedValue.Type()
 		if t.NumIn() != 0 || t.NumOut() != 1 {
-			return nil, fmt.Errorf("HaveField found an invalid method named '%s' in struct of type %T.\nMethods must take no arguments and return exactly one value.", fields[0], actual)
+			return nil, fmt.Errorf("%s found an invalid method named '%s' in struct of type %T.\nMethods must take no arguments and return exactly one value.", matchername, fields[0], actual)
 		}
 		extractedValue = extractedValue.Call([]reflect.Value{})[0]
 	} else {
 		extractedValue = actualValue.FieldByName(fields[0])
 		if extractedValue == (reflect.Value{}) {
-			return nil, fmt.Errorf("HaveField could not find field named '%s' in struct:\n%s", fields[0], format.Object(actual, 1))
+			return nil, missingFieldError(fmt.Sprintf("%s could not find field named '%s' in struct:\n%s", matchername, fields[0], format.Object(actual, 1)))
 		}
 	}
 
 	if len(fields) == 1 {
 		return extractedValue.Interface(), nil
 	} else {
-		return extractField(extractedValue.Interface(), fields[1])
+		return extractField(extractedValue.Interface(), fields[1], matchername)
 	}
 }
 
@@ -58,7 +70,7 @@ type HaveFieldMatcher struct {
 }
 
 func (matcher *HaveFieldMatcher) Match(actual interface{}) (success bool, err error) {
-	matcher.extractedField, err = extractField(actual, matcher.Field)
+	matcher.extractedField, err = extractField(actual, matcher.Field, "HaveField")
 	if err != nil {
 		return false, err
 	}
diff --git a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
index 0c83c2b63..2cb6b47db 100644
--- a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
@@ -5,7 +5,7 @@ import (
 	"strings"
 
 	"github.com/onsi/gomega/format"
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 type MatchYAMLMatcher struct {