Valu("store3", OpStore, types.TypeMem, 0, c.config.Types.Bool, "addr1", "v", "store2"),
			Valu("store4", OpStore, types.TypeMem, 0, c.config.Types.Bool, "addr3", "v", "store3"),
			Goto("exit")),
		Bloc("exit",
			Exit("store3")))

	CheckFunc(fun.f)
	dse(fun.f)
	CheckFunc(fun.f)

	v1 := fun.values["store1"]
	if v1.Op != OpCopy {
		t.Errorf("dead store not removed")
	}

	v2 := fun.values["zero1"]

			fprintf(stderr, "looping too long waiting for signal\n");
			exit(EXIT_FAILURE);
		}
	}

	sigioSeen = 0;

	// Tell the Go code to catch SIGIO.

	if (verbose) {
		fprintf(stderr, "calling dlsym\n");
	}

	catchSIGIO = (void(*)(void))dlsym(handle, "CatchSIGIO");
	if (catchSIGIO == NULL) {
		fprintf(stderr, "%s\n", dlerror());
		exit(EXIT_FAILURE);
	}

	if (verbose) {

                doLast {
                    println("exit value = " + execProvider.result.get().exitValue)
                    println(execProvider.standardOutput.asText.get())
                }
            }
        """

        when:
        runAndFail("-q", ":empty")

        then:
        result.assertHasErrorOutput("finished with non-zero exit value 42")
    }

if [ $failed_count_site1 -ne 0 ]; then
	echo "failed with multipart on site1 uploads"
	exit 1
fi

if [ $failed_count_site2 -ne 0 ]; then
	echo "failed with multipart on site2 uploads"
	exit 1
fi

./mc cp -r --quiet /usr/bin site1/testbucket/

sleep 5

	echo "BUG: ILM expiry rules prefix not replicated to 'siteb'"
	exit 1
fi
if [ "${ntagName1}" != "ntag1" ] || [ "${ntagVal1}" != "nval1" ] || [ "${ntagName2}" != "ntag2" ] || [ "${ntagVal2}" != "nval2" ]; then
	echo "BUG: ILM expiry rules tags not replicated to 'siteb'"
	exit 1
fi
if [ "${st}" != "Disabled" ]; then
	echo "BUG: ILM expiry rules status not replicated to 'siteb'"
	exit 1
fi

		// This is used to fail tests that make an early
		// unexpected call to os.Exit(0).
		panic("unexpected call to os.Exit(0) during test")
	}

	// Inform the runtime that os.Exit is being called. If -race is
	// enabled, this will give race detector a chance to fail the
	// program (racy programs do not have the right to finish
	// successfully). If coverage is enabled, then this call will
	// enable us to write out a coverage data file.

	if (stack1 == NULL) {
		perror("malloc");
		exit(1);
	}

	// Allocate the second stack before freeing the first to ensure we don't get
	// the same address from malloc.
	//
	// Will be freed in stackSwitchThread2.
	stack2 = malloc(STACK_SIZE);
	if (stack1 == NULL) {
		perror("malloc");
		exit(1);
	}

	if (getcontext(&uctx_switch) == -1) {
		perror("getcontext");
		exit(1);
	}
	uctx_switch.uc_stack.ss_sp = stack1;

	echo "BUG: original user count differs from expanded setup"
	exit 1
fi

if [ $policy_count -ne $expanded_policy_count ]; then
	echo "BUG: original policy count  differs from expanded setup"
	exit 1
fi

./mc version info myminio/versioned | grep -q "versioning is enabled"
ret=$?
if [ $ret -ne 0 ]; then
	echo "expected versioning enabled after expansion"
	exit 1
fi

./mc mirror cmd myminio/versioned/ --quiet >/dev/null

		return res
	}
	t.Cleanup(func() {
		if err := check(filter); err != nil {
			t.Errorf("goroutine leak: %v", err)
		}
	})
}

// CheckMain asserts that no goroutines are leaked after a test package exits.
// This can be used with the following code:
//
//	func TestMain(m *testing.M) {
//	    leak.CheckMain(m)
//	}
//

	argv0 := argv[0]
	if filepath.Base(argv0) == argv0 {
		argv0, err = exec.LookPath(argv0)
		if err != nil {
			Exitf("cannot find %s: %v", argv[0], err)
		}
	}
	if ctxt.Debugvlog != 0 {
		ctxt.Logf("invoking archiver with syscall.Exec()\n")
	}
	err = syscall.Exec(argv0, argv, os.Environ())
	if err != nil {
		Exitf("running %s failed: %v", argv[0], err)
	}