## Get started

If you're aware of stand-alone MinIO set up, the process remains largely the same. MinIO server automatically switches to stand-alone or distributed mode, depending on the command line parameters.

### 1. Prerequisites

Install MinIO either on Kubernetes or Distributed Linux.

// best approach was for Go to raise the limit unconditionally for itself,
// and then leave old software to set the limit back as needed.
// Code that really wants Go to leave the limit alone can set the hard limit,
// which Go of course has no choice but to respect.
func init() {
	var lim Rlimit
	if err := Getrlimit(RLIMIT_NOFILE, &lim); err == nil && lim.Cur != lim.Max {
		origRlimitNofile.Store(&lim)

        and:
        succeeds ":integTest"
        assertIntegTestsExecuted()

        then:
        executedAndNotSkipped ":integTest"
    }
    // endregion all suites

    // region stand-alone test tasks
    def "can toggle framework multiple times on custom test task unrelated to suites"() {
        given:
        buildFile << """
        tasks.register('integTest', Test) {
           useJUnitPlatform()

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Embedding of stand-alone type parameters is not permitted.

package p

type (
        _[P any] interface{ *P | []P | chan P | map[string]P }
        _[P any] interface{ P /* ERROR "term cannot be a type parameter" */ }

		// Must include three segments to specify scheme
		return scheme + ":" + name + ":" + port
	}
	if len(port) > 0 {
		// Must include two segments to specify port
		return name + ":" + port
	}
	// Return name alone
	return name

				}

				if !Identical(u, t.typ) {
					check.errorf(tlist[i], InvalidUnion, "invalid use of ~ (underlying type of %s is %s)", t.typ, u)
					continue
				}
			}

			// Stand-alone embedded interfaces are ok and are handled by the single-type case
			// in the beginning. Embedded interfaces with tilde are excluded above. If we reach

    if (is_ignored_op(&op)) {
      continue;
    }
    std::string target_name = get_target(&op);

    // If no cluster of same target has been formed yet, create a new cluster
    // with op alone.
    auto it = nearest_clusters.find(target_name);
    if (it == nearest_clusters.end()) {
      SetVector<Operation*> new_cluster_op_set;
      new_cluster_op_set.insert(&op);

				}

				if !Identical(u, t.typ) {
					check.errorf(tlist[i], InvalidUnion, "invalid use of ~ (underlying type of %s is %s)", t.typ, u)
					continue
				}
			}

			// Stand-alone embedded interfaces are ok and are handled by the single-type case
			// in the beginning. Embedded interfaces with tilde are excluded above. If we reach

	f := f1[int]
	f(int(0), new(int))
	f1(int(0), new(int))
}

func f2[A any, B interface{[]A}](A, B) {}
func _() {
	f := f2[byte]
	f(byte(0), []byte{})
	f2(byte(0), []byte{})
}

// Embedding stand-alone type parameters is not permitted for now. Disabled.
// func f3[A any, B interface{~C}, C interface{~*A}](A, B, C)
// func _() {
// 	f := f3[int]
// 	var x int
// 	f(x, &x, &x)
// 	f3(x, &x, &x)
// }

	// Tilde is not permitted on defined types or interfaces.
	foo int
	bar any
	_ interface{foo}
	_ interface{~ /* ERROR "invalid use of ~" */ foo }
	_ interface{~ /* ERROR "invalid use of ~" */ bar }
)

// Stand-alone type parameters are not permitted as elements or terms in unions.
type (
	_[T interface{ *T } ] struct{}        // ok
	_[T interface{ int | *T } ] struct{}  // ok