<version>3.11.2</version>
				<configuration>
					<encoding>UTF-8</encoding>
					<docencoding>UTF-8</docencoding>
					<charset>UTF-8</charset>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-jar-plugin</artifactId>
				<version>3.4.2</version>
				<configuration>
					<archive>
						<manifestEntries>
							<Automatic-Module-Name>org.codelibs.corelib</Automatic-Module-Name>

 */

package com.google.common.io;

import static com.google.common.collect.ImmutableList.toImmutableList;
import static com.google.common.truth.Truth.assertThat;
import static java.nio.charset.StandardCharsets.UTF_8;

import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.io.SourceSinkFactory.ByteSourceFactory;
import com.google.common.io.SourceSinkFactory.CharSourceFactory;

            File file = new File(artifactBasedir, "artifact-1.0.jar");
            assertEquals("dummy", new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8).trim());

            artifactDeployer.deploy(file, artifact, remoteRepository(), localRepository());

            ArtifactRepository remoteRepository = remoteRepository();

	</component>

	<component name="s3Client"
		class="org.codelibs.fess.crawler.client.s3.S3Client" instance="prototype">
		<property name="charset">"UTF-8"</property>
	</component>

	<component name="gcsClient"
		class="org.codelibs.fess.crawler.client.gcs.GcsClient" instance="prototype">
		<property name="charset">"UTF-8"</property>
	</component>

	<component name="crawlerClientCreator"

    )
    assert result.exit_code == 1, result.output

    fixed_content = (root_dir / "docs" / "lang" / "docs" / "doc.md").read_text("utf-8")
    expected_content = Path(f"{data_path}/translated_doc_number_gt.md").read_text(
        "utf-8"
    )

    assert fixed_content == expected_content  # Translated doc remains unchanged
    assert "Error processing docs/lang/docs/doc.md" in result.output
    assert (

    assertThat(encoding.encode(decoded.getBytes(UTF_8))).isEqualTo(encoded);
  }

  private static void testEncodesWithOffset(
      BaseEncoding encoding, String decoded, int offset, int len, String encoded) {
    assertThat(encoding.encode(decoded.getBytes(UTF_8), offset, len)).isEqualTo(encoded);
  }

        stopwordsFile.reload(null, is);

        assertEquals(0, stopwordsFile.stopwordsItemList.size());
    }

    @Test
    public void test_onlyCommentsAndEmptyLines() {
        String content = "# Comment 1\n" + "\n" + "# Comment 2\n" + "\n";

        InputStream is = new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8));
        stopwordsFile.reload(null, is);

            String result = new String(buffer, 0, bytesRead, "UTF-8");
            assertEquals(testContent, result);
        }
    }

    @Test
    public void testMemoryBasedCacheMultipleReads() throws IOException {
        String testContent = "Hello, World!";
        byte[] data = testContent.getBytes("UTF-8");
        ContentCache cache = new ContentCache(data);

        // First read

    connection.setDoOutput(true)
    connection.setRequestProperty("Expect", "100-Continue")
    connection.outputStream.write("request".toByteArray(StandardCharsets.UTF_8))
    val inputStream = connection.inputStream
    val reader = BufferedReader(InputStreamReader(inputStream, StandardCharsets.UTF_8))
    assertThat(reader.readLine()).isEqualTo("response")
    val request = server.takeRequest()
    assertThat(request.body.readUtf8()).isEqualTo("request")

 * limitations under the License.
 */

package com.google.common.io;

import static com.google.common.base.Preconditions.checkNotNull;
import static java.nio.charset.StandardCharsets.UTF_8;

import java.io.ByteArrayInputStream;
import java.io.FilterReader;
import java.io.IOException;
import java.io.InputStreamReader;
import org.jspecify.annotations.NullUnmarked;

/**
 * @author Colin Decker