}
	if buffered := wr.Buffered(); buffered != wantBuffered {
		t.Fatalf("Buffered = %v; want %v", buffered, wantBuffered)
	}
}

func BenchmarkReaderCopyOptimal(b *testing.B) {
	// Optimal case is where the underlying reader implements io.WriterTo
	srcBuf := bytes.NewBuffer(make([]byte, 8192))
	src := NewReader(srcBuf)
	dstBuf := new(bytes.Buffer)
	dst := onlyWriter{dstBuf}
	for i := 0; i < b.N; i++ {

	smallFileThreshold = 128 * humanize.KiByte // Optimized for NVMe/SSDs

	// For hardrives it is possible to set this to a lower value to avoid any
	// spike in latency. But currently we are simply keeping it optimal for SSDs.

	// bigFileThreshold is the point where we add readahead to put operations.
	bigFileThreshold = 128 * humanize.MiByte

	// XL metadata file carries per object metadata.
	xlStorageFormatFile = "xl.meta"

                }
            }
        };
        Optional<Activation> root = Optional.of(activation);
        stk.push(new ActivationFrame("activation", root));
        root.map(Activation::getFile).ifPresent(fa -> {
            stk.push(new ActivationFrame("file", Optional.of(fa)));
            stk.push(new ActivationFrame("exists", Optional.empty()));
            validator.accept(fa.getExists());

     */
    public static class TextFragment {
        /** Optional prefix text before the target */
        private final String prefix;
        /** Start of the target text */
        private final String textStart;
        /** Optional end of the target text */
        private final String textEnd;
        /** Optional suffix text after the target */
        private final String suffix;

                                "in": "query",
                            }
                        ],
                    }
                },
                "/query/optional": {
                    "get": {
                        "responses": {
                            "200": {
                                "description": "Successful Response",

                    }
                    boolean optional = false;
                    if (!selector.isEmpty() && selector.charAt(0) == '?') {
                        optional = true;
                        selector = selector.substring(1);
                    }
                    projectActivation.addProjectActivation(selector, active, optional);
                }
            }
        }
    }

   *
   * @since 11.0
   */
  public static <T> Optional<T> tryFind(Iterator<T> iterator, Predicate<? super T> predicate) {
    checkNotNull(iterator);
    checkNotNull(predicate);
    while (iterator.hasNext()) {
      T t = iterator.next();
      if (predicate.apply(t)) {
        return Optional.of(t);
      }
    }
    return Optional.absent();
  }

  /**

   *
   * @since 11.0
   */
  public static <T> Optional<T> tryFind(Iterator<T> iterator, Predicate<? super T> predicate) {
    checkNotNull(iterator);
    checkNotNull(predicate);
    while (iterator.hasNext()) {
      T t = iterator.next();
      if (predicate.apply(t)) {
        return Optional.of(t);
      }
    }
    return Optional.absent();
  }

  /**

import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

import org.codelibs.curl.CurlRequest;

                }
            }
        }
        for (Profile profile : interpolatedActivations) {
            Activation activation = profile.getActivation();
            Optional<Activation> a = Optional.ofNullable(activation);
            a.map(Activation::getFile).ifPresent(fa -> {
                Interpolation nt =