success:    false,
		},
	}

	for i, testCase := range testCases {
		t.Run(fmt.Sprintf("case-%d", i+1), func(t *testing.T) {
			_, err := NewReader(context.Background(), testCase.src, testCase.size, testCase.md5hex, testCase.sha256hex, testCase.actualSize)
			if err != nil && testCase.success {
				t.Errorf("Test %q: Expected success, but got error %s instead", testCase.desc, err)
			}
			if err == nil && !testCase.success {

			},
			expectedScope: "cluster",
		},
	}

	for _, test := range testCases {
		t.Run(test.name, func(t *testing.T) {
			if CleanScope(test.requestInfo) != test.expectedScope {
				t.Errorf("failed to clean scope: %v", test.requestInfo)
			}
		})
	}
}

func TestCleanFieldValidation(t *testing.T) {
	testCases := []struct {
		name                    string
		url                     *url.URL

	"k8s.io/apiserver/pkg/apis/apiserver"
)

func TestStructure(t *testing.T) {
	root := field.NewPath("resources")
	firstResourcePath := root.Index(0)
	cacheSize := int32(1)
	testCases := []struct {
		desc   string
		in     *apiserver.EncryptionConfiguration
		reload bool
		want   field.ErrorList
	}{{
		desc: "nil encryption config",
		in:   nil,
		want: field.ErrorList{

	}
	for _, testcase := range testcases {
		p := &Parser{l: &Lexer{s: testcase.token, pos: 0}, position: 0}
		p.scan()

		_, err := p.parseOperator()
		if ok := reflect.DeepEqual(testcase.expectedError, err); !ok {
			t.Errorf("\nexpect err [%v], \nactual err [%v]", testcase.expectedError, err)
		}
	}
}

func TestRequirementConstructor(t *testing.T) {

	}
}

func TestRunVersion(t *testing.T) {
	var buf bytes.Buffer
	iface := make(map[string]interface{})
	flagNameOutput := "output"
	cmd := newCmdVersion(&buf)

	testCases := []struct {
		name              string
		flag              string
		expectedError     bool
		shouldBeValidYAML bool
		shouldBeValidJSON bool
	}{
		{
			name: "valid: run without flags",
		},
		{

*/

package kernel

import (
	"errors"
	"testing"

	"github.com/stretchr/testify/assert"

	"k8s.io/apimachinery/pkg/util/version"
)

func TestGetVersion(t *testing.T) {
	testCases := []struct {
		name         string
		readFileFunc readFileFunc
		expected     *version.Version
		err          error
	}{
		{
			name: "valid os-release file",
			readFileFunc: func(_ string) ([]byte, error) {

limitations under the License.
*/

package meta

import (
	"errors"
	"fmt"
	"testing"

	"k8s.io/apimachinery/pkg/runtime/schema"
)

func TestErrorMatching(t *testing.T) {
	testCases := []struct {
		name string
		// input should contain an error that is _not_ empty, otherwise the naive reflectlite.DeepEqual matching of

// limitations under the License.

package namespace

import (
	"testing"

	. "github.com/onsi/gomega"
)

func TestConfigRevisionOverwrite(t *testing.T) {
	testCases := []struct {
		name string

		// test inputs.
		revision string
		cfg      Config

		// expected results.
		wantRevision string
	}{
		{
			name:     "NoOverwriteEmptyInput",
			revision: "",

			getIPNet("10.0.0.0/24"),
			false,
		},
	}

	for _, tc := range testCases {
		if tc.expect != IPNetEqual(tc.ipnet1, tc.ipnet2) {
			t.Errorf("Expect equality of %s and %s be to %v", tc.ipnet1.String(), tc.ipnet2.String(), tc.expect)
		}
	}
}

func TestIsConnectionRefused(t *testing.T) {
	testCases := []struct {
		err    error
		expect bool
	}{
		{

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package lifecycle

import "testing"

func Test_NoncurrentVersionsExpiration_Validation(t *testing.T) {
	testcases := []struct {
		n   NoncurrentVersionExpiration
		err error
	}{
		{
			n: NoncurrentVersionExpiration{
				NoncurrentDays:          0,
				NewerNoncurrentVersions: 0,
				set:                     true,
			},