t.Fatalf("Failed to write the file's data: %s", err)
	}
	tw.Close()

	tr := NewReader(&buffer)

	for {
		header, err := tr.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			t.Fatalf("Failed to read header: %s", err)
		}
		if header.Typeflag != TypeReg {
			t.Fatalf("Typeflag should've been %d, found %d", TypeReg, header.Typeflag)
		}
	}
}

                // Find common ancestor
                while (!parent.startsWith(commonRoot)) {
                    commonRoot = commonRoot.getParent();
                    if (commonRoot == null) {
                        break;
                    }
                }
            }
        }
        return commonRoot;
    }

    /**
     * Writes a Document to a file using the same format as the existing codebase.

			b = b[1:]
		case a[0].name < b[0].name:
			merged = append(merged, a[0])
			a = a[1:]
		default:
			merged = append(merged, b[0])
			b = b[1:]
		}
		if limit > 0 && len(merged) >= limit {
			break
		}
	}
	// Append anything left.
	if limit < 0 || len(merged) < limit {
		merged = append(merged, a...)
		merged = append(merged, b...)
	}
	m.o = merged
}

                        }
                        if (relocation.getVersion() != null) {
                            // note: see MNG-3454. This causes a problem, but fixing it may break more.
                            artifact.setVersionRange(VersionRange.createFromVersion(relocation.getVersion()));
                            relocatedArtifact = artifact;

					lbPkgEndOffset := min(lbPartOffset-(lbPartOffset%pkgSz)+pkgSz, v)
					bytesToDrop := v - lbPkgEndOffset

					// Last segment to update `l`
					l += getEncSize(currentPartDareBytes - bytesToDrop)
					break
				}
			}

			cumulativeSum += v
			cumulativeEncSum += getEncSize(v)
		}
		return o, l, skip, sn, ps
	}

	for i, test := range testMPs {
		{
			// nil range

            }

            char ch = s.charAt(pos);
            pos++;
            if (ch == '\\') {
                sb.append(ch);
                if (pos >= end) {
                    break; // ERROR, or let it go?
                }
                ch = s.charAt(pos);
                pos++;
            }

            sb.append(ch);
        }

        if (sb.length() > 0) {

        byte[] buffer = new byte[size];
        int totalRead = 0;
        while (totalRead < size) {
            int read = sis.read(buffer, totalRead, size - totalRead);
            if (read == -1)
                break;
            totalRead += read;
        }

        assertEquals(size, totalRead);
        assertArrayEquals(data, buffer);
    }

    @Test

      ),
    )
    val readBuff = Buffer()
    var byteCount = 0L
    while (true) {
      val readByteCount = onlyPart.body.read(readBuff, 1024L)
      if (readByteCount == -1L) break
      byteCount += readByteCount
      assertThat(readBuff.readUtf8()).isEqualTo("a".repeat(readByteCount.toInt()))
    }
    assertThat(byteCount).isEqualTo(1024L * 1024L * 100L)

				fis[i].SuccessorModTime = succModTimes[i]
				fis[i].IsLatest = succModTimes[i].IsZero()
			}
			if numVersions != nil {
				fis[i].NumVersions = numVersions[i]
			}
			quorum--
			if quorum == 0 {
				break
			}
		}
		return fis
	}

	commonSuccModTime := time.Date(2023, time.August, 25, 0, 0, 0, 0, time.UTC)
	succModTimesInQuorum := make([]time.Time, 16)
	succModTimesNoQuorum := make([]time.Time, 16)

        try {
            while (scrollId != null) {
                final SearchHits searchHits = response.getHits();
                if (searchHits.getHits().length == 0) {
                    break;
                }

                final BulkResponse bulkResponse = getClient().get(c -> {
                    final BulkRequestBuilder builder = c.prepareBulk();