if strings.Contains(msg, m) {
			return true
		}
	}
	return false
}

// IsExpectedGRPCError checks a gRPC error code and determines whether it is an expected error when
// things are operating normally. This is basically capturing when the client disconnects.
func IsExpectedGRPCError(err error) bool {
	if err == io.EOF {
		return true
	}

	if s, ok := status.FromError(err); ok {

        return daemonStateControl;
    }

    /**
     * Sets what is to be considered the result of executing the command.
     * <p>
     * This may be called multiple times to do things like wrap the result in another type.
     */
    public void setResult(Object result) {
        this.result = result;
    }

    /**
     * The currently nominated result for the execution.
     *

		if Meta.PkgMap == nil {
			Meta.PkgMap = make(map[int]int)
		}
		if _, ok := Meta.PkgMap[pkgid]; ok {
			return 0
		}
		// Record the real slot (position on meta-list) for this
		// package; we'll use the map to fix things up later on.
		Meta.PkgMap[pkgid] = slot
	}

	// ID zero is reserved as invalid.
	return uint32(slot + 1)

// that newer versions of the Macos toolchain (the newer linker in
// particular) appear to compute the UUID based not just on the
// content of the object files being linked but also on things like
// the timestamps/paths of the objects; this makes it
// difficult/impossible to support reproducible builds. Since we try
// hard to maintain build reproducibility for Go, the APIs here

    return 1 == (1 & (filter >> c));
  }

  // This is all essentially copied from ImmutableSet, but we have to duplicate because
  // of dependencies.

  // Represents how tightly we can pack things, as a maximum.
  private static final double DESIRED_LOAD_FACTOR = 0.5;

  /**
   * Returns an array size suitable for the backing array of a hash table that uses open addressing

 * This type will be retired in favor of {@link org.gradle.api.internal.InstantiatorFactory} at some point. Currently it is too tangled with a few things to just remove.
 */
public class DirectInstantiator implements Instantiator {

    /**
     * Please use {@link org.gradle.api.internal.InstantiatorFactory} instead.
     */

assistQueue,
  cpuprof,
  forcegc,
  hchan,
  pollDesc, # pollDesc can interact with timers, which can lock sched.
  scavenge,
  sweep,
  sweepWaiters,
  testR,
  wakeableSleep
# Above SCHED are things that can call into the scheduler.
< SCHED
# Below SCHED is the scheduler implementation.
< allocmR,
  execR;
allocmR, execR, hchan < sched;
sched < allg, allp;

# Channels
NONE < notifyList;

	// istioVersionLabelStr indicates the Istio version of the installation.
	istioVersionLabelStr = name.OperatorAPINamespace + "/version"
)

var (
	// TestMode sets the controller into test mode. Used for unit tests to bypass things like waiting on resources.
	TestMode = false

	scope = log.RegisterScope("installer", "installer")
)

func init() {

fi

set +e

export MC_HOST_minioadm=http://minioadmin:minioadmin@localhost:9100/
./mc ready minioadm

./mc ls minioadm/

./mc admin config set minioadm/ api root_access=off

sleep 3s # let things settle a little

./mc ls minioadm/
if [ $? -eq 0 ]; then
	echo "listing succeeded, 'minioadmin' was not disabled"
	exit 1
fi

set -e

killall -9 minio

export MINIO_API_ROOT_ACCESS=on

        def result = deserialize(serialized)

        then:
        result.method == method
        result.arguments == [1, 2] as Object[]
    }

    interface Thing {
        String doStuff(Thing[] things)
    }

    def "serializes a method invocation with array type parameters"() {
        def method = Thing.class.getMethod("doStuff", Thing[].class)