*/
package org.eclipse.jgit.archive;
+import static org.eclipse.jgit.lib.Constants.CHARACTER_ENCODING;
+
import java.io.IOException;
import java.io.OutputStream;
import java.text.MessageFormat;
@Override
public ArchiveOutputStream createArchiveOutputStream(OutputStream s,
Map<String, Object> o) throws IOException {
- TarArchiveOutputStream out = new TarArchiveOutputStream(s, "UTF-8"); //$NON-NLS-1$
+ TarArchiveOutputStream out = new TarArchiveOutputStream(s,
+ CHARACTER_ENCODING);
out.setLongFileMode(TarArchiveOutputStream.LONGFILE_POSIX);
out.setBigNumberMode(TarArchiveOutputStream.BIGNUMBER_POSIX);
return applyFormatOptions(out, o);
final TarArchiveEntry entry = new TarArchiveEntry(
path, TarConstants.LF_SYMLINK);
entry.setLinkName(new String(
- loader.getCachedBytes(100), "UTF-8")); //$NON-NLS-1$
+ loader.getCachedBytes(100), CHARACTER_ENCODING));
out.putArchiveEntry(entry);
out.closeArchiveEntry();
return;
package org.eclipse.jgit.http.test;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.util.HttpSupport.HDR_CONTENT_ENCODING;
import static org.eclipse.jgit.util.HttpSupport.HDR_CONTENT_LENGTH;
import static org.eclipse.jgit.util.HttpSupport.HDR_CONTENT_TYPE;
public void testInvalidWant() throws Exception {
@SuppressWarnings("resource")
ObjectId id = new ObjectInserter.Formatter().idFor(Constants.OBJ_BLOB,
- "testInvalidWant".getBytes(UTF_8));
+ "testInvalidWant".getBytes(CHARSET));
Repository dst = createBareRepository();
try (Transport t = Transport.open(dst, remoteURI);
package org.eclipse.jgit.junit;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.File;
import java.io.FileNotFoundException;
throws IOException {
FileUtils.mkdirs(f.getParentFile(), true);
try (Writer w = new OutputStreamWriter(new FileOutputStream(f),
- UTF_8)) {
+ CHARSET)) {
w.write(body);
}
}
*/
public static String read(final File file) throws IOException {
final byte[] body = IO.readFully(file);
- return new String(body, 0, body.length, UTF_8);
+ return new String(body, 0, body.length, CHARSET);
}
/**
package org.eclipse.jgit.junit;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.fail;
if (0 != (includedOptions & CONTENT)) {
sb.append(", content:"
+ new String(repo.open(entry.getObjectId(),
- Constants.OBJ_BLOB).getCachedBytes(), UTF_8));
+ Constants.OBJ_BLOB).getCachedBytes(), CHARSET));
}
if (0 != (includedOptions & ASSUME_UNCHANGED))
sb.append(", assume-unchanged:"
package org.eclipse.jgit.junit;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import java.io.File;
protected static void checkFile(File f, final String checkData)
throws IOException {
try (Reader r = new InputStreamReader(new FileInputStream(f),
- UTF_8)) {
+ CHARSET)) {
if (checkData.length() > 0) {
char[] data = new char[checkData.length()];
assertEquals(data.length, r.read(data));
package org.eclipse.jgit.junit;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
* @throws Exception
*/
public RevBlob blob(final String content) throws Exception {
- return blob(content.getBytes(UTF_8));
+ return blob(content.getBytes(CHARSET));
}
/**
*/
package org.eclipse.jgit.lfs.server.fs;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import java.io.BufferedInputStream;
if (buf.hasArray()) {
error = new String(buf.array(),
buf.arrayOffset() + buf.position(), buf.remaining(),
- UTF_8);
+ CHARSET);
} else {
final byte[] b = new byte[buf.remaining()];
buf.duplicate().get(b);
- error = new String(b, UTF_8);
+ error = new String(b, CHARSET);
}
} catch (IOException e) {
error = statusLine.getReasonPhrase();
org.eclipse.jgit.lfs.errors;version="[5.0.0,5.1.0)",
org.eclipse.jgit.lfs.internal;version="[5.0.0,5.1.0)",
org.eclipse.jgit.lfs.lib;version="[5.0.0,5.1.0)",
+ org.eclipse.jgit.lib;version="[5.0.0,5.1.0)",
org.eclipse.jgit.nls;version="[5.0.0,5.1.0)",
org.eclipse.jgit.transport.http;version="[5.0.0,5.1.0)",
org.eclipse.jgit.transport.http.apache;version="[5.0.0,5.1.0)",
*/
package org.eclipse.jgit.lfs.server;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.apache.http.HttpStatus.SC_FORBIDDEN;
import static org.apache.http.HttpStatus.SC_INSUFFICIENT_STORAGE;
import static org.apache.http.HttpStatus.SC_INTERNAL_SERVER_ERROR;
protected void doPost(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
Writer w = new BufferedWriter(
- new OutputStreamWriter(res.getOutputStream(), UTF_8));
+ new OutputStreamWriter(res.getOutputStream(), CHARSET));
Reader r = new BufferedReader(
- new InputStreamReader(req.getInputStream(), UTF_8));
+ new InputStreamReader(req.getInputStream(), CHARSET));
LfsRequest request = LfsGson.fromJson(r, LfsRequest.class);
String path = req.getPathInfo();
*/
package org.eclipse.jgit.lfs.server.s3;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.util.HttpSupport.HDR_AUTHORIZATION;
import java.io.UnsupportedEncodingException;
private static byte[] hash(String s) {
MessageDigest md = Constants.newMessageDigest();
- md.update(s.getBytes(UTF_8));
+ md.update(s.getBytes(CHARSET));
return md.digest();
}
private static byte[] sign(String stringData, byte[] key) {
try {
- byte[] data = stringData.getBytes(UTF_8);
+ byte[] data = stringData.getBytes(CHARSET);
Mac mac = Mac.getInstance(HMACSHA256);
mac.init(new SecretKeySpec(key, HMACSHA256));
return mac.doFinal(data);
private static String urlEncode(String url, boolean keepPathSlash) {
String encoded;
try {
- encoded = URLEncoder.encode(url, UTF_8.name());
+ encoded = URLEncoder.encode(url, CHARSET.name());
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(LfsServerText.get().unsupportedUtf8, e);
}
*/
package org.eclipse.jgit.lfs.test;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.BufferedInputStream;
import java.io.FileNotFoundException;
*/
public static LongObjectId hash(String s) {
MessageDigest md = Constants.newMessageDigest();
- md.update(s.getBytes(UTF_8));
+ md.update(s.getBytes(CHARSET));
return LongObjectId.fromRaw(md.digest());
}
package org.eclipse.jgit.lfs.lib;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARACTER_ENCODING;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayOutputStream;
assertEquals(
"version https://git-lfs.github.com/spec/v1\noid sha256:"
+ s + "\nsize 4\n",
- baos.toString(UTF_8.name()));
+ baos.toString(CHARACTER_ENCODING));
}
}
}
*/
package org.eclipse.jgit.lfs;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.BufferedReader;
import java.io.IOException;
*/
public void encode(OutputStream out) {
try (PrintStream ps = new PrintStream(out, false,
- UTF_8.name())) {
+ CHARSET.name())) {
ps.print("version "); //$NON-NLS-1$
ps.print(VERSION + "\n"); //$NON-NLS-1$
ps.print("oid " + HASH_FUNCTION_NAME + ":"); //$NON-NLS-1$ //$NON-NLS-2$
ps.print(size + "\n"); //$NON-NLS-1$
} catch (UnsupportedEncodingException e) {
// should not happen, we are using a standard charset
- throw new UnsupportedCharsetException(UTF_8.name());
+ throw new UnsupportedCharsetException(CHARSET.name());
}
}
long sz = -1;
try (BufferedReader br = new BufferedReader(
- new InputStreamReader(in, UTF_8))) {
+ new InputStreamReader(in, CHARSET))) {
for (String s = br.readLine(); s != null; s = br.readLine()) {
if (s.startsWith("#") || s.length() == 0) { //$NON-NLS-1$
continue;
*/
package org.eclipse.jgit.lfs;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.lfs.Protocol.OPERATION_UPLOAD;
import static org.eclipse.jgit.lfs.internal.LfsConnectionFactory.toRequest;
import static org.eclipse.jgit.transport.http.HttpConnection.HTTP_OK;
}
Gson gson = Protocol.gson();
api.getOutputStream().write(
- gson.toJson(toRequest(OPERATION_UPLOAD, res)).getBytes(UTF_8));
+ gson.toJson(toRequest(OPERATION_UPLOAD, res)).getBytes(CHARSET));
int responseCode = api.getResponseCode();
if (responseCode != HTTP_OK) {
throw new IOException(
*/
package org.eclipse.jgit.lfs;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
+
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
-import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.text.MessageFormat;
.write(gson
.toJson(LfsConnectionFactory
.toRequest(Protocol.OPERATION_DOWNLOAD, res))
- .getBytes(StandardCharsets.UTF_8));
+ .getBytes(CHARSET));
int responseCode = lfsServerConn.getResponseCode();
if (responseCode != HttpConnection.HTTP_OK) {
throw new IOException(
*/
package org.eclipse.jgit.pgm;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
private BufferedReader readFromProcess(Process proc) throws Exception {
return new BufferedReader(
- new InputStreamReader(proc.getInputStream(), UTF_8));
+ new InputStreamReader(proc.getInputStream(), CHARSET));
}
private void grepForEntry(String name, String mode, String... cmdline)
// found!
List<String> l = new ArrayList<>();
BufferedReader reader = new BufferedReader(
- new InputStreamReader(in, UTF_8));
+ new InputStreamReader(in, CHARSET));
String line;
while ((line = reader.readLine()) != null)
l.add(line);
package org.eclipse.jgit.pgm;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.BufferedReader;
import java.io.IOException;
final BufferedReader cIn;
try {
final InputStream in = cUrl.openStream();
- cIn = new BufferedReader(new InputStreamReader(in, UTF_8));
+ cIn = new BufferedReader(new InputStreamReader(in, CHARSET));
} catch (IOException err) {
// If we cannot read from the service list, go to the next.
//
package org.eclipse.jgit.pgm;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.File;
import java.io.IOException;
}
PrintWriter createErrorWriter() {
- return new PrintWriter(new OutputStreamWriter(System.err, UTF_8));
+ return new PrintWriter(new OutputStreamWriter(System.err, CHARSET));
}
private void execute(final String[] argv) throws Exception {
package org.eclipse.jgit.pgm.debug;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.lib.Constants.HEAD;
import static org.eclipse.jgit.lib.Constants.MASTER;
import static org.eclipse.jgit.lib.Constants.R_HEADS;
throws IOException, FileNotFoundException {
RefList.Builder<Ref> list = new RefList.Builder<>();
try (BufferedReader br = new BufferedReader(new InputStreamReader(
- new FileInputStream(lsRemotePath), UTF_8))) {
+ new FileInputStream(lsRemotePath), CHARSET))) {
Ref last = null;
String line;
while ((line = br.readLine()) != null) {
package org.eclipse.jgit.pgm.debug;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.lib.Constants.HEAD;
import static org.eclipse.jgit.lib.Constants.MASTER;
import static org.eclipse.jgit.lib.Constants.R_HEADS;
static List<Ref> readRefs(String inputFile) throws IOException {
List<Ref> refs = new ArrayList<>();
try (BufferedReader br = new BufferedReader(
- new InputStreamReader(new FileInputStream(inputFile), UTF_8))) {
+ new InputStreamReader(new FileInputStream(inputFile), CHARSET))) {
String line;
while ((line = br.readLine()) != null) {
ObjectId id = ObjectId.fromString(line.substring(0, 40));
List<LogEntry> log = new ArrayList<>();
try (BufferedReader br = new BufferedReader(
- new InputStreamReader(new FileInputStream(logPath), UTF_8))) {
+ new InputStreamReader(new FileInputStream(logPath), CHARSET))) {
@SuppressWarnings("nls")
Pattern pattern = Pattern.compile("([^,]+)" // 1: ref
+ ",([0-9]+(?:[.][0-9]+)?)" // 2: time
*/
package org.eclipse.jgit.ignore;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.BufferedReader;
import java.io.File;
this.gitDir = gitDir;
this.pattern = pattern;
Files.write(FileUtils.toPath(new File(gitDir, ".gitignore")),
- (pattern + "\n").getBytes(UTF_8), StandardOpenOption.CREATE,
+ (pattern + "\n").getBytes(CHARSET), StandardOpenOption.CREATE,
StandardOpenOption.TRUNCATE_EXISTING,
StandardOpenOption.WRITE);
}
Process proc = Runtime.getRuntime().exec(command, new String[0],
gitDir);
try (OutputStream out = proc.getOutputStream()) {
- out.write((path + "\n").getBytes(UTF_8));
+ out.write((path + "\n").getBytes(CHARSET));
out.flush();
}
return proc;
package org.eclipse.jgit.api;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.lib.CoreConfig.EolStreamType.AUTO_CRLF;
import static org.eclipse.jgit.lib.CoreConfig.EolStreamType.AUTO_LF;
import static org.eclipse.jgit.lib.CoreConfig.EolStreamType.DIRECT;
EolStreamType streamTypeWithBinaryCheck, String output,
String expectedConversion) throws Exception {
ByteArrayOutputStream b;
- byte[] outputBytes = output.getBytes(UTF_8);
- byte[] expectedConversionBytes = expectedConversion.getBytes(UTF_8);
+ byte[] outputBytes = output.getBytes(CHARSET);
+ byte[] expectedConversionBytes = expectedConversion.getBytes(CHARSET);
// test using output text and assuming it was declared TEXT
b = new ByteArrayOutputStream();
private void testCheckin(EolStreamType streamTypeText,
EolStreamType streamTypeWithBinaryCheck, String input,
String expectedConversion) throws Exception {
- byte[] inputBytes = input.getBytes(UTF_8);
- byte[] expectedConversionBytes = expectedConversion.getBytes(UTF_8);
+ byte[] inputBytes = input.getBytes(CHARSET);
+ byte[] expectedConversionBytes = expectedConversion.getBytes(CHARSET);
// test using input text and assuming it was declared TEXT
try (InputStream in = EolStreamTypeUtil.wrapInputStream(
*/
package org.eclipse.jgit.api;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import java.util.List;
git.notesAdd().setObjectId(commit2).setMessage("data").call();
Note note = git.notesShow().setObjectId(commit2).call();
String content = new String(db.open(note.getData()).getCachedBytes(),
- UTF_8);
+ CHARSET);
assertEquals(content, "data");
git.notesRemove().setObjectId(commit2).call();
*/
package org.eclipse.jgit.api;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
private static void writeToFile(File actFile, String string)
throws IOException {
try (FileOutputStream fos = new FileOutputStream(actFile)) {
- fos.write(string.getBytes(UTF_8));
+ fos.write(string.getBytes(CHARSET));
}
}
bos.write(buffer, 0, read);
read = fis.read(buffer);
}
- String content = new String(bos.toByteArray(), UTF_8);
+ String content = new String(bos.toByteArray(), CHARSET);
assertEquals(string, content);
}
}
*/
package org.eclipse.jgit.api;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
private static void writeToFile(File actFile, String string)
throws IOException {
try (FileOutputStream fos = new FileOutputStream(actFile)) {
- fos.write(string.getBytes(UTF_8));
+ fos.write(string.getBytes(CHARSET));
}
}
bos.write(buffer, 0, read);
read = fis.read(buffer);
}
- String content = new String(bos.toByteArray(), UTF_8);
+ String content = new String(bos.toByteArray(), CHARSET);
assertEquals(string, content);
}
}
*/
package org.eclipse.jgit.api;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
assertEquals("GIT_AUTHOR_DATE='@123456789 -0100'", lines[2]);
PersonIdent parsedIdent = git.rebase().parseAuthor(
- convertedAuthor.getBytes(UTF_8));
+ convertedAuthor.getBytes(CHARSET));
assertEquals(ident.getName(), parsedIdent.getName());
assertEquals(ident.getEmailAddress(), parsedIdent.getEmailAddress());
// this is rounded to the last second
assertEquals("GIT_AUTHOR_DATE='@123456789 +0930'", lines[2]);
parsedIdent = git.rebase().parseAuthor(
- convertedAuthor.getBytes(UTF_8));
+ convertedAuthor.getBytes(CHARSET));
assertEquals(ident.getName(), parsedIdent.getName());
assertEquals(ident.getEmailAddress(), parsedIdent.getEmailAddress());
assertEquals(123456789000L, parsedIdent.getWhen().getTime());
int count = 0;
File todoFile = getTodoFile();
try (BufferedReader br = new BufferedReader(new InputStreamReader(
- new FileInputStream(todoFile), UTF_8))) {
+ new FileInputStream(todoFile), CHARSET))) {
String line = br.readLine();
while (line != null) {
int firstBlank = line.indexOf(' ');
package org.eclipse.jgit.diff;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
r.append(text.charAt(i));
r.append('\n');
}
- return new RawText(r.toString().getBytes(UTF_8));
+ return new RawText(r.toString().getBytes(CHARSET));
}
}
package org.eclipse.jgit.diff;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
e = c.reduceCommonStartEnd(t("abQxy"), t("abRxy"), e);
assertEquals(new Edit(2, 3, 2, 3), e);
- RawText a = new RawText("p\na b\nQ\nc d\n".getBytes(UTF_8));
- RawText b = new RawText("p\na b \nR\n c d \n".getBytes(UTF_8));
+ RawText a = new RawText("p\na b\nQ\nc d\n".getBytes(CHARSET));
+ RawText b = new RawText("p\na b \nR\n c d \n".getBytes(CHARSET));
e = new Edit(0, 4, 0, 4);
e = RawTextComparator.WS_IGNORE_ALL.reduceCommonStartEnd(a, b, e);
assertEquals(new Edit(2, 3, 2, 3), e);
RawText b;
Edit e;
- a = new RawText("R\n y\n".getBytes(UTF_8));
- b = new RawText("S\n\n y\n".getBytes(UTF_8));
+ a = new RawText("R\n y\n".getBytes(CHARSET));
+ b = new RawText("S\n\n y\n".getBytes(CHARSET));
e = new Edit(0, 2, 0, 3);
e = RawTextComparator.DEFAULT.reduceCommonStartEnd(a, b, e);
assertEquals(new Edit(0, 1, 0, 2), e);
- a = new RawText("S\n\n y\n".getBytes(UTF_8));
- b = new RawText("R\n y\n".getBytes(UTF_8));
+ a = new RawText("S\n\n y\n".getBytes(CHARSET));
+ b = new RawText("R\n y\n".getBytes(CHARSET));
e = new Edit(0, 3, 0, 2);
e = RawTextComparator.DEFAULT.reduceCommonStartEnd(a, b, e);
assertEquals(new Edit(0, 2, 0, 1), e);
RawText a;
RawText b;
Edit e;
- a = new RawText("start".getBytes(UTF_8));
- b = new RawText("start of line".getBytes(UTF_8));
+ a = new RawText("start".getBytes(CHARSET));
+ b = new RawText("start of line".getBytes(CHARSET));
e = new Edit(0, 1, 0, 1);
e = RawTextComparator.DEFAULT.reduceCommonStartEnd(a, b, e);
assertEquals(new Edit(0, 1, 0, 1), e);
RawText a;
RawText b;
Edit e;
- a = new RawText("start".getBytes(UTF_8));
- b = new RawText("start of\nlastline".getBytes(UTF_8));
+ a = new RawText("start".getBytes(CHARSET));
+ b = new RawText("start of\nlastline".getBytes(CHARSET));
e = new Edit(0, 1, 0, 2);
e = RawTextComparator.DEFAULT.reduceCommonStartEnd(a, b, e);
assertEquals(new Edit(0, 1, 0, 2), e);
r.append(text.charAt(i));
r.append('\n');
}
- return new RawText(r.toString().getBytes(UTF_8));
+ return new RawText(r.toString().getBytes(CHARSET));
}
}
package org.eclipse.jgit.diff;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+ "A\n" //
+ "B\n" //
+ "B\n" //
- + "B\n").getBytes(UTF_8);
+ + "B\n").getBytes(CHARSET);
SimilarityIndex si = new SimilarityIndex();
si.hash(new ByteArrayInputStream(in), in.length, false);
assertEquals(2, si.size());
+ "D\r\n" //
+ "B\r\n";
SimilarityIndex src = new SimilarityIndex();
- byte[] bytes1 = text.getBytes(UTF_8);
+ byte[] bytes1 = text.getBytes(CHARSET);
src.hash(new ByteArrayInputStream(bytes1), bytes1.length, true);
src.sort();
SimilarityIndex dst = new SimilarityIndex();
- byte[] bytes2 = text.replace("\r", "").getBytes(UTF_8);
+ byte[] bytes2 = text.replace("\r", "").getBytes(CHARSET);
dst.hash(new ByteArrayInputStream(bytes2), bytes2.length, true);
dst.sort();
package org.eclipse.jgit.dircache;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.junit.Assert.assertEquals;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
private static Map<String, CGitIndexRecord> readLsFiles() throws Exception {
final LinkedHashMap<String, CGitIndexRecord> r = new LinkedHashMap<>();
try (BufferedReader br = new BufferedReader(new InputStreamReader(
- new FileInputStream(pathOf("gitgit.lsfiles")), UTF_8))) {
+ new FileInputStream(pathOf("gitgit.lsfiles")), CHARSET))) {
String line;
while ((line = br.readLine()) != null) {
final CGitIndexRecord cr = new CGitIndexRecord(line);
private static Map<String, CGitLsTreeRecord> readLsTree() throws Exception {
final LinkedHashMap<String, CGitLsTreeRecord> r = new LinkedHashMap<>();
try (BufferedReader br = new BufferedReader(new InputStreamReader(
- new FileInputStream(pathOf("gitgit.lstree")), UTF_8))) {
+ new FileInputStream(pathOf("gitgit.lstree")), CHARSET))) {
String line;
while ((line = br.readLine()) != null) {
final CGitLsTreeRecord cr = new CGitLsTreeRecord(line);
*/
package org.eclipse.jgit.gitrepo;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
ManifestParser parser = new ManifestParser(
null, null, "master", baseUrl, null, null);
- parser.read(new ByteArrayInputStream(xmlContent.toString().getBytes(UTF_8)));
+ parser.read(new ByteArrayInputStream(xmlContent.toString().getBytes(CHARSET)));
// Unfiltered projects should have them all.
results.clear();
results.add("foo");
baseUrl, null, null);
try {
parser.read(new ByteArrayInputStream(
- xmlContent.toString().getBytes(UTF_8)));
+ xmlContent.toString().getBytes(CHARSET)));
fail("ManifestParser did not throw exception for missing fetch");
} catch (IOException e) {
assertTrue(e.getCause() instanceof SAXException);
*/
package org.eclipse.jgit.gitrepo;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
RevCommit commit = cmd
.setInputStream(new ByteArrayInputStream(
- xmlContent.toString().getBytes(UTF_8)))
+ xmlContent.toString().getBytes(CHARSET)))
.setRemoteReader(repos)
.setURI("platform/")
.setTargetURI("platform/superproject")
String firstIdStr = commit.getId().name() + ":" + ".gitmodules";
commit = new RepoCommand(dest)
.setInputStream(new ByteArrayInputStream(
- xmlContent.toString().getBytes(UTF_8)))
+ xmlContent.toString().getBytes(CHARSET)))
.setRemoteReader(repos)
.setURI("platform/")
.setTargetURI("platform/superproject")
repos.put("platform/base", child);
RevCommit commit = cmd
- .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(UTF_8)))
+ .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(CHARSET)))
.setRemoteReader(repos)
.setURI("platform/")
.setTargetURI("platform/superproject")
RevCommit commit = new RepoCommand(dest)
.setInputStream(new ByteArrayInputStream(
- xmlContent.toString().getBytes(UTF_8)))
+ xmlContent.toString().getBytes(CHARSET)))
.setRemoteReader(new IndexedRepos())
.setURI("platform/")
.setTargetURI("platform/superproject")
repos.put("plugins/cookbook", child);
RevCommit commit = cmd
- .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(UTF_8)))
+ .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(CHARSET)))
.setRemoteReader(repos)
.setURI("")
.setTargetURI("gerrit")
repos.put(repoUrl, child);
RevCommit commit = cmd
- .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(UTF_8)))
+ .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(CHARSET)))
.setRemoteReader(repos)
.setURI(baseUrl)
.setTargetURI("gerrit")
repos.put(repoUrl, child);
RevCommit commit = cmd
- .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(UTF_8)))
+ .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(CHARSET)))
.setRemoteReader(repos)
.setURI(baseUrl)
.setTargetURI(abs + "/superproject")
*/
package org.eclipse.jgit.ignore;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.junit.Assert.assertEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
for (String line : rules) {
data.append(line + "\n");
}
- return new ByteArrayInputStream(data.toString().getBytes(UTF_8));
+ return new ByteArrayInputStream(data.toString().getBytes(CHARSET));
}
}
*/
package org.eclipse.jgit.indexdiff;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
File restoreScript = new File(testDir, name + ".sh");
try (OutputStream out = new BufferedOutputStream(
new FileOutputStream(restoreScript));
- Writer writer = new OutputStreamWriter(out, UTF_8)) {
+ Writer writer = new OutputStreamWriter(out, CHARSET)) {
writer.write("echo `which git` 1>&2\n");
writer.write("echo `git --version` 1>&2\n");
writer.write("git init " + name + " && \\\n");
package org.eclipse.jgit.internal.storage.file;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.junit.Assert.assertEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
ObjectId blobId;
try (ObjectInserter ins = bareRepo.newObjectInserter()) {
- blobId = ins.insert(Constants.OBJ_BLOB, "contents".getBytes(UTF_8));
+ blobId = ins.insert(Constants.OBJ_BLOB, "contents".getBytes(CHARSET));
ins.flush();
}
package org.eclipse.jgit.internal.storage.file;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
4294967295000L, 60));
commit.setCommitter(new PersonIdent("Joe Hacker", "joe2@example.com",
4294967295000L, 60));
- commit.setEncoding(UTF_8);
+ commit.setEncoding(CHARSET);
commit.setMessage("\u00dcbergeeks");
ObjectId cid = insertCommit(commit);
assertEquals("4680908112778718f37e686cbebcc912730b3154", cid.name());
package org.eclipse.jgit.junit;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
RevObject obj = tr.get(rw.parseTree(treeish), path);
assertSame(RevBlob.class, obj.getClass());
ObjectLoader loader = rw.getObjectReader().open(obj);
- return new String(loader.getCachedBytes(), UTF_8);
+ return new String(loader.getCachedBytes(), CHARSET);
}
}
package org.eclipse.jgit.lib;
import static java.lang.Integer.valueOf;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.junit.JGitTestUtil.concat;
import static org.eclipse.jgit.lib.Constants.OBJECT_ID_LENGTH;
import static org.eclipse.jgit.lib.Constants.OBJ_BAD;
StringBuilder b = new StringBuilder();
entry(b, "100644 A");
entry(b, "100644 a");
- byte[] data = b.toString().getBytes(UTF_8);
+ byte[] data = b.toString().getBytes(CHARSET);
checker.setSafeForWindows(true);
assertCorrupt("duplicate entry names", OBJ_TREE, data);
assertSkipListAccepts(OBJ_TREE, data);
StringBuilder b = new StringBuilder();
entry(b, "100644 A");
entry(b, "100644 a");
- byte[] data = b.toString().getBytes(UTF_8);
+ byte[] data = b.toString().getBytes(CHARSET);
checker.setSafeForMacOS(true);
assertCorrupt("duplicate entry names", OBJ_TREE, data);
assertSkipListAccepts(OBJ_TREE, data);
StringBuilder b = new StringBuilder();
entry(b, "100644 \u0065\u0301");
entry(b, "100644 \u00e9");
- byte[] data = b.toString().getBytes(UTF_8);
+ byte[] data = b.toString().getBytes(CHARSET);
checker.setSafeForMacOS(true);
assertCorrupt("duplicate entry names", OBJ_TREE, data);
assertSkipListAccepts(OBJ_TREE, data);
StringBuilder b = new StringBuilder();
entry(b, "100644 A");
checker.setSafeForMacOS(true);
- checker.checkTree(b.toString().getBytes(UTF_8));
+ checker.checkTree(b.toString().getBytes(CHARSET));
}
@Test
*/
package org.eclipse.jgit.merge;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
}
binary[50] = '\0';
- writeTrashFile("file", new String(binary, UTF_8));
+ writeTrashFile("file", new String(binary, CHARSET));
git.add().addFilepattern("file").call();
RevCommit first = git.commit().setMessage("added file").call();
int idx = LINELEN * 1200 + 1;
byte save = binary[idx];
binary[idx] = '@';
- writeTrashFile("file", new String(binary, UTF_8));
+ writeTrashFile("file", new String(binary, CHARSET));
binary[idx] = save;
git.add().addFilepattern("file").call();
git.checkout().setCreateBranch(true).setStartPoint(first).setName("side").call();
binary[LINELEN * 1500 + 1] = '!';
- writeTrashFile("file", new String(binary, UTF_8));
+ writeTrashFile("file", new String(binary, CHARSET));
git.add().addFilepattern("file").call();
RevCommit sideCommit = git.commit().setAll(true)
.setMessage("modified file l 1500").call();
merger.getMergeResults().get("file");
try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
fmt.formatMerge(out, merger.getMergeResults().get("file"),
- "BASE", "OURS", "THEIRS", UTF_8.name());
+ "BASE", "OURS", "THEIRS", CHARSET.name());
String expected = "<<<<<<< OURS\n"
+ "1master\n"
+ "=======\n"
+ ">>>>>>> THEIRS\n"
+ "2\n"
+ "3";
- assertEquals(expected, new String(out.toByteArray(), UTF_8));
+ assertEquals(expected, new String(out.toByteArray(), CHARSET));
}
}
}
if (obj == null) {
return null;
}
- return new String(rw.getObjectReader().open(obj, OBJ_BLOB).getBytes(), UTF_8);
+ return new String(rw.getObjectReader().open(obj, OBJ_BLOB).getBytes(), CHARSET);
}
}
package org.eclipse.jgit.patch;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@Test
public void testGetText_Convert() throws IOException {
final Charset csOld = ISO_8859_1;
- final Charset csNew = UTF_8;
+ final Charset csNew = CHARSET;
final Patch p = parseTestPatchFile();
assertTrue(p.getErrors().isEmpty());
assertEquals(1, p.getFiles().size());
@Test
public void testGetText_DiffCc() throws IOException {
final Charset csOld = ISO_8859_1;
- final Charset csNew = UTF_8;
+ final Charset csNew = CHARSET;
final Patch p = parseTestPatchFile();
assertTrue(p.getErrors().isEmpty());
assertEquals(1, p.getFiles().size());
package org.eclipse.jgit.revwalk;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
assertNull(c.getTree());
assertNull(c.parents);
- c.parseCanonical(rw, body.toString().getBytes(UTF_8));
+ c.parseCanonical(rw, body.toString().getBytes(CHARSET));
assertNotNull(c.getTree());
assertEquals(treeId, c.getTree().getId());
assertSame(rw.lookupTree(treeId), c.getTree());
final RevCommit c;
c = new RevCommit(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
- c.parseCanonical(new RevWalk(db), b.toString().getBytes(UTF_8));
+ c.parseCanonical(new RevWalk(db), b.toString().getBytes(CHARSET));
return c;
}
final RevCommit c;
c = new RevCommit(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
- c.parseCanonical(new RevWalk(db), b.toString().getBytes(UTF_8));
+ c.parseCanonical(new RevWalk(db), b.toString().getBytes(CHARSET));
assertEquals("", c.getFullMessage());
assertEquals("", c.getShortMessage());
final RevCommit c;
c = new RevCommit(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
- c.parseCanonical(new RevWalk(db), b.toString().getBytes(UTF_8));
+ c.parseCanonical(new RevWalk(db), b.toString().getBytes(CHARSET));
assertEquals(new PersonIdent("", "a_u_thor@example.com", 1218123387000l, 7), c.getAuthorIdent());
assertEquals(new PersonIdent("", "", 1218123390000l, -5), c.getCommitterIdent());
@Test
public void testParse_implicit_UTF8_encoded() throws Exception {
final ByteArrayOutputStream b = new ByteArrayOutputStream();
- b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
- b.write("author F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n".getBytes(UTF_8));
- b.write("committer C O. Miter <c@example.com> 1218123390 -0500\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("\u304d\u308c\u3044\n".getBytes(UTF_8));
+ b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(CHARSET));
+ b.write("author F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n".getBytes(CHARSET));
+ b.write("committer C O. Miter <c@example.com> 1218123390 -0500\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("\u304d\u308c\u3044\n".getBytes(CHARSET));
final RevCommit c;
c = new RevCommit(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67")); // bogus id
c.parseCanonical(new RevWalk(db), b.toByteArray());
@Test
public void testParse_implicit_mixed_encoded() throws Exception {
final ByteArrayOutputStream b = new ByteArrayOutputStream();
- b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
+ b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(CHARSET));
b.write("author F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n".getBytes(ISO_8859_1));
- b.write("committer C O. Miter <c@example.com> 1218123390 -0500\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("\u304d\u308c\u3044\n".getBytes(UTF_8));
+ b.write("committer C O. Miter <c@example.com> 1218123390 -0500\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("\u304d\u308c\u3044\n".getBytes(CHARSET));
final RevCommit c;
c = new RevCommit(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67")); // bogus id
c.parseCanonical(new RevWalk(db), b.toByteArray());
@Test
public void testParse_explicit_bad_encoded() throws Exception {
final ByteArrayOutputStream b = new ByteArrayOutputStream();
- b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
+ b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(CHARSET));
b.write("author F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n".getBytes(ISO_8859_1));
- b.write("committer C O. Miter <c@example.com> 1218123390 -0500\n".getBytes(UTF_8));
- b.write("encoding EUC-JP\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("\u304d\u308c\u3044\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("Hi\n".getBytes(UTF_8));
+ b.write("committer C O. Miter <c@example.com> 1218123390 -0500\n".getBytes(CHARSET));
+ b.write("encoding EUC-JP\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("\u304d\u308c\u3044\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("Hi\n".getBytes(CHARSET));
final RevCommit c;
c = new RevCommit(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67")); // bogus id
c.parseCanonical(new RevWalk(db), b.toByteArray());
@Test
public void testParse_explicit_bad_encoded2() throws Exception {
final ByteArrayOutputStream b = new ByteArrayOutputStream();
- b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
- b.write("author F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n".getBytes(UTF_8));
- b.write("committer C O. Miter <c@example.com> 1218123390 -0500\n".getBytes(UTF_8));
- b.write("encoding ISO-8859-1\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("\u304d\u308c\u3044\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("Hi\n".getBytes(UTF_8));
+ b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(CHARSET));
+ b.write("author F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n".getBytes(CHARSET));
+ b.write("committer C O. Miter <c@example.com> 1218123390 -0500\n".getBytes(CHARSET));
+ b.write("encoding ISO-8859-1\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("\u304d\u308c\u3044\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("Hi\n".getBytes(CHARSET));
final RevCommit c;
c = new RevCommit(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67")); // bogus id
c.parseCanonical(new RevWalk(db), b.toByteArray());
public void testParse_incorrectUtf8Name() throws Exception {
ByteArrayOutputStream b = new ByteArrayOutputStream();
b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n"
- .getBytes(UTF_8));
- b.write("author au <a@example.com> 1218123387 +0700\n".getBytes(UTF_8));
+ .getBytes(CHARSET));
+ b.write("author au <a@example.com> 1218123387 +0700\n".getBytes(CHARSET));
b.write("committer co <c@example.com> 1218123390 -0500\n"
- .getBytes(UTF_8));
- b.write("encoding 'utf8'\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(UTF_8));
+ .getBytes(CHARSET));
+ b.write("encoding 'utf8'\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(CHARSET));
RevCommit c = new RevCommit(
id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
@Test
public void testParse_illegalEncoding() throws Exception {
ByteArrayOutputStream b = new ByteArrayOutputStream();
- b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
- b.write("author au <a@example.com> 1218123387 +0700\n".getBytes(UTF_8));
- b.write("committer co <c@example.com> 1218123390 -0500\n".getBytes(UTF_8));
- b.write("encoding utf-8logoutputencoding=gbk\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("message\n".getBytes(UTF_8));
+ b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(CHARSET));
+ b.write("author au <a@example.com> 1218123387 +0700\n".getBytes(CHARSET));
+ b.write("committer co <c@example.com> 1218123390 -0500\n".getBytes(CHARSET));
+ b.write("encoding utf-8logoutputencoding=gbk\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("message\n".getBytes(CHARSET));
RevCommit c = new RevCommit(
id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
@Test
public void testParse_unsupportedEncoding() throws Exception {
ByteArrayOutputStream b = new ByteArrayOutputStream();
- b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
- b.write("author au <a@example.com> 1218123387 +0700\n".getBytes(UTF_8));
- b.write("committer co <c@example.com> 1218123390 -0500\n".getBytes(UTF_8));
- b.write("encoding it_IT.UTF8\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("message\n".getBytes(UTF_8));
+ b.write("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(CHARSET));
+ b.write("author au <a@example.com> 1218123387 +0700\n".getBytes(CHARSET));
+ b.write("committer co <c@example.com> 1218123390 -0500\n".getBytes(CHARSET));
+ b.write("encoding it_IT.UTF8\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("message\n".getBytes(CHARSET));
RevCommit c = new RevCommit(
id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
package org.eclipse.jgit.revwalk;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
assertNull(c.getObject());
assertNull(c.getTagName());
- c.parseCanonical(rw, b.toString().getBytes(UTF_8));
+ c.parseCanonical(rw, b.toString().getBytes(CHARSET));
assertNotNull(c.getObject());
assertEquals(id, c.getObject().getId());
assertSame(rw.lookupAny(id, typeCode), c.getObject());
assertNull(c.getObject());
assertNull(c.getTagName());
- c.parseCanonical(rw, body.toString().getBytes(UTF_8));
+ c.parseCanonical(rw, body.toString().getBytes(CHARSET));
assertNotNull(c.getObject());
assertEquals(treeId, c.getObject().getId());
assertSame(rw.lookupTree(treeId), c.getObject());
assertNull(c.getObject());
assertNull(c.getTagName());
- c.parseCanonical(rw, body.toString().getBytes(UTF_8));
+ c.parseCanonical(rw, body.toString().getBytes(CHARSET));
assertNotNull(c.getObject());
assertEquals(treeId, c.getObject().getId());
assertSame(rw.lookupTree(treeId), c.getObject());
final RevTag c;
c = new RevTag(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
- c.parseCanonical(new RevWalk(db), b.toString().getBytes(UTF_8));
+ c.parseCanonical(new RevWalk(db), b.toString().getBytes(CHARSET));
return c;
}
public void testParse_implicit_UTF8_encoded() throws Exception {
final ByteArrayOutputStream b = new ByteArrayOutputStream();
b.write("object 9788669ad918b6fcce64af8882fc9a81cb6aba67\n"
- .getBytes(UTF_8));
- b.write("type tree\n".getBytes(UTF_8));
- b.write("tag v1.2.3.4.5\n".getBytes(UTF_8));
+ .getBytes(CHARSET));
+ b.write("type tree\n".getBytes(CHARSET));
+ b.write("tag v1.2.3.4.5\n".getBytes(CHARSET));
b
.write("tagger F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n"
- .getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("\u304d\u308c\u3044\n".getBytes(UTF_8));
+ .getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("\u304d\u308c\u3044\n".getBytes(CHARSET));
final RevTag c;
c = new RevTag(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
c.parseCanonical(new RevWalk(db), b.toByteArray());
public void testParse_implicit_mixed_encoded() throws Exception {
final ByteArrayOutputStream b = new ByteArrayOutputStream();
b.write("object 9788669ad918b6fcce64af8882fc9a81cb6aba67\n"
- .getBytes(UTF_8));
- b.write("type tree\n".getBytes(UTF_8));
- b.write("tag v1.2.3.4.5\n".getBytes(UTF_8));
+ .getBytes(CHARSET));
+ b.write("type tree\n".getBytes(CHARSET));
+ b.write("tag v1.2.3.4.5\n".getBytes(CHARSET));
b.write("tagger F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n"
.getBytes(ISO_8859_1));
- b.write("\n".getBytes(UTF_8));
- b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("\u304d\u308c\u3044\n".getBytes(UTF_8));
+ b.write("\n".getBytes(CHARSET));
+ b.write("Sm\u00f6rg\u00e5sbord\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("\u304d\u308c\u3044\n".getBytes(CHARSET));
final RevTag c;
c = new RevTag(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
c.parseCanonical(new RevWalk(db), b.toByteArray());
public void testParse_explicit_bad_encoded() throws Exception {
final ByteArrayOutputStream b = new ByteArrayOutputStream();
b.write("object 9788669ad918b6fcce64af8882fc9a81cb6aba67\n"
- .getBytes(UTF_8));
- b.write("type tree\n".getBytes(UTF_8));
- b.write("tag v1.2.3.4.5\n".getBytes(UTF_8));
+ .getBytes(CHARSET));
+ b.write("type tree\n".getBytes(CHARSET));
+ b.write("tag v1.2.3.4.5\n".getBytes(CHARSET));
b
.write("tagger F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n"
.getBytes(ISO_8859_1));
- b.write("encoding EUC-JP\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("\u304d\u308c\u3044\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("Hi\n".getBytes(UTF_8));
+ b.write("encoding EUC-JP\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("\u304d\u308c\u3044\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("Hi\n".getBytes(CHARSET));
final RevTag c;
c = new RevTag(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
c.parseCanonical(new RevWalk(db), b.toByteArray());
public void testParse_explicit_bad_encoded2() throws Exception {
final ByteArrayOutputStream b = new ByteArrayOutputStream();
b.write("object 9788669ad918b6fcce64af8882fc9a81cb6aba67\n"
- .getBytes(UTF_8));
- b.write("type tree\n".getBytes(UTF_8));
- b.write("tag v1.2.3.4.5\n".getBytes(UTF_8));
+ .getBytes(CHARSET));
+ b.write("type tree\n".getBytes(CHARSET));
+ b.write("tag v1.2.3.4.5\n".getBytes(CHARSET));
b
.write("tagger F\u00f6r fattare <a_u_thor@example.com> 1218123387 +0700\n"
- .getBytes(UTF_8));
- b.write("encoding ISO-8859-1\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("\u304d\u308c\u3044\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("Hi\n".getBytes(UTF_8));
+ .getBytes(CHARSET));
+ b.write("encoding ISO-8859-1\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("\u304d\u308c\u3044\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("Hi\n".getBytes(CHARSET));
final RevTag c;
c = new RevTag(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
c.parseCanonical(new RevWalk(db), b.toByteArray());
@Test
public void testParse_illegalEncoding() throws Exception {
ByteArrayOutputStream b = new ByteArrayOutputStream();
- b.write("object 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
- b.write("type tree\n".getBytes(UTF_8));
- b.write("tag v1.0\n".getBytes(UTF_8));
- b.write("tagger t <t@example.com> 1218123387 +0700\n".getBytes(UTF_8));
- b.write("encoding utf-8logoutputencoding=gbk\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("message\n".getBytes(UTF_8));
+ b.write("object 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(CHARSET));
+ b.write("type tree\n".getBytes(CHARSET));
+ b.write("tag v1.0\n".getBytes(CHARSET));
+ b.write("tagger t <t@example.com> 1218123387 +0700\n".getBytes(CHARSET));
+ b.write("encoding utf-8logoutputencoding=gbk\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("message\n".getBytes(CHARSET));
RevTag t = new RevTag(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
t.parseCanonical(new RevWalk(db), b.toByteArray());
@Test
public void testParse_unsupportedEncoding() throws Exception {
ByteArrayOutputStream b = new ByteArrayOutputStream();
- b.write("object 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
- b.write("type tree\n".getBytes(UTF_8));
- b.write("tag v1.0\n".getBytes(UTF_8));
- b.write("tagger t <t@example.com> 1218123387 +0700\n".getBytes(UTF_8));
- b.write("encoding it_IT.UTF8\n".getBytes(UTF_8));
- b.write("\n".getBytes(UTF_8));
- b.write("message\n".getBytes(UTF_8));
+ b.write("object 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(CHARSET));
+ b.write("type tree\n".getBytes(CHARSET));
+ b.write("tag v1.0\n".getBytes(CHARSET));
+ b.write("tagger t <t@example.com> 1218123387 +0700\n".getBytes(CHARSET));
+ b.write("encoding it_IT.UTF8\n".getBytes(CHARSET));
+ b.write("\n".getBytes(CHARSET));
+ b.write("message\n".getBytes(CHARSET));
RevTag t = new RevTag(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
t.parseCanonical(new RevWalk(db), b.toByteArray());
*/
package org.eclipse.jgit.storage.file;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.util.FileUtils.pathToString;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
@Test
public void testUTF8withoutBOM() throws IOException, ConfigInvalidException {
- final File file = createFile(CONTENT1.getBytes(UTF_8));
+ final File file = createFile(CONTENT1.getBytes(CHARSET));
final FileBasedConfig config = new FileBasedConfig(file, FS.DETECTED);
config.load();
assertEquals(ALICE, config.getString(USER, null, NAME));
bos1.write(0xEF);
bos1.write(0xBB);
bos1.write(0xBF);
- bos1.write(CONTENT1.getBytes(UTF_8));
+ bos1.write(CONTENT1.getBytes(CHARSET));
final File file = createFile(bos1.toByteArray());
final FileBasedConfig config = new FileBasedConfig(file, FS.DETECTED);
bos2.write(0xEF);
bos2.write(0xBB);
bos2.write(0xBF);
- bos2.write(CONTENT2.getBytes(UTF_8));
+ bos2.write(CONTENT2.getBytes(CHARSET));
assertArrayEquals(bos2.toByteArray(), IO.readFully(file));
}
package org.eclipse.jgit.transport;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
Ref ref = repo.exactRef(refName);
assertNotNull(ref);
assertEquals(id, ref.getObjectId());
- assertEquals(data, new String(repo.open(id, OBJ_BLOB).getBytes(), UTF_8));
+ assertEquals(data, new String(repo.open(id, OBJ_BLOB).getBytes(), CHARSET));
}
}
package org.eclipse.jgit.transport;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.transport.WalkEncryptionTest.Util.cryptoCipherListPBE;
import static org.eclipse.jgit.transport.WalkEncryptionTest.Util.cryptoCipherListTrans;
import static org.eclipse.jgit.transport.WalkEncryptionTest.Util.folderDelete;
* @throws Exception
*/
static String textRead(File file) throws Exception {
- return new String(Files.readAllBytes(file.toPath()), UTF_8);
+ return new String(Files.readAllBytes(file.toPath()), CHARSET);
}
/**
* @throws Exception
*/
static void textWrite(File file, String text) throws Exception {
- Files.write(file.toPath(), text.getBytes(UTF_8));
+ Files.write(file.toPath(), text.getBytes(CHARSET));
}
static void verifyFileContent(File fileOne, File fileTwo)
AmazonS3 s3 = new AmazonS3(props);
String file = JGIT_USER + "-" + UUID.randomUUID().toString();
String path = JGIT_REMOTE_DIR + "/" + file;
- s3.put(bucket, path, file.getBytes(UTF_8));
+ s3.put(bucket, path, file.getBytes(CHARSET));
s3.delete(bucket, path);
}
*/
package org.eclipse.jgit.util;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
}
private static RawCharSequence raw(String text) {
- byte[] bytes = text.getBytes(UTF_8);
+ byte[] bytes = text.getBytes(CHARSET);
return new RawCharSequence(bytes, 0, bytes.length);
}
}
package org.eclipse.jgit.util.io;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayInputStream;
}
private static byte[] asBytes(String in) {
- return in.getBytes(UTF_8);
+ return in.getBytes(CHARSET);
}
}
package org.eclipse.jgit.util.sha1;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
.fromString("a9993e364706816aba3e25717850c26c9cd0d89d");
MessageDigest m = MessageDigest.getInstance("SHA-1");
- m.update(TEST1.getBytes(UTF_8));
+ m.update(TEST1.getBytes(CHARSET));
ObjectId m1 = ObjectId.fromRaw(m.digest());
SHA1 s = SHA1.newInstance();
- s.update(TEST1.getBytes(UTF_8));
+ s.update(TEST1.getBytes(CHARSET));
ObjectId s1 = ObjectId.fromRaw(s.digest());
s.reset();
- s.update(TEST1.getBytes(UTF_8));
+ s.update(TEST1.getBytes(CHARSET));
ObjectId s2 = s.toObjectId();
assertEquals(m1, s1);
.fromString("84983e441c3bd26ebaae4aa1f95129e5e54670f1");
MessageDigest m = MessageDigest.getInstance("SHA-1");
- m.update(TEST2.getBytes(UTF_8));
+ m.update(TEST2.getBytes(CHARSET));
ObjectId m1 = ObjectId.fromRaw(m.digest());
SHA1 s = SHA1.newInstance();
- s.update(TEST2.getBytes(UTF_8));
+ s.update(TEST2.getBytes(CHARSET));
ObjectId s1 = ObjectId.fromRaw(s.digest());
s.reset();
- s.update(TEST2.getBytes(UTF_8));
+ s.update(TEST2.getBytes(CHARSET));
ObjectId s2 = s.toObjectId();
assertEquals(m1, s1);
*/
package org.eclipse.jgit.hooks;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
PrintStream hookErrRedirect = null;
try {
hookErrRedirect = new PrintStream(errorByteArray, false,
- UTF_8.name());
+ CHARSET.name());
} catch (UnsupportedEncodingException e) {
// UTF-8 is guaranteed to be available
}
hookErrRedirect, getStdinArgs());
if (result.isExecutedWithError()) {
throw new AbortedByHookException(
- new String(errorByteArray.toByteArray(), UTF_8),
+ new String(errorByteArray.toByteArray(), CHARSET),
getHookName(), result.getExitCode());
}
}
package org.eclipse.jgit.internal.storage.dfs;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.util.Arrays;
*/
public static DfsStreamKey of(DfsRepositoryDescription repo, String name,
@Nullable PackExt ext) {
- return new ByteArrayDfsStreamKey(repo, name.getBytes(UTF_8), ext);
+ return new ByteArrayDfsStreamKey(repo, name.getBytes(CHARSET), ext);
}
final int hash;
package org.eclipse.jgit.internal.storage.file;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.BufferedReader;
import java.io.File;
if (content.length() > 0) {
nonEmpty = true;
}
- lock.write(content.getBytes(UTF_8));
+ lock.write(content.getBytes(CHARSET));
}
}
package org.eclipse.jgit.internal.storage.file;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.BufferedReader;
import java.io.File;
private ObjectIdOwnerMap<Entry> load() {
ObjectIdOwnerMap<Entry> r = new ObjectIdOwnerMap<>();
try (FileInputStream fin = new FileInputStream(src);
- Reader rin = new InputStreamReader(fin, UTF_8);
+ Reader rin = new InputStreamReader(fin, CHARSET);
BufferedReader br = new BufferedReader(rin)) {
MutableObjectId id = new MutableObjectId();
for (String line; (line = br.readLine()) != null;) {
package org.eclipse.jgit.internal.storage.reftable;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.internal.storage.reftable.BlockWriter.compare;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.FILE_BLOCK_TYPE;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.FILE_HEADER_LEN;
if (blockType == LOG_BLOCK_TYPE) {
len -= 9;
}
- return RawParseUtils.decode(UTF_8, nameBuf, 0, len);
+ return RawParseUtils.decode(CHARSET, nameBuf, 0, len);
}
boolean match(byte[] match, boolean matchIsPrefix) {
}
Ref readRef() throws IOException {
- String name = RawParseUtils.decode(UTF_8, nameBuf, 0, nameLen);
+ String name = RawParseUtils.decode(CHARSET, nameBuf, 0, nameLen);
switch (valueType & VALUE_TYPE_MASK) {
case VALUE_NONE: // delete
return newRef(name);
private String readValueString() {
int len = readVarint32();
int end = ptr + len;
- String s = RawParseUtils.decode(UTF_8, buf, ptr, end);
+ String s = RawParseUtils.decode(CHARSET, buf, ptr, end);
ptr = end;
return s;
}
package org.eclipse.jgit.internal.storage.reftable;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.FILE_HEADER_LEN;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.INDEX_BLOCK_TYPE;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.LOG_BLOCK_TYPE;
}
private static byte[] nameUtf8(Ref ref) {
- return ref.getName().getBytes(UTF_8);
+ return ref.getName().getBytes(CHARSET);
}
}
this.newId = newId;
this.timeSecs = who.getWhen().getTime() / 1000L;
this.tz = (short) who.getTimeZoneOffset();
- this.name = who.getName().getBytes(UTF_8);
- this.email = who.getEmailAddress().getBytes(UTF_8);
- this.msg = message.getBytes(UTF_8);
+ this.name = who.getName().getBytes(CHARSET);
+ this.email = who.getEmailAddress().getBytes(CHARSET);
+ this.msg = message.getBytes(CHARSET);
}
static byte[] key(String ref, long index) {
- byte[] name = ref.getBytes(UTF_8);
+ byte[] name = ref.getBytes(CHARSET);
byte[] key = Arrays.copyOf(name, name.length + 1 + 8);
NB.encodeInt64(key, key.length - 8, reverseUpdateIndex(index));
return key;
package org.eclipse.jgit.internal.storage.reftable;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.FILE_HEADER_LEN;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.INDEX_BLOCK_TYPE;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.LOG_BLOCK_TYPE;
}
void writeVarintString(String s) {
- writeVarintString(s.getBytes(UTF_8));
+ writeVarintString(s.getBytes(CHARSET));
}
void writeVarintString(byte[] msg) {
package org.eclipse.jgit.internal.storage.reftable;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.internal.storage.reftable.BlockReader.decodeBlockLen;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.FILE_BLOCK_TYPE;
import static org.eclipse.jgit.internal.storage.reftable.ReftableConstants.FILE_FOOTER_LEN;
public RefCursor seekRef(String refName) throws IOException {
initRefIndex();
- byte[] key = refName.getBytes(UTF_8);
+ byte[] key = refName.getBytes(CHARSET);
boolean prefix = key[key.length - 1] == '/';
RefCursorImpl i = new RefCursorImpl(refEnd, key, prefix);
initLogIndex();
if (logPosition > 0) {
byte[] key = LogEntry.key(refName, updateIndex);
- byte[] match = refName.getBytes(UTF_8);
+ byte[] match = refName.getBytes(CHARSET);
LogCursorImpl i = new LogCursorImpl(logEnd, match);
i.block = seek(LOG_BLOCK_TYPE, key, logIndex, logPosition, logEnd);
return i;
package org.eclipse.jgit.lib;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
+
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.MessageFormat;
super(base);
final String decoded;
if (isUtf8(blob)) {
- decoded = RawParseUtils.decode(RawParseUtils.UTF8_CHARSET,
- blob, 3, blob.length);
+ decoded = RawParseUtils.decode(CHARSET, blob, 3, blob.length);
} else {
decoded = RawParseUtils.decode(blob);
}
package org.eclipse.jgit.lib;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
+
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
String decoded;
if (isUtf8(bytes)) {
- decoded = RawParseUtils.decode(RawParseUtils.UTF8_CHARSET, bytes, 3,
- bytes.length);
+ decoded = RawParseUtils.decode(CHARSET, bytes, 3, bytes.length);
} else {
decoded = RawParseUtils.decode(bytes);
}
public static final byte[] PACK_SIGNATURE = { 'P', 'A', 'C', 'K' };
/** Native character encoding for commit messages, file names... */
- public static final Charset CHARSET = UTF_8;
+ public static final Charset CHARSET;
/** Native character encoding for commit messages, file names... */
- public static final String CHARACTER_ENCODING = CHARSET.name();
+ public static final String CHARACTER_ENCODING;
/** Default main branch name */
public static final String MASTER = "master";
static {
if (OBJECT_ID_LENGTH != newMessageDigest().getDigestLength())
throw new LinkageError(JGitText.get().incorrectOBJECT_ID_LENGTH);
+ CHARSET = UTF_8;
+ CHARACTER_ENCODING = CHARSET.name();
}
/** name of the file containing the commit msg for a merge commit */
package org.eclipse.jgit.lib;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.BufferedOutputStream;
import java.io.File;
switch (tokenCount) {
case 0:
String actionToken = new String(buf, tokenBegin,
- nextSpace - tokenBegin - 1, UTF_8);
+ nextSpace - tokenBegin - 1, CHARSET);
tokenBegin = nextSpace;
action = RebaseTodoLine.Action.parse(actionToken);
if (action == null)
case 1:
nextSpace = RawParseUtils.next(buf, tokenBegin, ' ');
String commitToken = new String(buf, tokenBegin,
- nextSpace - tokenBegin - 1, UTF_8);
+ nextSpace - tokenBegin - 1, CHARSET);
tokenBegin = nextSpace;
commit = AbbreviatedObjectId.fromString(commitToken);
break;
package org.eclipse.jgit.lib;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.IOException;
import java.io.OutputStreamWriter;
* Initialize a new progress monitor.
*/
public TextProgressMonitor() {
- this(new PrintWriter(new OutputStreamWriter(System.err, UTF_8)));
+ this(new PrintWriter(new OutputStreamWriter(System.err, CHARSET)));
}
/**
package org.eclipse.jgit.revwalk;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.IOException;
import java.nio.charset.Charset;
try {
return getEncoding();
} catch (IllegalCharsetNameException | UnsupportedCharsetException e) {
- return UTF_8;
+ return CHARSET;
}
}
package org.eclipse.jgit.revwalk;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.IOException;
import java.nio.charset.Charset;
int p = pos.value += 4; // "tag "
final int nameEnd = RawParseUtils.nextLF(rawTag, p) - 1;
- tagName = RawParseUtils.decode(UTF_8, rawTag, p, nameEnd);
+ tagName = RawParseUtils.decode(CHARSET, rawTag, p, nameEnd);
if (walk.isRetainBody())
buffer = rawTag;
try {
return RawParseUtils.parseEncoding(buffer);
} catch (IllegalCharsetNameException | UnsupportedCharsetException e) {
- return UTF_8;
+ return CHARSET;
}
}
package org.eclipse.jgit.storage.file;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
+
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
} else {
final String decoded;
if (isUtf8(in)) {
- decoded = RawParseUtils.decode(RawParseUtils.UTF8_CHARSET,
+ decoded = RawParseUtils.decode(CHARSET,
in, 3, in.length);
utf8Bom = true;
} else {
bos.write(0xEF);
bos.write(0xBB);
bos.write(0xBF);
- bos.write(text.getBytes(RawParseUtils.UTF8_CHARSET.name()));
+ bos.write(text.getBytes(CHARSET));
out = bos.toByteArray();
} else {
out = Constants.encode(text);
package org.eclipse.jgit.transport;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.ByteArrayOutputStream;
import java.io.File;
try {
final Mac m = Mac.getInstance(HMAC);
m.init(privateKey);
- sec = Base64.encodeBytes(m.doFinal(s.toString().getBytes(UTF_8)));
+ sec = Base64.encodeBytes(m.doFinal(s.toString().getBytes(CHARSET)));
} catch (NoSuchAlgorithmException e) {
throw new IOException(MessageFormat.format(JGitText.get().noHMACsupport, HMAC, e.getMessage()));
} catch (InvalidKeyException e) {
package org.eclipse.jgit.transport;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.File;
import java.security.InvalidKeyException;
}
String input = path + ":" + String.valueOf(timestamp); //$NON-NLS-1$
- byte[] rawHmac = mac.doFinal(input.getBytes(UTF_8));
+ byte[] rawHmac = mac.doFinal(input.getBytes(CHARSET));
return Long.toString(timestamp) + "-" + toHex(rawHmac); //$NON-NLS-1$
}
package org.eclipse.jgit.transport;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.util.HttpSupport.HDR_AUTHORIZATION;
import static org.eclipse.jgit.util.HttpSupport.HDR_WWW_AUTHENTICATE;
@Override
void configureRequest(final HttpConnection conn) throws IOException {
String ident = user + ":" + pass; //$NON-NLS-1$
- String enc = Base64.encodeBytes(ident.getBytes(UTF_8));
+ String enc = Base64.encodeBytes(ident.getBytes(CHARSET));
conn.setRequestProperty(HDR_AUTHORIZATION, type.getSchemeName()
+ " " + enc); //$NON-NLS-1$
}
private static String H(String data) {
MessageDigest md = newMD5();
- md.update(data.getBytes(UTF_8));
+ md.update(data.getBytes(CHARSET));
return LHEX(md.digest());
}
private static String KD(String secret, String data) {
MessageDigest md = newMD5();
- md.update(secret.getBytes(UTF_8));
+ md.update(secret.getBytes(CHARSET));
md.update((byte) ':');
- md.update(data.getBytes(UTF_8));
+ md.update(data.getBytes(CHARSET));
return LHEX(md.digest());
}
package org.eclipse.jgit.transport;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import java.io.IOException;
import java.io.OutputStream;
private void write(String s) {
if (write) {
try {
- out.write(s.getBytes(UTF_8));
+ out.write(s.getBytes(CHARSET));
out.flush();
} catch (IOException e) {
write = false;
package org.eclipse.jgit.transport;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.util.RawParseUtils.lastIndexOfTrim;
import java.text.SimpleDateFormat;
*/
public static PushCertificateIdent parse(String str) {
MutableInteger p = new MutableInteger();
- byte[] raw = str.getBytes(UTF_8);
+ byte[] raw = str.getBytes(CHARSET);
int tzBegin = raw.length - 1;
tzBegin = lastIndexOfTrim(raw, ' ', tzBegin);
if (tzBegin < 0 || raw[tzBegin] != ' ') {
idEnd = raw.length;
}
}
- String id = new String(raw, 0, idEnd, UTF_8);
+ String id = new String(raw, 0, idEnd, CHARSET);
return new PushCertificateIdent(str, id, when * 1000L, tz);
}
package org.eclipse.jgit.transport;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
import static org.eclipse.jgit.lib.Constants.OBJ_COMMIT;
import static org.eclipse.jgit.lib.FileMode.TYPE_FILE;
ObjectLoader loader =
tw.getObjectReader().open(tw.getObjectId(0), OBJ_BLOB);
try (InputStream in = loader.openStream();
- Reader r = new BufferedReader(new InputStreamReader(in, UTF_8))) {
+ Reader r = new BufferedReader(new InputStreamReader(in, CHARSET))) {
return PushCertificateParser.fromReader(r);
}
}
DirCacheEditor editor = dc.editor();
String certText = pc.cert.toText() + pc.cert.getSignature();
- final ObjectId certId = inserter.insert(OBJ_BLOB, certText.getBytes(UTF_8));
+ final ObjectId certId = inserter.insert(OBJ_BLOB, certText.getBytes(CHARSET));
boolean any = false;
for (ReceiveCommand cmd : pc.cert.getCommands()) {
if (byRef != null && !commandsEqual(cmd, byRef.get(cmd.getRefName()))) {
package org.eclipse.jgit.transport;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.lib.Constants.OBJECT_ID_STRING_LENGTH;
import static org.eclipse.jgit.transport.GitProtocolConstants.OPTION_SYMREF;
public abstract class RefAdvertiser {
/** Advertiser which frames lines in a {@link PacketLineOut} format. */
public static class PacketLineOutRefAdvertiser extends RefAdvertiser {
- private final CharsetEncoder utf8 = UTF_8.newEncoder();
+ private final CharsetEncoder utf8 = CHARSET.newEncoder();
private final PacketLineOut pckOut;
private byte[] binArr = new byte[256];
package org.eclipse.jgit.transport;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
import static org.eclipse.jgit.lib.RefDatabase.ALL;
import java.io.BufferedReader;
BufferedReader br;
try {
InputStream urlIn = url.openStream();
- br = new BufferedReader(new InputStreamReader(urlIn, "UTF-8")); //$NON-NLS-1$
+ br = new BufferedReader(new InputStreamReader(urlIn, CHARSET));
} catch (IOException err) {
// If we cannot read from the service list, go to the next.
//
package org.eclipse.jgit.util;
-import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
-import java.nio.charset.StandardCharsets;
import java.text.MessageFormat;
import java.util.Arrays;
+ "abcdefghijklmnopqrstuvwxyz" // //$NON-NLS-1$
+ "0123456789" // //$NON-NLS-1$
+ "+/" // //$NON-NLS-1$
- ).getBytes(UTF_8);
+ ).getBytes(CHARSET);
DEC = new byte[128];
Arrays.fill(DEC, INVALID_DEC);
e += 4;
}
- return new String(outBuff, 0, e, StandardCharsets.UTF_8);
+ return new String(outBuff, 0, e, CHARSET);
}
/**
* @return the decoded data
*/
public static byte[] decode(String s) {
- byte[] bytes = s.getBytes(UTF_8);
+ byte[] bytes = s.getBytes(CHARSET);
return decode(bytes, 0, bytes.length);
}
}
package org.eclipse.jgit.util;
+import static org.eclipse.jgit.lib.Constants.CHARSET;
+
import java.io.File;
import java.io.PrintStream;
import java.nio.file.Files;
try {
w = readPipe(dir, //
new String[] { cygpath, "--windows", "--absolute", pn }, // //$NON-NLS-1$ //$NON-NLS-2$
- "UTF-8"); //$NON-NLS-1$
+ CHARSET.name());
} catch (CommandFailedException e) {
LOG.warn(e.getMessage());
return null;
package org.eclipse.jgit.util;
+import static org.eclipse.jgit.lib.Constants.CHARACTER_ENCODING;
+
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.ConnectException;
if (key == null || key.length() == 0)
return;
try {
- urlstr.append(URLEncoder.encode(key, "UTF-8")); //$NON-NLS-1$
+ urlstr.append(URLEncoder.encode(key, CHARACTER_ENCODING));
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(JGitText.get().couldNotURLEncodeToUTF8, e);
}
projects / jgit.git / commitdiff