switch (algorithm) {
        case COMPRESSION_NONE:
            return "None";
        case COMPRESSION_LZ77:
            return "LZ77";
        case COMPRESSION_LZ77_HUFFMAN:
            return "LZ77+Huffman";
        case COMPRESSION_LZNT1:
            return "LZNT1";
        case COMPRESSION_PATTERN_V1:
            return "Pattern_V1";
        default:

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * Unit test for simple App.
 */
public class AppTest
    extends TestCase
{
    /**
     * Create the test case
     *
     * @param testName name of the test case
     */
    public AppTest( String testName )
    {
        super( testName );
    }

    /**
     * @return the suite of tests being tested

package org.gradle.test

import org.gradle.test.sub.*;

class GroovyClassWithImports extends SubGroovyClass implements SubJavaInterface, GroovyInterface {
    void close() {
    }
}

        container = new StandardCrawlerContainer().singleton("dataHelper", MemoryDataHelper.class)
                .singleton("urlFilterService", UrlFilterServiceImpl.class)
                .singleton("urlFilter", UrlFilterImpl.class)
                .singleton("dataService", DataServiceImpl.class);
        urlFilter = container.getComponent("urlFilter");
    }

    /**

                addedToBuffer = true;
            }

            // this has to be a separate "if" statement, to capture the case of: "-Dfoo=bar"
            if (addedToBuffer && arg.endsWith("\"")) {
                // if we're building an argument, keep doing so.
                // if this is the case of "-Dfoo=bar", then we need to adjust the buffer.
                if (!currentArg.isEmpty()) {

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.jspecify.annotations.NullUnmarked;

/**
 * Test class for {@link MultiInputStream}.
 *
 * @author Chris Nokleberg
 */
@NullUnmarked
public class MultiInputStreamTest extends IoTestCase {

  public void testJoin() throws Exception {
    joinHelper(0);
    joinHelper(1);
    joinHelper(0, 0, 0);

        response.readDataWireFormat(buffer, 0, buffer.length);

        CIFSException exception = assertThrows(CIFSException.class, () -> {
            response.getInfo(FileInternalInfo.class);
        });

        assertEquals("Incompatible file information class", exception.getMessage());
    }

    @Test
    @DisplayName("Test writeSetupWireFormat returns 0")
    void testWriteSetupWireFormat() {

	cutSet := " "
	if trimChars != "" {
		cutSet = trimChars
	}

	trimFunc := strings.Trim
	switch {
	case where == nil:
	case *where == trimBoth:
	case *where == trimLeading:
		trimFunc = strings.TrimLeft
	case *where == trimTrailing:
		trimFunc = strings.TrimRight
	default:
		return "", errInvalidTrimArg
	}

	return trimFunc(text, cutSet), nil

@Timeout(60)
@Flaky
@Tag("Slow")
@Burst
class HttpOverHttp2Test(
  val protocol: Protocol = burstValues(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.HTTP_2),
) {
  @RegisterExtension
  val platform: PlatformRule = PlatformRule()

  @RegisterExtension
  val clientTestRule = configureClientTestRule()

  @RegisterExtension
  val testLogHandler: TestLogHandler = TestLogHandler(Http2::class.java)

     */
    @Test(expected = IORuntimeException.class)
    public void testReadBytes_CustomMaxSize_ExceedsLimit() throws Exception {
        final File file = tempFolder.newFile("medium.txt");
        final byte[] data = new byte[1024]; // 1KB
        final FileOutputStream out = new FileOutputStream(file);
        try {
            out.write(data);
        } finally {
            out.close();
        }