void testEncodeMultipleChunks() {
            // Given
            SrvCopychunk chunk1 = new SrvCopychunk(100, 200, 300);
            SrvCopychunk chunk2 = new SrvCopychunk(400, 500, 600);
            SrvCopychunk chunk3 = new SrvCopychunk(700, 800, 900);
            SrvCopychunkCopy copy = new SrvCopychunkCopy(sourceKey, chunk1, chunk2, chunk3);

            // When

   * Computes a hash code based on the data that have been provided to this hasher. This is called
   * after all chunks are handled with {@link #process} and any leftover bytes that did not make a
   * complete chunk are handled with {@link #processRemaining}.
   */
  protected abstract HashCode makeHash();

  // Process pent-up data in chunks
  private void munchIfFull() {
    if (buffer.remaining() < 8) {

    /**
     * Returns a new tree starting at this node, filtering the children.
     * Note that this node will not be filtered and only the children
     * and its descendant will be checked.
     *
     * @param filter the filter to apply
     * @return a new filtered graph
     */
    @Nonnull
    Node filter(@Nonnull Predicate<Node> filter);

    /**

		_, err := f.Write(chunk)
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	if frag := int(size % chunkSize); frag > 0 {
		_, err := f.Write(chunk[:frag])
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	end := []byte("END\n")
	_, err = f.Write(end)
	if err != nil {
		t.Fatal("write end:", err)
	}
	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

            }
          }
          break;
        }
        // obj changed, reread
        localValue = abstractFuture.value();
        if (notInstanceOfDelegatingToFuture(localValue)) {
          // obj cannot be null at this point, because value can only change from null to non-null.
          // So if value changed (and it did since we lost the CAS), then it cannot be null and

        return id;
    }

    /**
     * Set a filter value based on checked state (add if checked, remove if unchecked)
     */
    function setFilter(array, value, checked) {
        var index = array.indexOf(value);
        if (checked && index === -1) {
            array.push(value);
        } else if (!checked && index !== -1) {
            array.splice(index, 1);
        }
    }

    /**

        if (expectedSha.equals(sha) == false) {
            final String exceptionMessage = String.format(
                Locale.ROOT,
                "SHA has changed! Expected %s for %s but got %s."
                    + "\nThis usually indicates a corrupt dependency cache or artifacts changed upstream."
                    + "\nEither wipe your cache, fix the upstream artifact, or delete %s and run updateShas",
                expectedSha,

                "Method com.example.Source.foo(java.lang.String): Parameter 0 nullability changed from non-nullable to nullable",
                "Constructor com.example.Source(java.lang.String): Parameter 0 nullability changed from non-nullable to nullable",
                "Method com.example.SourceKt.invoke(com.example.Source,java.lang.String): Parameter 1 nullability changed from non-nullable to nullable"
            )
            assertHasNoInformation()

                callback.onPhaseStart(ChatPhaseCallback.PHASE_ANSWER, "Generating response...");
                llmClientManager.generateUnclearIntentResponse(userMessage, history, (chunk, done) -> {
                    fullResponse.append(chunk);
                    callback.onChunk(chunk, done);
                });
                callback.onPhaseComplete(ChatPhaseCallback.PHASE_ANSWER);
                if (logger.isDebugEnabled()) {

                changed = true;
            }
        }

        Versioning versioning = sourceMetadata.getVersioning();
        if ( versioning != null )
        {
            Versioning v = getVersioning();
            if ( v == null )
            {
                v = new Versioning();
                setVersioning( v );
                changed = true;
            }