}

          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
          }

      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!

    return suite;
  }

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

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

  @J2ktIncompatible
  @GwtIncompatible // suite
  private static Test testsForFilter() {
    return CollectionTestSuiteBuilder.using(
            new TestStringCollectionGenerator() {

     * (related to MNG-6572 optimization)
     */
    @Test
    void testVersionEqualWithLeadingZeroes() {
        // versions with string lengths from 1 to 19
        String[] arr = new String[] {
            "0000000000000000001",
            "000000000000000001",
            "00000000000000001",
            "0000000000000001",
            "000000000000001",

    return suite;
  }

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

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

  @J2ktIncompatible
  @GwtIncompatible // suite
  private static Test testsForFilter() {
    return CollectionTestSuiteBuilder.using(
            new TestStringCollectionGenerator() {

                                 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 {

					t.Errorf("Test %d: read returns wrong file content", i)
				}
			}
		}
	}
}

// Test erasureDecode with random offset and lengths.
// This test is t.Skip()ed as it a long time to run, hence should be run
// explicitly after commenting out t.Skip()
func TestErasureDecodeRandomOffsetLength(t *testing.T) {
	if testing.Short() {
		t.Skip()
	}

                               int num_values, ForwardOperation* forward_op_) {
  std::vector<StringPiece> v(num_values);
  for (int i = 0; i < num_values; ++i) {
    v[i] = StringPiece(static_cast<const char*>(values[i]), lengths[i]);
  }
  forward_op_->attrs.Set(attr_name, v);
  return op_->SetAttrStringList(attr_name, values, lengths, num_values);
}

                    unfiltered.add("yyy");
                    unfiltered.addAll(ImmutableList.copyOf(elements));
                    unfiltered.add("zzz");
                    return Sets.filter(unfiltered, Collections2Test.LENGTH_1);
                  }
                })
            .named("Sets.filter, no nulls")
            .withFeatures(
                CollectionFeature.SUPPORTS_ADD,
                CollectionFeature.SUPPORTS_REMOVE,

		}
		buf.WriteByte('\n')
	}
}

// Test the line splitter, including some carriage returns but no long lines.
func TestScanLongLines(t *testing.T) {
	// Build a buffer of lots of line lengths up to but not exceeding smallMaxTokenSize.
	tmp := new(bytes.Buffer)
	buf := new(bytes.Buffer)
	lineNum := 0
	j := 0
	for i := 0; i < 2*smallMaxTokenSize; i++ {
		genLine(tmp, lineNum, j, true)