package org.eclipse.jgit.http.test;
+import static java.nio.charset.StandardCharsets.UTF_8;
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;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URISyntaxException;
-import java.nio.charset.StandardCharsets;
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.Collection;
public void testInvalidWant() throws Exception {
@SuppressWarnings("resource")
ObjectId id = new ObjectInserter.Formatter().idFor(Constants.OBJ_BLOB,
- "testInvalidWant".getBytes(StandardCharsets.UTF_8));
+ "testInvalidWant".getBytes(UTF_8));
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.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(UTF_8));
}
/**
*/
package org.eclipse.jgit.lfs.server.s3;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.eclipse.jgit.util.HttpSupport.HDR_AUTHORIZATION;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.net.URLEncoder;
-import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
private static byte[] hash(String s) {
MessageDigest md = Constants.newMessageDigest();
- md.update(s.getBytes(StandardCharsets.UTF_8));
+ md.update(s.getBytes(UTF_8));
return md.digest();
}
private static byte[] sign(String stringData, byte[] key) {
try {
- byte[] data = stringData.getBytes("UTF-8"); //$NON-NLS-1$
+ byte[] data = stringData.getBytes(UTF_8);
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, StandardCharsets.UTF_8.name());
+ encoded = URLEncoder.encode(url, UTF_8.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 java.io.BufferedInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
*/
public static LongObjectId hash(String s) {
MessageDigest md = Constants.newMessageDigest();
- md.update(s.getBytes(StandardCharsets.UTF_8));
+ md.update(s.getBytes(UTF_8));
return LongObjectId.fromRaw(md.digest());
}
package org.eclipse.jgit.lfs.lib;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
-import java.nio.charset.StandardCharsets;
import org.eclipse.jgit.lfs.LfsPointer;
import org.junit.Test;
baos.close();
assertEquals("version https://git-lfs.github.com/spec/v1\noid sha256:"
+ s + "\nsize 4\n",
- baos.toString(StandardCharsets.UTF_8.name()));
+ baos.toString(UTF_8.name()));
}
}
package org.eclipse.jgit.lfs.lib;
+import static java.nio.charset.StandardCharsets.US_ASCII;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import java.io.OutputStreamWriter;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Locale;
public void testCopyFromStringByte() {
AnyLongObjectId id1 = LongObjectIdTestUtils.hash("test");
byte[] buf = new byte[64];
- Charset cs = StandardCharsets.US_ASCII;
+ Charset cs = US_ASCII;
cs.encode(id1.name()).get(buf);
AnyLongObjectId id2 = LongObjectId.fromString(buf, 0);
assertEquals("objects should be equals", id1, id2);
*/
package org.eclipse.jgit.lfs;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
-import java.nio.charset.StandardCharsets;
import java.nio.charset.UnsupportedCharsetException;
import java.util.Locale;
*/
public void encode(OutputStream out) {
try (PrintStream ps = new PrintStream(out, false,
- StandardCharsets.UTF_8.name())) {
+ UTF_8.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(
- StandardCharsets.UTF_8.name());
+ throw new UnsupportedCharsetException(UTF_8.name());
}
}
long sz = -1;
try (BufferedReader br = new BufferedReader(
- new InputStreamReader(in, StandardCharsets.UTF_8.name()))) {
+ new InputStreamReader(in, UTF_8))) {
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.errors;
-import java.io.UnsupportedEncodingException;
+import static java.nio.charset.StandardCharsets.US_ASCII;
+
import java.text.MessageFormat;
import org.eclipse.jgit.lfs.internal.LfsText;
private static String asAscii(byte[] bytes, int offset, int length) {
try {
- return new String(bytes, offset, length, "US-ASCII"); //$NON-NLS-1$
- } catch (UnsupportedEncodingException e2) {
- return ""; //$NON-NLS-1$
- } catch (StringIndexOutOfBoundsException e2) {
+ return new String(bytes, offset, length, US_ASCII);
+ } catch (StringIndexOutOfBoundsException e) {
return ""; //$NON-NLS-1$
}
}
*/
package org.eclipse.jgit.ignore;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
-import java.io.UnsupportedEncodingException;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import java.util.Arrays;
private String pattern;
- public CGitIgnoreRule(File gitDir, String pattern)
- throws UnsupportedEncodingException, IOException {
+ public CGitIgnoreRule(File gitDir, String pattern) throws IOException {
this.gitDir = gitDir;
this.pattern = pattern;
Files.write(FileUtils.toPath(new File(gitDir, ".gitignore")),
- (pattern + "\n").getBytes("UTF-8"),
- StandardOpenOption.CREATE,
+ (pattern + "\n").getBytes(UTF_8), StandardOpenOption.CREATE,
StandardOpenOption.TRUNCATE_EXISTING,
StandardOpenOption.WRITE);
}
Process proc = Runtime.getRuntime().exec(command, new String[0],
gitDir);
OutputStream out = proc.getOutputStream();
- out.write((path + "\n").getBytes("UTF-8"));
+ out.write((path + "\n").getBytes(UTF_8));
out.flush();
out.close();
return proc;
package org.eclipse.jgit.patch;
+import static java.nio.charset.StandardCharsets.ISO_8859_1;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
commitId = line.substring("commit ".length());
buf = new TemporaryBuffer.LocalFile(null);
} else if (buf != null) {
- buf.write(line.getBytes("ISO-8859-1"));
+ buf.write(line.getBytes(ISO_8859_1));
buf.write('\n');
}
}
package org.eclipse.jgit.api;
+import static java.nio.charset.StandardCharsets.UTF_8;
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;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
-import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import org.eclipse.jgit.lib.CoreConfig.EolStreamType;
EolStreamType streamTypeWithBinaryCheck, String output,
String expectedConversion) throws Exception {
ByteArrayOutputStream b;
- byte[] outputBytes = output.getBytes(StandardCharsets.UTF_8);
- byte[] expectedConversionBytes = expectedConversion
- .getBytes(StandardCharsets.UTF_8);
+ byte[] outputBytes = output.getBytes(UTF_8);
+ byte[] expectedConversionBytes = expectedConversion.getBytes(UTF_8);
// 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(StandardCharsets.UTF_8);
- byte[] expectedConversionBytes = expectedConversion
- .getBytes(StandardCharsets.UTF_8);
+ byte[] inputBytes = input.getBytes(UTF_8);
+ byte[] expectedConversionBytes = expectedConversion.getBytes(UTF_8);
// 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.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
FileOutputStream fos = null;
try {
fos = new FileOutputStream(actFile);
- fos.write(string.getBytes("UTF-8"));
+ fos.write(string.getBytes(UTF_8));
fos.close();
} finally {
if (fos != null)
*/
package org.eclipse.jgit.api;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
FileOutputStream fos = null;
try {
fos = new FileOutputStream(actFile);
- fos.write(string.getBytes("UTF-8"));
+ fos.write(string.getBytes(UTF_8));
fos.close();
} finally {
if (fos != null)
*/
package org.eclipse.jgit.api;
+import static java.nio.charset.StandardCharsets.UTF_8;
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(UTF_8));
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(UTF_8));
assertEquals(ident.getName(), parsedIdent.getName());
assertEquals(ident.getEmailAddress(), parsedIdent.getEmailAddress());
assertEquals(123456789000L, parsedIdent.getWhen().getTime());
package org.eclipse.jgit.diff;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import java.io.UnsupportedEncodingException;
-
import org.junit.Test;
public abstract class AbstractDiffTestCase {
r.append(text.charAt(i));
r.append('\n');
}
- try {
- return new RawText(r.toString().getBytes("UTF-8"));
- } catch (UnsupportedEncodingException e) {
- throw new RuntimeException(e);
- }
+ return new RawText(r.toString().getBytes(UTF_8));
}
}
package org.eclipse.jgit.diff;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
-import java.io.UnsupportedEncodingException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.util.RawParseUtils;
}
@Test
- public void testComparatorReduceCommonStartEnd()
- throws UnsupportedEncodingException {
+ public void testComparatorReduceCommonStartEnd() {
final RawTextComparator c = RawTextComparator.DEFAULT;
Edit e;
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(UTF_8));
+ RawText b = new RawText("p\na b \nR\n c d \n".getBytes(UTF_8));
e = new Edit(0, 4, 0, 4);
e = RawTextComparator.WS_IGNORE_ALL.reduceCommonStartEnd(a, b, e);
assertEquals(new Edit(2, 3, 2, 3), e);
}
@Test
- public void testComparatorReduceCommonStartEnd_EmptyLine()
- throws UnsupportedEncodingException {
+ public void testComparatorReduceCommonStartEnd_EmptyLine() {
RawText a;
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(UTF_8));
+ b = new RawText("S\n\n y\n".getBytes(UTF_8));
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(UTF_8));
+ b = new RawText("R\n y\n".getBytes(UTF_8));
e = new Edit(0, 3, 0, 2);
e = RawTextComparator.DEFAULT.reduceCommonStartEnd(a, b, e);
assertEquals(new Edit(0, 2, 0, 1), e);
}
@Test
- public void testComparatorReduceCommonStartButLastLineNoEol()
- throws UnsupportedEncodingException {
+ public void testComparatorReduceCommonStartButLastLineNoEol() {
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(UTF_8));
+ b = new RawText("start of line".getBytes(UTF_8));
e = new Edit(0, 1, 0, 1);
e = RawTextComparator.DEFAULT.reduceCommonStartEnd(a, b, e);
assertEquals(new Edit(0, 1, 0, 1), e);
}
@Test
- public void testComparatorReduceCommonStartButLastLineNoEol_2()
- throws UnsupportedEncodingException {
+ public void testComparatorReduceCommonStartButLastLineNoEol_2() {
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(UTF_8));
+ b = new RawText("start of\nlastline".getBytes(UTF_8));
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');
}
- try {
- return new RawText(r.toString().getBytes("UTF-8"));
- } catch (UnsupportedEncodingException e) {
- throw new RuntimeException(e);
- }
+ return new RawText(r.toString().getBytes(UTF_8));
}
}
package org.eclipse.jgit.diff;
+import static java.nio.charset.StandardCharsets.UTF_8;
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(UTF_8);
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(UTF_8);
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(UTF_8);
dst.hash(new ByteArrayInputStream(bytes2), bytes2.length, true);
dst.sort();
*/
package org.eclipse.jgit.gitrepo;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import java.io.FileReader;
import java.io.IOException;
import java.net.URI;
-import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
repos.put("platform/base", child);
RevCommit commit = cmd
- .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(StandardCharsets.UTF_8)))
+ .setInputStream(new ByteArrayInputStream(
+ xmlContent.toString().getBytes(UTF_8)))
.setRemoteReader(repos)
.setURI("platform/")
.setTargetURI("platform/superproject")
repos.put("plugins/cookbook", child);
RevCommit commit = cmd
- .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(StandardCharsets.UTF_8)))
+ .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(UTF_8)))
.setRemoteReader(repos)
.setURI("")
.setTargetURI("gerrit")
repos.put(repoUrl, child);
RevCommit commit = cmd
- .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(StandardCharsets.UTF_8)))
+ .setInputStream(new ByteArrayInputStream(xmlContent.toString().getBytes(UTF_8)))
.setRemoteReader(repos)
.setURI(baseUrl)
.setTargetURI("gerrit")
*/
package org.eclipse.jgit.ignore;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.eclipse.jgit.junit.Assert.assertEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
writeTrashFile(name, data.toString());
}
- private InputStream writeToString(String... rules) throws IOException {
+ private InputStream writeToString(String... rules) {
StringBuilder data = new StringBuilder();
for (String line : rules) {
data.append(line + "\n");
}
- return new ByteArrayInputStream(data.toString().getBytes("UTF-8"));
+ return new ByteArrayInputStream(data.toString().getBytes(UTF_8));
}
}
*/
package org.eclipse.jgit.indexdiff;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.io.Writer;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
File restoreScript = new File(testDir, name + ".sh");
try (OutputStream out = new BufferedOutputStream(
new FileOutputStream(restoreScript));
- Writer writer = new OutputStreamWriter(out,
- StandardCharsets.UTF_8)) {
+ Writer writer = new OutputStreamWriter(out, UTF_8)) {
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.ISO_8859_1;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
}
@Test
- public void test025_computeSha1NoStore() throws IOException {
+ public void test025_computeSha1NoStore() {
byte[] data = "test025 some data, more than 16 bytes to get good coverage"
- .getBytes("ISO-8859-1");
+ .getBytes(ISO_8859_1);
try (ObjectInserter.Formatter formatter = new ObjectInserter.Formatter()) {
final ObjectId id = formatter.idFor(Constants.OBJ_BLOB, data);
assertEquals("4f561df5ecf0dfbd53a0dc0f37262fef075d9dde", id.name());
package org.eclipse.jgit.lib;
import static java.lang.Integer.valueOf;
+import static java.nio.charset.StandardCharsets.UTF_8;
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;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.fail;
-import java.io.UnsupportedEncodingException;
import java.text.MessageFormat;
import org.eclipse.jgit.errors.CorruptObjectException;
@Test
public void testInvalidTreeDuplicateNames5()
- throws UnsupportedEncodingException, CorruptObjectException {
+ throws CorruptObjectException {
StringBuilder b = new StringBuilder();
entry(b, "100644 A");
entry(b, "100644 a");
- byte[] data = b.toString().getBytes("UTF-8");
+ byte[] data = b.toString().getBytes(UTF_8);
checker.setSafeForWindows(true);
assertCorrupt("duplicate entry names", OBJ_TREE, data);
assertSkipListAccepts(OBJ_TREE, data);
@Test
public void testInvalidTreeDuplicateNames6()
- throws UnsupportedEncodingException, CorruptObjectException {
+ throws CorruptObjectException {
StringBuilder b = new StringBuilder();
entry(b, "100644 A");
entry(b, "100644 a");
- byte[] data = b.toString().getBytes("UTF-8");
+ byte[] data = b.toString().getBytes(UTF_8);
checker.setSafeForMacOS(true);
assertCorrupt("duplicate entry names", OBJ_TREE, data);
assertSkipListAccepts(OBJ_TREE, data);
@Test
public void testInvalidTreeDuplicateNames7()
- throws UnsupportedEncodingException, CorruptObjectException {
+ throws CorruptObjectException {
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(UTF_8);
checker.setSafeForMacOS(true);
assertCorrupt("duplicate entry names", OBJ_TREE, data);
assertSkipListAccepts(OBJ_TREE, data);
@Test
public void testInvalidTreeDuplicateNames8()
- throws UnsupportedEncodingException, CorruptObjectException {
+ throws CorruptObjectException {
StringBuilder b = new StringBuilder();
entry(b, "100644 A");
checker.setSafeForMacOS(true);
- checker.checkTree(b.toString().getBytes("UTF-8"));
+ checker.checkTree(b.toString().getBytes(UTF_8));
}
@Test
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
-import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import org.eclipse.jgit.api.Git;
}
binary[50] = '\0';
- writeTrashFile("file", new String(binary, StandardCharsets.UTF_8));
+ writeTrashFile("file", new String(binary, UTF_8));
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, StandardCharsets.UTF_8));
+ writeTrashFile("file", new String(binary, UTF_8));
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, StandardCharsets.UTF_8));
+ writeTrashFile("file", new String(binary, UTF_8));
git.add().addFilepattern("file").call();
RevCommit sideCommit = git.commit().setAll(true)
.setMessage("modified file l 1500").call();
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.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
assertNull(c.getTree());
assertNull(c.parents);
- c.parseCanonical(rw, body.toString().getBytes("UTF-8"));
+ c.parseCanonical(rw, body.toString().getBytes(UTF_8));
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(UTF_8));
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(UTF_8));
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(UTF_8));
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(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));
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("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("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
+ 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));
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("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("tree 9788669ad918b6fcce64af8882fc9a81cb6aba67\n".getBytes(UTF_8));
+ 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));
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(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));
final RevCommit c;
c = new RevCommit(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67")); // bogus id
c.parseCanonical(new RevWalk(db), b.toByteArray());
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.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
assertNull(c.getObject());
assertNull(c.getTagName());
- c.parseCanonical(rw, b.toString().getBytes("UTF-8"));
+ c.parseCanonical(rw, b.toString().getBytes(UTF_8));
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(UTF_8));
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(UTF_8));
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(UTF_8));
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(UTF_8));
+ b.write("type tree\n".getBytes(UTF_8));
+ b.write("tag v1.2.3.4.5\n".getBytes(UTF_8));
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(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));
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"));
- 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"));
+ .getBytes(UTF_8));
+ b.write("type tree\n".getBytes(UTF_8));
+ b.write("tag v1.2.3.4.5\n".getBytes(UTF_8));
+ 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));
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(UTF_8));
+ b.write("type tree\n".getBytes(UTF_8));
+ b.write("tag v1.2.3.4.5\n".getBytes(UTF_8));
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"));
+ .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));
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(UTF_8));
+ b.write("type tree\n".getBytes(UTF_8));
+ b.write("tag v1.2.3.4.5\n".getBytes(UTF_8));
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(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));
final RevTag c;
c = new RevTag(id("9473095c4cb2f12aefe1db8a355fe3fafba42f67"));
c.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.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(UTF_8));
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(UTF_8));
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(UTF_8));
assertArrayEquals(bos2.toByteArray(), IO.readFully(file));
}
package org.eclipse.jgit.util;
+import static java.nio.charset.StandardCharsets.ISO_8859_1;
import static org.eclipse.jgit.util.QuotedString.GIT_PATH;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
-import java.io.UnsupportedEncodingException;
-
import org.eclipse.jgit.lib.Constants;
import org.junit.Test;
}
private static void assertDequote(final String exp, final String in) {
- final byte[] b;
- try {
- b = ('"' + in + '"').getBytes("ISO-8859-1");
- } catch (UnsupportedEncodingException e) {
- throw new RuntimeException(e);
- }
+ final byte[] b = ('"' + in + '"').getBytes(ISO_8859_1);
final String r = GIT_PATH.dequote(b, 0, b.length);
assertEquals(exp, r);
}
package org.eclipse.jgit.util;
+import static java.nio.charset.StandardCharsets.US_ASCII;
import static org.eclipse.jgit.util.RawCharUtil.isWhitespace;
import static org.eclipse.jgit.util.RawCharUtil.trimLeadingWhitespace;
import static org.eclipse.jgit.util.RawCharUtil.trimTrailingWhitespace;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import java.io.UnsupportedEncodingException;
-
import org.junit.Test;
public class RawCharUtilTest {
/**
* Test method for
* {@link RawCharUtil#trimTrailingWhitespace(byte[], int, int)}.
- *
- * @throws UnsupportedEncodingException
*/
@Test
- public void testTrimTrailingWhitespace()
- throws UnsupportedEncodingException {
- assertEquals(0, trimTrailingWhitespace("".getBytes("US-ASCII"), 0, 0));
- assertEquals(0, trimTrailingWhitespace(" ".getBytes("US-ASCII"), 0, 1));
- assertEquals(1, trimTrailingWhitespace("a ".getBytes("US-ASCII"), 0, 2));
- assertEquals(2,
- trimTrailingWhitespace(" a ".getBytes("US-ASCII"), 0, 3));
- assertEquals(3,
- trimTrailingWhitespace(" a".getBytes("US-ASCII"), 0, 3));
- assertEquals(6, trimTrailingWhitespace(
- " test ".getBytes("US-ASCII"), 2, 9));
+ public void testTrimTrailingWhitespace() {
+ assertEquals(0, trimTrailingWhitespace("".getBytes(US_ASCII), 0, 0));
+ assertEquals(0, trimTrailingWhitespace(" ".getBytes(US_ASCII), 0, 1));
+ assertEquals(1, trimTrailingWhitespace("a ".getBytes(US_ASCII), 0, 2));
+ assertEquals(2, trimTrailingWhitespace(" a ".getBytes(US_ASCII), 0, 3));
+ assertEquals(3, trimTrailingWhitespace(" a".getBytes(US_ASCII), 0, 3));
+ assertEquals(6,
+ trimTrailingWhitespace(" test ".getBytes(US_ASCII), 2, 9));
}
/**
* Test method for
* {@link RawCharUtil#trimLeadingWhitespace(byte[], int, int)}.
- *
- * @throws UnsupportedEncodingException
*/
@Test
- public void testTrimLeadingWhitespace() throws UnsupportedEncodingException {
- assertEquals(0, trimLeadingWhitespace("".getBytes("US-ASCII"), 0, 0));
- assertEquals(1, trimLeadingWhitespace(" ".getBytes("US-ASCII"), 0, 1));
- assertEquals(0, trimLeadingWhitespace("a ".getBytes("US-ASCII"), 0, 2));
- assertEquals(1, trimLeadingWhitespace(" a ".getBytes("US-ASCII"), 0, 3));
- assertEquals(2, trimLeadingWhitespace(" a".getBytes("US-ASCII"), 0, 3));
- assertEquals(2, trimLeadingWhitespace(" test ".getBytes("US-ASCII"),
+ public void testTrimLeadingWhitespace() {
+ assertEquals(0, trimLeadingWhitespace("".getBytes(US_ASCII), 0, 0));
+ assertEquals(1, trimLeadingWhitespace(" ".getBytes(US_ASCII), 0, 1));
+ assertEquals(0, trimLeadingWhitespace("a ".getBytes(US_ASCII), 0, 2));
+ assertEquals(1, trimLeadingWhitespace(" a ".getBytes(US_ASCII), 0, 3));
+ assertEquals(2, trimLeadingWhitespace(" a".getBytes(US_ASCII), 0, 3));
+ assertEquals(2,
+ trimLeadingWhitespace(" test ".getBytes(US_ASCII),
2, 9));
}
package org.eclipse.jgit.util;
+import static java.nio.charset.StandardCharsets.ISO_8859_1;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertNotNull;
-import java.io.UnsupportedEncodingException;
-
import org.junit.Test;
public class RawParseUtils_LineMapTest {
}
@Test
- public void testTwoLineFooBar() throws UnsupportedEncodingException {
- final byte[] buf = "foo\nbar\n".getBytes("ISO-8859-1");
+ public void testTwoLineFooBar() {
+ final byte[] buf = "foo\nbar\n".getBytes(ISO_8859_1);
final IntList map = RawParseUtils.lineMap(buf, 0, buf.length);
assertArrayEquals(new int[]{Integer.MIN_VALUE, 0, 4, buf.length}, asInts(map));
}
@Test
- public void testTwoLineNoLF() throws UnsupportedEncodingException {
- final byte[] buf = "foo\nbar".getBytes("ISO-8859-1");
+ public void testTwoLineNoLF() {
+ final byte[] buf = "foo\nbar".getBytes(ISO_8859_1);
final IntList map = RawParseUtils.lineMap(buf, 0, buf.length);
assertArrayEquals(new int[]{Integer.MIN_VALUE, 0, 4, buf.length}, asInts(map));
}
@Test
- public void testBinary() throws UnsupportedEncodingException {
- final byte[] buf = "xxxfoo\nb\0ar".getBytes("ISO-8859-1");
+ public void testBinary() {
+ final byte[] buf = "xxxfoo\nb\0ar".getBytes(ISO_8859_1);
final IntList map = RawParseUtils.lineMap(buf, 3, buf.length);
assertArrayEquals(new int[]{Integer.MIN_VALUE, 3, buf.length}, asInts(map));
}
@Test
- public void testFourLineBlanks() throws UnsupportedEncodingException {
- final byte[] buf = "foo\n\n\nbar\n".getBytes("ISO-8859-1");
+ public void testFourLineBlanks() {
+ final byte[] buf = "foo\n\n\nbar\n".getBytes(ISO_8859_1);
final IntList map = RawParseUtils.lineMap(buf, 0, buf.length);
assertArrayEquals(new int[]{
*/
package org.eclipse.jgit.util;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.io.UnsupportedEncodingException;
-
import org.eclipse.jgit.junit.RepositoryTestCase;
import org.junit.Test;
}
private static RawCharSequence raw(String text) {
- try {
- byte[] bytes = text.getBytes("UTF-8");
- return new RawCharSequence(bytes, 0, bytes.length);
- } catch (UnsupportedEncodingException e) {
- throw new RuntimeException(e);
- }
+ byte[] bytes = text.getBytes(UTF_8);
+ return new RawCharSequence(bytes, 0, bytes.length);
}
}
package org.eclipse.jgit.util.io;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
-import java.io.UnsupportedEncodingException;
import org.junit.Test;
}
private static byte[] asBytes(String in) {
- try {
- return in.getBytes("UTF-8");
- } catch (UnsupportedEncodingException ex) {
- throw new AssertionError();
- }
+ return in.getBytes(UTF_8);
}
}
package org.eclipse.jgit.util.sha1;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
.fromString("a9993e364706816aba3e25717850c26c9cd0d89d");
MessageDigest m = MessageDigest.getInstance("SHA-1");
- m.update(TEST1.getBytes(StandardCharsets.UTF_8));
+ m.update(TEST1.getBytes(UTF_8));
ObjectId m1 = ObjectId.fromRaw(m.digest());
SHA1 s = SHA1.newInstance();
- s.update(TEST1.getBytes(StandardCharsets.UTF_8));
+ s.update(TEST1.getBytes(UTF_8));
ObjectId s1 = ObjectId.fromRaw(s.digest());
s.reset();
- s.update(TEST1.getBytes(StandardCharsets.UTF_8));
+ s.update(TEST1.getBytes(UTF_8));
ObjectId s2 = s.toObjectId();
assertEquals(m1, s1);
.fromString("84983e441c3bd26ebaae4aa1f95129e5e54670f1");
MessageDigest m = MessageDigest.getInstance("SHA-1");
- m.update(TEST2.getBytes(StandardCharsets.UTF_8));
+ m.update(TEST2.getBytes(UTF_8));
ObjectId m1 = ObjectId.fromRaw(m.digest());
SHA1 s = SHA1.newInstance();
- s.update(TEST2.getBytes(StandardCharsets.UTF_8));
+ s.update(TEST2.getBytes(UTF_8));
ObjectId s1 = ObjectId.fromRaw(s.digest());
s.reset();
- s.update(TEST2.getBytes(StandardCharsets.UTF_8));
+ s.update(TEST2.getBytes(UTF_8));
ObjectId s2 = s.toObjectId();
assertEquals(m1, s1);
package org.eclipse.jgit.transport;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
try {
final Mac m = Mac.getInstance(HMAC);
m.init(privateKey);
- sec = Base64.encodeBytes(m.doFinal(s.toString().getBytes("UTF-8"))); //$NON-NLS-1$
+ sec = Base64.encodeBytes(m.doFinal(s.toString().getBytes(UTF_8)));
} 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 java.io.File;
-import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
*/
public HMACSHA1NonceGenerator(String seed) throws IllegalStateException {
try {
- byte[] keyBytes = seed.getBytes("ISO-8859-1"); //$NON-NLS-1$
+ byte[] keyBytes = seed.getBytes(ISO_8859_1);
SecretKeySpec signingKey = new SecretKeySpec(keyBytes, "HmacSHA1"); //$NON-NLS-1$
mac = Mac.getInstance("HmacSHA1"); //$NON-NLS-1$
mac.init(signingKey);
throw new IllegalStateException(e);
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException(e);
- } catch (UnsupportedEncodingException e) {
- throw new IllegalStateException(e);
}
}
}
String input = path + ":" + String.valueOf(timestamp); //$NON-NLS-1$
- byte[] rawHmac;
- try {
- rawHmac = mac.doFinal(input.getBytes("UTF-8")); //$NON-NLS-1$
- } catch (UnsupportedEncodingException e) {
- throw new IllegalStateException(e);
- }
+ byte[] rawHmac = mac.doFinal(input.getBytes(UTF_8));
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.util.HttpSupport.HDR_AUTHORIZATION;
import static org.eclipse.jgit.util.HttpSupport.HDR_WWW_AUTHENTICATE;
import java.io.IOException;
-import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
@Override
void configureRequest(final HttpConnection conn) throws IOException {
String ident = user + ":" + pass; //$NON-NLS-1$
- String enc = Base64.encodeBytes(ident.getBytes("UTF-8")); //$NON-NLS-1$
+ String enc = Base64.encodeBytes(ident.getBytes(UTF_8));
conn.setRequestProperty(HDR_AUTHORIZATION, type.getSchemeName()
+ " " + enc); //$NON-NLS-1$
}
}
private static String H(String data) {
- try {
- MessageDigest md = newMD5();
- md.update(data.getBytes("UTF-8")); //$NON-NLS-1$
- return LHEX(md.digest());
- } catch (UnsupportedEncodingException e) {
- throw new RuntimeException("UTF-8 encoding not available", e); //$NON-NLS-1$
- }
+ MessageDigest md = newMD5();
+ md.update(data.getBytes(UTF_8));
+ return LHEX(md.digest());
}
private static String KD(String secret, String data) {
- try {
- MessageDigest md = newMD5();
- md.update(secret.getBytes("UTF-8")); //$NON-NLS-1$
- md.update((byte) ':');
- md.update(data.getBytes("UTF-8")); //$NON-NLS-1$
- return LHEX(md.digest());
- } catch (UnsupportedEncodingException e) {
- throw new RuntimeException("UTF-8 encoding not available", e); //$NON-NLS-1$
- }
+ MessageDigest md = newMD5();
+ md.update(secret.getBytes(UTF_8));
+ md.update((byte) ':');
+ md.update(data.getBytes(UTF_8));
+ return LHEX(md.digest());
}
private static MessageDigest newMD5() {
package org.eclipse.jgit.util;
-import java.io.UnsupportedEncodingException;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
import java.nio.charset.StandardCharsets;
import java.text.MessageFormat;
import java.util.Arrays;
/** Indicates an invalid byte during decoding. */
private final static byte INVALID_DEC = -3;
- /** Preferred encoding. */
- private final static String UTF_8 = "UTF-8"; //$NON-NLS-1$
-
/** The 64 valid Base64 values. */
private final static byte[] ENC;
private final static byte[] DEC;
static {
- try {
- ENC = ("ABCDEFGHIJKLMNOPQRSTUVWXYZ" // //$NON-NLS-1$
- + "abcdefghijklmnopqrstuvwxyz" // //$NON-NLS-1$
- + "0123456789" // //$NON-NLS-1$
- + "+/" // //$NON-NLS-1$
- ).getBytes(UTF_8);
- } catch (UnsupportedEncodingException uee) {
- throw new RuntimeException(uee.getMessage(), uee);
- }
+ ENC = ("ABCDEFGHIJKLMNOPQRSTUVWXYZ" // //$NON-NLS-1$
+ + "abcdefghijklmnopqrstuvwxyz" // //$NON-NLS-1$
+ + "0123456789" // //$NON-NLS-1$
+ + "+/" // //$NON-NLS-1$
+ ).getBytes(UTF_8);
DEC = new byte[128];
Arrays.fill(DEC, INVALID_DEC);
* @return the decoded data
*/
public static byte[] decode(String s) {
- byte[] bytes = s.getBytes(StandardCharsets.UTF_8);
+ byte[] bytes = s.getBytes(UTF_8);
return decode(bytes, 0, bytes.length);
}
}
projects / jgit.git / commitdiff