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 {

		{"text/*,application/json", []string{"text/*", "application/json"}, true},
	}

	for _, testCase := range testCases {
		testCase := testCase
		t.Run(testCase.str, func(t *testing.T) {
			gotPatterns, err := parseCompressIncludes(testCase.str)
			if !testCase.success && err == nil {
				t.Error("expected failure but success instead")
			}
			if testCase.success && err != nil {
				t.Errorf("expected success but failed instead %s", err)
			}

		}
	}

	toObjectNames := func(testCases []testCaseType) []ObjectToDelete {
		names := make([]ObjectToDelete, len(testCases))
		for i := range testCases {
			names[i] = ObjectToDelete{
				ObjectV: ObjectV{
					ObjectName: testCases[i].object,
				},
			}
		}
		return names
	}

	objectNames := toObjectNames(testCases)

		{[]string{"127.0.0.1:9000", nonLoopBackIP + ":9000"}, handler, getCert},
	}

	for i, testCase := range testCases {
		server := NewServer(testCase.addrs).
			UseHandler(testCase.handler)
		if testCase.certFn != nil {
			server = server.UseTLSConfig(&tls.Config{
				PreferServerCipherSuites: true,
				GetCertificate:           testCase.certFn,
			})
		}
		if server == nil {

				"Policy": []string{"policy"},
			},
			expected: ErrNone,
		},
	}

	// Run each test case individually.
	for i, testCase := range testCases {
		_, code := doesPolicySignatureMatch(testCase.form)
		if code != testCase.expected {
			t.Errorf("(%d) expected to get %s, instead got %s", i, niceError(testCase.expected), niceError(code))
		}
	}
}

func TestDoesPresignedSignatureMatch(t *testing.T) {

		},
	}

	t.Parallel()
	for _, testCase := range testCases {
		testCase := testCase
		t.Run(testCase.name, func(t *testing.T) {
			update, err := testCase.meta.validate(testCase.pools)
			if testCase.expectedErr {
				t.Log(err)
			}
			if err != nil && !testCase.expectedErr {
				t.Errorf("Expected success, but found %s", err)
			}
			if err == nil && testCase.expectedErr {

			[]string{"object0"},
		},
	}

	for i, testCase := range testCases {
		err := obj.MakeBucket(context.Background(), testCase.bucketName, MakeBucketOptions{})
		if err != nil {
			t.Fatalf("%s : %s", instanceType, err.Error())
		}

		for _, object := range testCase.objectToUploads {
			md5Bytes := md5.Sum([]byte(object.content))

import (
	"bytes"
	"fmt"
	"io"
	"os"
	"testing"

	"istio.io/istio/pkg/test/util/assert"
)

func TestSDSWriter_ValidCert(t *testing.T) {
	testCases := []struct{ sds string }{
		{sds: "istio"},
		{sds: "spire"},
	}
	for _, tc := range testCases {
		t.Run(tc.sds, func(t *testing.T) {
			configDumpFile, err := os.Open(fmt.Sprintf("testdata/secret/%s/config_dump.json", tc.sds))
			if err != nil {

	}
	for i, testCase := range testCases {
		result, err := obj.GetObjectInfo(context.Background(), testCase.bucketName, testCase.objectName, opts)
		if err != nil && testCase.shouldPass {
			t.Errorf("Test %d: %s: Expected to pass, but failed with: <ERROR> %s", i+1, instanceType, err.Error())
		}
		if err == nil && !testCase.shouldPass {

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

package cmd

import (
	"bytes"
	"testing"
)

func TestValidateBucketSSEConfig(t *testing.T) {
	testCases := []struct {
		inputXML    string
		expectedErr error
		shouldPass  bool
	}{
		// MinIO supported XML
		{
			inputXML: `<ServerSideEncryptionConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">