}

func f(c chan struct{}) {
	var x atomic.Value

	go func() {
		x.Swap(one) // writing using the old marker
	}()
	for i := 0; i < 100000; i++ {
		v := x.Load() // reading using the new marker

		p := (*eface)(unsafe.Pointer(&v)).typ
		if uintptr(p) == ^uintptr(0) {
			// We read the old marker, which the new reader
			// doesn't know is a case where it should retry
			// instead of returning it.

    public boolean isTraceEnabled(Marker marker) {
        return false;
    }

    public void trace(Marker marker, String msg) {}

    public void trace(Marker marker, String format, Object arg) {}

    public void trace(Marker marker, String format, Object arg1, Object arg2) {}

    public void trace(Marker marker, String format, Object... argArray) {}

                    def startMarkerFile = file("start.marker")
                    startMarkerFile << new Date().toString()
                    println "start marker written (\$startMarkerFile)"

                    def stopMarkerFile = file("stop.marker")
                    def startedAt = System.currentTimeMillis()
                    println "waiting for stop marker (\$stopMarkerFile)"

	// elems[RelocString][stringsIdx[s]] == s (if present).
	stringsIdx map[string]Index

	// syncFrames is the number of frames to write at each sync
	// marker. A negative value means sync markers are omitted.
	syncFrames int
}

// SyncMarkers reports whether pw uses sync markers.
func (pw *PkgEncoder) SyncMarkers() bool { return pw.syncFrames >= 0 }

// NewPkgEncoder returns an initialized PkgEncoder.
//

    static final FORBIDDEN = "_FORBIDDEN"
    static final DOES_NOT_EXIST = "_DOES_NOT_EXIST"

    static forbidden(String marker) {
        marker == FORBIDDEN
    }

    static doesNotExist(String marker) {
        marker == DOES_NOT_EXIST
    }

    static valid(String marker) {
        marker == VALID
    }

    static deprecated(String alternatives) {
        !(alternatives in [VALID, FORBIDDEN, DOES_NOT_EXIST])

![delete](https://raw.githubusercontent.com/minio/minio/master/docs/bucket/versioning/versioning_DELETE_versionEnabled.png)

	}
	return a
}

var (
	newlineMarker = []byte("\n-- ")
	marker        = []byte("-- ")
	markerEnd     = []byte(" --")
)

// findFileMarker finds the next file marker in data,
// extracts the file name, and returns the data before the marker,
// the file name, and the data after the marker.
// If there is no next marker, findFileMarker returns before = fixNL(data), name = "", after = nil.

			return
		}
	} else {
		maxkeys = maxObjectList
	}

	prefix = values.Get("prefix")
	marker = values.Get("marker")
	delimiter = values.Get("delimiter")
	encodingType = values.Get("encoding-type")
	return
}

func getListBucketObjectVersionsArgs(values url.Values) (prefix, marker, delimiter string, maxkeys int, encodingType, versionIDMarker string, errCode APIErrorCode) {
	errCode = ErrNone

type ListMultipartsInfo struct {
	// Together with upload-id-marker, this parameter specifies the multipart upload
	// after which listing should begin.
	KeyMarker string

	// Together with key-marker, specifies the multipart upload after which listing
	// should begin. If key-marker is not specified, the upload-id-marker parameter
	// is ignored.
	UploadIDMarker string

        def t = thrown(IllegalArgumentException)
        t.message == 'Need to provide valid class reference'
    }

    def "does not find marker file for class loaded from outside of JAR"() {
        expect:
        !GradleRuntimeShadedJarDetector.isLoadedFrom(String.class)
    }

    def "can find marker file contained in fat JAR"() {
        given:
        createJarWithMarkerFile(jarFile)
        def clazz = loadClassForJar()