{
			header: http.Header{
				"Test-1": []string{"123"},
			},
			metadata:   map[string]string{},
			shouldFail: false,
		},
		// Validate that there are all headers extracted
		{
			header: http.Header{
				"X-Amz-Meta-Appid":   []string{"amz-meta"},
				"X-Minio-Meta-Appid": []string{"minio-meta"},
			},
			metadata: map[string]string{
				"X-Amz-Meta-Appid":   "amz-meta",

        return Stream.of(
                Arguments.of(false, new String[] {}, false),
                Arguments.of(true, new String[] {}, true),
                Arguments.of(true, new String[] {"--force-interactive"}, false),
                Arguments.of(true, new String[] {"--force-interactive", "--non-interactive"}, false),
                Arguments.of(true, new String[] {"--force-interactive", "--batch-mode"}, false),

        private final TokenVisitor visitor;
        private final LinkedList<String> elementStack = new LinkedList<String>();
        private final Map<String, String> attributes = new HashMap<String, String>();

        public VisitorImpl(TokenVisitor visitor) {
            this.visitor = visitor;
        }

        private void unwindTo(String element, TokenVisitor visitor) {
            if (elementStack.contains(element)) {

    AtomicLongMap<Object> map = AtomicLongMap.create();
    tester.testAllPublicInstanceMethods(map);
  }

  public void testCreate_map() {
    Map<String, Long> in = ImmutableMap.of("1", 1L, "2", 2L, "3", 3L);
    AtomicLongMap<String> map = AtomicLongMap.create(in);
    assertFalse(map.isEmpty());
    assertEquals(3, map.size());
    assertTrue(map.containsKey("1"));
    assertTrue(map.containsKey("2"));

    RuntimeException exception = new RuntimeException();
    String result = "result";
    SettableFuture<String> future = SettableFuture.create();
    int[] successCalls = new int[1];
    int[] failureCalls = new int[1];
    FutureCallback<String> callback =
        new FutureCallback<String>() {
          @Override
          public void onSuccess(String result) {
            successCalls[0]++;
            throw exception;

        private final String groupId;

        private final String artifactId;

        private final String version;

        RelativeProject(String groupId, String artifactId, String version) {
            this.groupId = groupId;
            this.artifactId = artifactId;
            this.version = version;
        }

        public String getGroupId() {
            return groupId;

    }

    public String getLogMessage() {
        return getId();
    }

    public LocalDateTime getRequestedAt() {
        return getUpdatedAt();
    }

    public void addField(final String key, final Object value) {
        fields.put(key, value);
    }

    @Override
    public Map<String, Object> toSource() {
        final Map<String, Object> sourceMap = super.toSource();

    @Override
    public void fatal(final String message) {
        logger.fatal(message);
    }

    @Override
    public void fatal(final String message, final Throwable t) {
        logger.fatal(message, t);
    }

    @Override
    public boolean isErrorEnabled() {
        return logger.isErrorEnabled();
    }

    @Override
    public void error(final String message) {
        logger.error(message);
    }

      @Override
      protected Multiset<String> create(String[] elements) {
        return unmodifiableMultiset(LinkedHashMultiset.create(asList(elements)));
      }

      @Override
      public List<String> order(List<String> insertionOrder) {
        List<String> order = new ArrayList<>();
        for (String s : insertionOrder) {
          int index = order.indexOf(s);

   * @param replacement the character to append to the result string in place of each matching
   *     character in {@code sequence}
   * @return the new string
   */
  public String replaceFrom(CharSequence sequence, char replacement) {
    String string = sequence.toString();
    int pos = indexIn(string);
    if (pos == -1) {
      return string;
    }
    char[] chars = string.toCharArray();
    chars[pos] = replacement;