val sources = mutableListOf<Source>()
      val lengths = this.lengths.clone() // Defensive copy since these can be zeroed out.
      try {
        for (i in 0 until valueCount) {
          sources += newSource(i)
        }
        return Snapshot(key, sequenceNumber, sources, lengths)
      } catch (_: FileNotFoundException) {
        // A file must have been deleted manually!

          }

          var lengthBits = source.readByte().toLong() and 0xff
          if (lengthBits == 0L || lengthBytes == 1 && lengthBits and 0b1000_0000 == 0L) {
            throw ProtocolException("invalid encoding for length")
          }

          for (i in 1 until lengthBytes) {
            lengthBits = lengthBits shl 8
            lengthBits += source.readByte().toInt() and 0xff
          }

  std::vector<size_t> lengths;
  raw_strs.reserve(values.size());
  lengths.reserve(values.size());
  for (const auto& s : values) {
    raw_strs.emplace_back(s.data());
    lengths.emplace_back(s.size());
  }
  return SetAttrStringList(attr_name,
                           reinterpret_cast<const void**>(raw_strs.data()),
                           lengths.data(), values.size());
}

	}
}

func TestCompareBytes(t *testing.T) {
	lengths := make([]int, 0) // lengths to test in ascending order
	for i := 0; i <= 128; i++ {
		lengths = append(lengths, i)
	}
	lengths = append(lengths, 256, 512, 1024, 1333, 4095, 4096, 4097)

	if !testing.Short() {
		lengths = append(lengths, 65535, 65536, 65537, 99999)
	}

	n := lengths[len(lengths)-1]
	a := make([]byte, n+1)
	b := make([]byte, n+1)

    return suite;
  }

  static final Predicate<@Nullable String> NOT_YYY_ZZZ =
      input -> !Objects.equals(input, "yyy") && !Objects.equals(input, "zzz");

  static final Predicate<String> LENGTH_1 = input -> input.length() == 1;

  @J2ktIncompatible
  @GwtIncompatible // suite
  @AndroidIncompatible // test-suite builders
  private static Test testsForFilter() {
    return CollectionTestSuiteBuilder.using(

 *
 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public class TreeMultimapExplicitTest extends TestCase {

  /**
   * Compare strings lengths, and if the lengths are equal compare the strings. A {@code null} is
   * less than any non-null value.
   */
  private enum StringLength implements Comparator<@Nullable String> {
    COMPARATOR;

    @Override

    return suite;
  }

  static final Predicate<@Nullable String> NOT_YYY_ZZZ =
      input -> !Objects.equals(input, "yyy") && !Objects.equals(input, "zzz");

  static final Predicate<String> LENGTH_1 = input -> input.length() == 1;

  @J2ktIncompatible
  @GwtIncompatible // suite
  @AndroidIncompatible // test-suite builders
  private static Test testsForFilter() {
    return CollectionTestSuiteBuilder.using(

        String smbServer = NbtAddress.SMBSERVER_NAME;

        assertNotNull(anyHosts);
        assertNotNull(masterBrowser);
        assertNotNull(smbServer);

        // Test that they have expected lengths
        assertEquals(16, anyHosts.length());
        assertEquals(15, masterBrowser.length());
        assertEquals(15, smbServer.length());
    }

// and len2 specifies the byte length that the crc2 hash covers.
func crc32Combine(poly uint32, crc1, crc2 uint32, len2 int64) uint32 {
	// degenerate case (also disallow negative lengths)
	if len2 <= 0 {
		return crc1
	}

	even := make([]uint64, 32) // even-power-of-two zeros operator
	odd := make([]uint64, 32)  // odd-power-of-two zeros operator

	// put operator for one zero bit in odd

                                 const size_t* lengths,
                                 int num_values) override {
    if (strcmp(attr_name, tensorflow::kColocationAttrName) == 0) {
      op_->colocation_constraints.clear();
      for (int i = 0; i < num_values; ++i) {
        op_->colocation_constraints.emplace(static_cast<const char*>(values[i]),
                                            lengths[i]);
      }
    } else {