// If `data_.size() + len` is greater than `SIZE_MAX` then the left hand side
  // will overflow to something less than max_length_. After checking `len <=
  // max_length_` we can use this subtraction to check for overflow.
  if (len > max_length_ || data_.size() >= max_length_ - len)
    return absl::ResourceExhaustedError("Buffer overflow");
  data_.resize(data_.size() + len);

  absl::Status AddString(const char* str, size_t len);

  // Fill content into a buffer and returns the number of bytes stored.
  // The function allocates space for the buffer but does NOT take ownership.
  int WriteToBuffer(char** buffer);

 private:
  // Data buffer to store contents of strings, not including headers.
  std::vector<char> data_;

```sh
minio server /data{1...12}
```

Example: Start MinIO server in a 8 drives setup, using MinIO Docker image.

```sh
podman run \
  -p 9000:9000 \
  -p 9001:9001 \
  --name minio \
  -v /mnt/data1:/data1 \
  -v /mnt/data2:/data2 \
  -v /mnt/data3:/data3 \
  -v /mnt/data4:/data4 \
  -v /mnt/data5:/data5 \
  -v /mnt/data6:/data6 \
  -v /mnt/data7:/data7 \
  -v /mnt/data8:/data8 \

    volumes:
      - data2-1:/data1
      - data2-2:/data2
      - data2-3:/data3

  minio3:
    <<: *minio-common
    hostname: minio3
    volumes:
      - data3-1:/data1
      - data3-2:/data2
      - data3-3:/data3

  minio4:
    <<: *minio-common
    hostname: minio4
    volumes:
      - data4-1:/data1
      - data4-2:/data2
      - data4-3:/data3

  nginx:

    volumes:
      - site2-data2-1:/data1
      - site2-data2-2:/data2

  site2-minio3:
    <<: *minio-common
    hostname: site2-minio3
    volumes:
      - site2-data3-1:/data1
      - site2-data3-2:/data2

  site2-minio4:
    <<: *minio-common
    hostname: site2-minio4
    volumes:
      - site2-data4-1:/data1
      - site2-data4-2:/data2

  site2-nginx:
    image: nginx:1.19.2-alpine

    volumes:
      - site1-data2-1:/data1
      - site1-data2-2:/data2

  site1-minio3:
    <<: *minio-common
    hostname: site1-minio3
    volumes:
      - site1-data3-1:/data1
      - site1-data3-2:/data2

  site1-minio4:
    <<: *minio-common
    hostname: site1-minio4
    volumes:
      - site1-data4-1:/data1
      - site1-data4-2:/data2

  site1-nginx:
    image: nginx:1.19.2-alpine

        data1 = connection.receive_text()
        assert data1 == "You wrote: Hello from 1234"
        data2 = connection_two.receive_text()
        client1_says = "Client #1234 says: Hello from 1234"
        assert data2 == client1_says
        data1 = connection.receive_text()
        assert data1 == client1_says
        connection_two.close()
        data1 = connection.receive_text()

    }

    def "single source file moved within hierarchy with #pathSensitive as input is loaded from cache: #expectedOutcome"() {
        given:
        file("src/data1").createDir()
        file("src/data2").createDir()
        file("src/data1/input.txt").text = "input"

        declareTestTaskWithPathSensitivity(pathSensitive)

        buildFile << """
            test {
                sources = fileTree("src")

    <<: *minio-common
    hostname: minio1
    volumes:
      - data1-1:/data1
      - data1-2:/data2

  minio2:
    <<: *minio-common
    hostname: minio2
    volumes:
      - data2-1:/data1
      - data2-2:/data2

  minio3:
    <<: *minio-common
    hostname: minio3
    volumes:
      - data3-1:/data1
      - data3-2:/data2

  minio4:
    <<: *minio-common
    hostname: minio4
    volumes:

                    when (it.name) {
                        "d1" -> data1 = it.value.map { arrayItem -> arrayItem.value as String }.toTypedArray()
                        "d2" -> data2 = it.value.map { arrayItem -> arrayItem.value as String }.toTypedArray()
                    }
            }
        }
        return KotlinClassHeader(kind, metadataVersion, data1, data2, extraString, packageName, extraInt)
    }

    private