}
	sr.ReturnNonDecryptable(true)

	// Debug corrupted streams.
	if false {
		sr.SkipEncrypted(true)
		return sr.DebugStream(os.Stdout)
	}
	extracted := false
	for {
		stream, err := sr.NextStream()
		if err != nil {
			if err == io.EOF {
				if extracted {
					return nil
				}
				return errors.New("no data found on stream")
			}
			if errors.Is(err, estream.ErrNoKey) {

        archiveClassifier.set("darwin-x86_64")
        archiveExtension.set('tar.gz')
    }

    tasks.register('extracted', Copy) {
        from('.')
        destinationDir = file('build/extractedDistro')
    }

    tasks.register("extractedAssemble").configure {
        dependsOn('extracted')
    }

    tasks.named("assemble").configure {
        dependsOn('tar')
    }
}

def calculateBranchVersion() {

        then:
        result.task(":darwin-tar:checkLicense").outcome == TaskOutcome.FAILED
        result.output.contains("> expected line [2] in " +
                "[./darwin-tar/build/tar-extracted/elasticsearch-${VersionProperties.getElasticsearch()}/LICENSE.txt] " +
                "to be [elastic license coorp stuff line 2] but was [unknown license content line 2]")
    }

 * Negotiation Protocol) authentication. It contains the username extracted from the
 * SPNEGO authentication process, typically from a Kerberos ticket.
 */
public class SpnegoCredential implements LoginCredential, FessCredential {

    /** The username extracted from SPNEGO authentication. */
    private final String username;

    /**

        assertEquals(testData.length, writtenBytes);

        byte[] extracted = new byte[testData.length];
        System.arraycopy(outputBuffer, 50, extracted, 0, testData.length);
        assertArrayEquals(testData, extracted);
    }

    @Test
    @DisplayName("Test small data handling")
    public void testSmallDataHandling() throws CIFSException {

    public void test_field_name_extraction() {
        // Test that field names can be extracted from encoded strings
        String originalFieldName = "author";
        String encodedFieldName = BaseEncoding.base64().encode(originalFieldName.getBytes(StandardCharsets.UTF_8));
        String fullFieldName = Constants.FACET_FIELD_PREFIX + encodedFieldName;

        // Extract the encoded part

            }
            configurations {
                extracted {
                    attributes {
                          attribute(ArtifactAttributes.ARTIFACT_FORMAT, "directory")
                    }
                }
            }
            artifacts {
                it.add("default", buildTar)
                it.add("extracted", buildExpanded)
            }
        """
    }

    @Test
    @DisplayName("readSecurityBuffer correctly extracts data")
    void testReadSecurityBuffer() {
        byte[] buf = new byte[8 + 4];
        byte[] payload = { 0x11, 0x22, 0x33, 0x44 };
        NtlmMessage.writeSecurityBuffer(buf, 0, 8, payload);
        byte[] extracted = NtlmMessage.readSecurityBuffer(buf, 0);
        assertArrayEquals(payload, extracted, "Payload should match original");
    }

    @Test

This directory contains JLine native libraries extracted from JLine JAR.

You can add your own build for platforms not natively supported by JLine.
See here [1] on how to compile for your platform and here [2] how libraries
follow JLine's directory and filename conventions.

[1] https://github.com/jline/jline3/tree/master/native

            configurations {
                consumeArchive {}
                consumeDir {}
            }

            dependencies {
                consumeDir project(path: ':producer-tar', configuration:'extracted')
                consumeArchive project(path: ':producer-tar', configuration:'default' )
            }

            tasks.register("copyDir", Copy) {
                from(configurations.consumeDir)