echo "A root disk is formatted unexpectedely"
		cat "${WORK_DIR}/server4.log"
		exit -1
	fi
}

function cleanup() {
	pkill minio
	sudo umount ${WORK_DIR}/mnt/disk{1..3}/
	sudo rm /dev/minio-loopdisk*
	rm -rf "$WORK_DIR"
}

(prepare_block_devices)
(main "$@")
rv=$?

cleanup

          ;;
        *)
          echo "Error: Unsupported topology ${TOPOLOGY}" >&2
          exit 1
          ;;
      esac
      shift 2
    ;;
    --topology-config)
      CLUSTER_TOPOLOGY_CONFIG_FILE="${ROOT}/${2}"
      shift 2
    ;;
    -*)
      echo "Error: Unsupported flag $1" >&2
      exit 1
      ;;
    *) # preserve positional arguments
      PARAMS+=("$1")
      shift
      ;;

		echo "FAILED"
		purge "$WORK_DIR"
		exit 1
	done

	if ! ps -p $pid1 1>&2 >/dev/null; then
		echo "server1 log:"
		cat "${WORK_DIR}/dist-minio-server1.log"
		echo "FAILED"
		purge "$WORK_DIR"
		exit 1
	fi

	if ! ps -p $pid2 1>&2 >/dev/null; then
		echo "server2 log:"
		cat "${WORK_DIR}/dist-minio-server2.log"
		echo "FAILED"
		purge "$WORK_DIR"
		exit 1
	fi

	if ! ps -p $pid3 1>&2 >/dev/null; then

# limitations under the License.

./jwt_tool.py "$@"

# The jwt_tool.py always return non-zero exit code, overwrite to just return zero as the test code will check the report
# separately to determine if it has really failed.

	case "":
		return
	case "v1":
		os.Stdout.WriteString(`.string	"go.l__ufer.Run"`)
		os.Exit(0)
	case "v2":
		os.Stdout.WriteString(`.string	"go.l..u00e4ufer.Run"`)
		os.Exit(0)
	case "v3":
		os.Stdout.WriteString(`.string	"go_0l_u00e4ufer.Run"`)
		os.Exit(0)
	case "error":
		os.Stdout.WriteString(`unknown string`)
		os.Exit(0)
	}
}

func TestToSymbolFunc(t *testing.T) {
	testenv.MustHaveExec(t)

		path = os.Args[1]
	} else if len(os.Args) > 2 {
		fmt.Fprintf(os.Stderr, "usage: %s [output directory]\n", os.Args[0])
		os.Exit(1)
	}

	outDir, err := genutils.OutDir(path)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to get output directory: %v\n", err)
		os.Exit(1)
	}

	// Set environment variables used by kubectl so the output is consistent,
	// regardless of where we run.

		if ! bash "${KUBE_ROOT}/hack/${t}.sh" 1> /dev/null; then
			echo -e "${color_red:?}Running ${t} FAILED${color_norm}"
			if ! ${ALL}; then
				exit 1
			fi
		fi
	else
		if ! bash "${KUBE_ROOT}/hack/${t}.sh"; then
			echo -e "${color_red}Running ${t} FAILED${color_norm}"
			if ! ${ALL}; then
				exit 1
			fi
		fi
	fi
done

)

func init() {
	register("CgoCallbackGC", CgoCallbackGC)
}

//export go_callback
func go_callback() {
	if e := extraMInUse.Load(); e == 0 {
		fmt.Printf("in callback extraMInUse got %d want >0\n", e)
		os.Exit(1)
	}

	runtime.GC()
	grow()
	runtime.GC()
}

var cnt int

func grow() {
	x := 10000
	sum := 0
	if grow1(&x, &sum) == 0 {
		panic("bad")
	}
}

func grow1(x, sum *int) int {

}

func main() {
	nf := testing.AllocsPerRun(100, F)
	ng := testing.AllocsPerRun(100, G)
	if int(nf) > 1 {
		fmt.Printf("AllocsPerRun(100, F) = %v, want 1\n", nf)
		os.Exit(1)
	}
	if int(ng) > 1 {
		fmt.Printf("AllocsPerRun(100, G) = %v, want 1\n", ng)
		os.Exit(1)
	}

		base.SetExitStatus(2)
		base.Exit()
	}
	if cfg.BuildRace && cfg.BuildASan {
		fmt.Fprintf(os.Stderr, "go: may not use -race and -asan simultaneously\n")
		base.SetExitStatus(2)
		base.Exit()
	}
	if cfg.BuildMSan && cfg.BuildASan {
		fmt.Fprintf(os.Stderr, "go: may not use -msan and -asan simultaneously\n")
		base.SetExitStatus(2)
		base.Exit()
	}