_, err := objAPI.GetBucketInfo(ctx, bucket, BucketOptions{})
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	aclHeader := r.Header.Get(xhttp.AmzACL)
	if aclHeader == "" {
		acl := &accessControlPolicy{}
		if err = xmlDecoder(r.Body, acl, r.ContentLength); err != nil {
			if terr, ok := err.(*xml.SyntaxError); ok && terr.Msg == io.EOF.Error() {

      ServiceManagerState state = this.state.get();
      if (state != null) {
        state.transitionService(service, NEW, STARTING);
        if (!(service instanceof NoOpService)) {
          logger.get().log(Level.FINE, "Starting {0}.", service);
        }
      }
    }

    @Override
    public void running() {
      ServiceManagerState state = this.state.get();
      if (state != null) {

    // Log after all static init is finished; if an installed logger uses any Futures methods, it
    // shouldn't break in cases where reflection is missing/broken.
    if (thrownReflectionFailure != null) {
      log.get().log(Level.SEVERE, "SafeAtomicHelper is broken!", thrownReflectionFailure);
    }
  }

  AggregateFutureState(int remainingFutures) {
    this.remainingField = remainingFutures;
  }

                } catch (final IOException e) {
                    throw new IllegalStateException("Failed to get string from the item: " + item, e);
                }
            } catch (final IOException e) {
                throw new IllegalStateException("Failed to get string from the item: " + item, e);
            }
            haveValue = true;
        }

      ReferenceEntry<K, V> expectedEntry = expectedEntries.get(i);
      ReferenceEntry<K, V> actualEntry = actualEntries.get(i);
      assertThat(actualEntry.getKey()).isSameInstanceAs(expectedEntry.getKey());
      assertThat(actualEntry.getValueReference().get())
          .isSameInstanceAs(expectedEntry.getValueReference().get());
    }
  }

      ReferenceEntry<K, V> expectedEntry = expectedEntries.get(i);
      ReferenceEntry<K, V> actualEntry = actualEntries.get(i);
      assertThat(actualEntry.getKey()).isSameInstanceAs(expectedEntry.getKey());
      assertThat(actualEntry.getValueReference().get())
          .isSameInstanceAs(expectedEntry.getValueReference().get());
    }
  }

        resolveReportLocationsOnAdd = true
        taskPathToReports.values.asSequence()
            .flatMap { it }
            .forEach { it.resolve() }
    }

    private val rootBuildDir: File get() = parameters.rootBuildDir.get().asFile

    override fun onFinish(event: FinishEvent) {
        if (event is TaskFinishEvent && taskPathToReports.containsKey(event.descriptor.taskPath)) {
            val taskPath = event.descriptor.taskPath

        // Escaped quotes within quoted value - DOES NOT get unquoted because pattern doesn't match
        value = "\"value with \"\"escaped\"\" quotes\"";
        result = KuromojiCSVUtil.parse(value);
        assertEquals(1, result.length);
        assertEquals("\"value with \"\"escaped\"\" quotes\"", result[0]);

        // Multiple escaped quotes - NONE get unquoted because they all contain internal quotes

 * </ul>
 *
 * <p>The client supports URLs in the format: {@code gcs://bucket-name/object-path}
 *
 * <p>Features:
 * <ul>
 *   <li>Automatic initialization of GCS client</li>
 *   <li>Support for HEAD and GET operations</li>
 *   <li>Content length validation</li>
 *   <li>MIME type detection</li>
 *   <li>Handling of large files through temporary file storage</li>
 *   <li>Object metadata retrieval</li>

  public void testPutAllAddsAtEndInOrder() {
    List<V> values = asList(v3(), v1(), v4());

    for (K k : sampleKeys()) {
      resetContainer();

      List<V> expectedValues = copyToList(multimap().get(k));

      assertTrue(multimap().putAll(k, values));
      expectedValues.addAll(values);

      assertGet(k, expectedValues);
    }
  }