throw new ServiceNotAuthorizedException();
}
- private ReceivePack createFor(final HttpServletRequest req,
+ private static ReceivePack createFor(final HttpServletRequest req,
final Repository db, final String user) {
final ReceivePack rp = new ReceivePack(db);
rp.setRefLogIdent(toPersonIdent(req, user));
assertUnreasonable("C:/windows");
}
- private void assertUnreasonable(String name)
+ private static void assertUnreasonable(String name)
throws ServiceNotEnabledException {
FileResolver<RepositoryResolver> r = new FileResolver<RepositoryResolver>(
new File("."), false);
}
}
- private void packHeader(ByteArrayOutputStream tinyPack, int cnt)
+ private static void packHeader(ByteArrayOutputStream tinyPack, int cnt)
throws IOException {
final byte[] hdr = new byte[8];
NB.encodeInt32(hdr, 0, 2);
}
}
- private BufferedReader reader(HttpURLConnection conn)
+ private static BufferedReader reader(HttpURLConnection conn)
throws UnsupportedEncodingException, IOException {
String encoding = conn.getContentEncoding();
InputStream in = conn.getInputStream();
}
}
- private String readFully(HttpURLConnection c) throws IOException {
+ private static String readFully(HttpURLConnection c) throws IOException {
String enc = c.getContentEncoding();
Reader reader;
if (enc != null) {
return c;
}
- private void setCookie(URL url, String name, String value)
+ private static void setCookie(URL url, String name, String value)
throws IOException {
Map<String, List<String>> cols = new HashMap<String, List<String>>();
cols.put("Set-Cookie", Collections.singletonList(name + "=" + value));
}
}
- private CQ parseOneCQ(Map<String, String> row) {
+ private static CQ parseOneCQ(Map<String, String> row) {
long id = Long.parseLong(row.get("bug_id"));
String state = row.get("bug_severity");
String bug_status = row.get("bug_status");
}
}
- private Date parseDate(SimpleDateFormat dt, String value)
+ private static Date parseDate(SimpleDateFormat dt, String value)
throws IOException {
if ("NULL".equals(value) || "".equals(value) || value == null)
return null;
return project;
}
- private void populateProjectType(Project p, Element project) {
+ private static void populateProjectType(Project p, Element project) {
required(project, "id", p.getID());
required(project, "name", p.getName());
optional(project, "comments", p.getComments());
return r;
}
- private String mapCQState(String state) {
+ private static String mapCQState(String state) {
// "approved" CQs shall be listed as "active" in the iplog
if (state.equals("approved"))
return "active";
return doc.createElementNS(IPLOG_NS, IPLOG_PFX + name);
}
- private void required(Element r, String name, String value) {
+ private static void required(Element r, String name, String value) {
if (value == null)
value = "";
r.setAttribute(name, value);
}
- private void optional(Element r, String name, String value) {
+ private static void optional(Element r, String name, String value) {
if (value != null && value.length() > 0)
r.setAttribute(name, value);
}
reviewUrl = cfg.getString(S_REVIEW, null, K_URL);
}
- private List<Project> parseProjects(final Config cfg,
+ private
static List<Project> parseProjects(final Config cfg,
final String sectionName) {
final List<Project> dst = new ArrayList<Project>();
for (String id : cfg.getSubsections(sectionName)) {
}
}
- private String hostOf(URI uri) {
+ private static String hostOf(URI uri) {
StringBuilder key = new StringBuilder();
key.append(uri.getScheme());
key.append(':');
mockSystemReader.setProperty(Constants.GIT_CEILING_DIRECTORIES_KEY, makePath(ceilings));
}
- private String makePath(List<?> objects) {
+ private static String makePath(List<?> objects) {
final StringBuilder stringBuilder = new StringBuilder();
for (Object object : objects) {
if (stringBuilder.length() > 0)
toClose.add(r);
}
- private String createUniqueTestFolderPrefix() {
+ private static String createUniqueTestFolderPrefix() {
return "test" + (System.currentTimeMillis() + "_" + (testCount++));
}
}
}
- private void prunePacked(ObjectDirectory odb) throws IOException {
+ private static void prunePacked(ObjectDirectory odb) throws IOException {
for (PackFile p : odb.getPacks()) {
for (MutableEntry e : p)
FileUtils.delete(odb.fileFor(e.toObjectId()));
writer.flush();
}
- private String longTypeOf(ObjectReader reader, final TrackingRefUpdate u) {
+ private static String longTypeOf(ObjectReader reader,
+ final TrackingRefUpdate u) {
final RefUpdate.Result r = u.getResult();
if (r == RefUpdate.Result.LOCK_FAILURE)
return "[lock fail]";
return "[" + r.name() + "]"; //$NON-NLS-1$//$NON-NLS-2$
}
- private String safeAbbreviate(ObjectReader reader, ObjectId id) {
+ private static String safeAbbreviate(ObjectReader reader, ObjectId id) {
try {
return reader.abbreviate(id).name();
} catch (IOException cannotAbbreviate) {
return r;
}
- private Ref guessHEAD(final FetchResult result) {
+ private static Ref guessHEAD(final FetchResult result) {
final Ref idHEAD = result.getAdvertisedRef(Constants.HEAD);
final List<Ref> availableRefs = new ArrayList<Ref>();
Ref head = null;
}
return commit;
}
-}
\ No newline at end of file
+}
outw.println(MessageFormat.format(CLIText.get().listeningOn, d.getAddress()));
}
- private DaemonService service(final org.eclipse.jgit.transport.Daemon d,
+ private static DaemonService service(
+ final org.eclipse.jgit.transport.Daemon d,
final String n) {
final DaemonService svc = d.getService(n);
if (svc == null)
}
}
- private String safeAbbreviate(ObjectReader reader, ObjectId id) {
+ private static String safeAbbreviate(ObjectReader reader, ObjectId id) {
try {
return reader.abbreviate(id).name();
} catch (IOException cannotAbbreviate) {
outw.println(BinaryDelta.format(delta));
}
- private byte[] getDelta(ObjectReader reader, RevObject obj)
+ private static byte[] getDelta(ObjectReader reader, RevObject obj)
throws IOException, MissingObjectException,
StoredObjectRepresentationNotAvailableException {
ObjectReuseAsIs asis = (ObjectReuseAsIs) reader;
outw.flush();
}
- private void testOne(Function fun, RawText txt, int[] elements, int cnt) {
+ private static void testOne(Function fun, RawText txt, int[] elements,
+ int cnt) {
final Hash cmp = fun.hash;
final Fold fold = fun.fold;
assertEquals(FileMode.EXECUTABLE_FILE, walk.getFileMode(0));
}
- private DirCacheEntry addEntryToBuilder(String path, File file,
+ private static DirCacheEntry addEntryToBuilder(String path, File file,
ObjectInserter newObjectInserter, DirCacheBuilder builder, int stage)
throws IOException {
FileInputStream inputStream = new FileInputStream(file);
b.getString(0, b.size(), false));
}
- private byte[] readFile(final String patchFile) throws IOException {
+ private static byte[] readFile(final String patchFile) throws IOException {
final InputStream in = DiffFormatterReflowTest.class
.getResourceAsStream(patchFile);
if (in == null) {
*/
public class BlameCommandTest extends RepositoryTestCase {
- private String join(String... lines) {
+ private static String join(String... lines) {
StringBuilder joined = new StringBuilder();
for (String line : lines)
joined.append(line).append('\n');
}
}
- private String expected_f3_head(final int state) {
+ private static String expected_f3_head(final int state) {
switch (state) {
case 0:
case 1:
return null;
}
- private String expected_f3_idx(final int state) {
+ private static String expected_f3_idx(final int state) {
switch (state) {
case 0:
case 3:
return null;
}
- private String getHead(final Git git, final String path) throws Exception {
+ static private String getHead(final Git git, final String path)
+ throws Exception {
try {
final Repository repo = git.getRepository();
final ObjectId headId = repo.resolve(Constants.HEAD + "^{commit}");
assertEquals(0, status.getUntracked().size());
}
- private void assertCollectionEquals(Collection<?> asList,
+ private static void assertCollectionEquals(Collection<?> asList,
Collection<?> added) {
assertEquals(asList.toString(), added.toString());
}
assertEquals(StatusCommandTest.set("file2"), stat.getConflicting());
}
- private void setExecutable(Git git, String path, boolean executable) {
+ private static void setExecutable(Git git, String path, boolean executable) {
FS.DETECTED.setExecute(
new File(git.getRepository().getWorkTree(), path), executable);
}
- private boolean canExecute(Git git, String path) {
+ private static boolean canExecute(Git git, String path) {
return FS.DETECTED.canExecute(new File(git.getRepository()
.getWorkTree(), path));
}
- private RevCommit addAllAndCommit(final Git git) throws Exception {
+ private static RevCommit addAllAndCommit(final Git git) throws Exception {
git.add().addFilepattern(".").call();
return git.commit().setMessage("message").call();
}
assertFileContentsEqual(targetFile, "Hello world");
}
- private void writeToFile(File actFile, String string) throws IOException {
+ private static void writeToFile(File actFile, String string)
+ throws IOException {
FileOutputStream fos = null;
try {
fos = new FileOutputStream(actFile);
}
}
- private void assertFileContentsEqual(File actFile, String string)
+ private static void assertFileContentsEqual(File actFile, String string)
throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
FileInputStream fis = null;
assertFileContentsEqual(targetFile, "Hello world");
}
- private void writeToFile(File actFile, String string) throws IOException {
+ private static void writeToFile(File actFile, String string)
+ throws IOException {
FileOutputStream fos = null;
try {
fos = new FileOutputStream(actFile);
}
}
- private void assertFileContentsEqual(File actFile, String string)
+ private static void assertFileContentsEqual(File actFile, String string)
throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
FileInputStream fis = null;
assertEquals(expected.toString(), actual);
}
- private String makeDiffHeader(String pathA, String pathB, ObjectId aId,
+ private static String makeDiffHeader(String pathA, String pathB,
+ ObjectId aId,
ObjectId bId) {
String a = aId.abbreviate(8).name();
String b = bId.abbreviate(8).name();
"+++ b/" + pathB + "\n";
}
- private String makeDiffHeaderModeChange(String pathA, String pathB,
+ private static String makeDiffHeaderModeChange(String pathA, String pathB,
ObjectId aId, ObjectId bId, String modeA, String modeB) {
String a = aId.abbreviate(8).name();
String b = bId.abbreviate(8).name();
assertEquals(intentToAdd, entry.isIntentToAdd());
}
- private File pathOf(final String name) {
+ private static File pathOf(final String name) {
return JGitTestUtil.getTestResourceFile(name);
}
- private Map<String, CGitIndexRecord> readLsFiles() throws Exception {
+ private static Map<String, CGitIndexRecord> readLsFiles() throws Exception {
final LinkedHashMap<String, CGitIndexRecord> r = new LinkedHashMap<String, CGitIndexRecord>();
final BufferedReader br = new BufferedReader(new InputStreamReader(
new FileInputStream(pathOf("gitgit.lsfiles")), "UTF-8"));
return r;
}
- private Map<String, CGitLsTreeRecord> readLsTree() throws Exception {
+ private static Map<String, CGitLsTreeRecord> readLsTree() throws Exception {
final LinkedHashMap<String, CGitLsTreeRecord> r = new LinkedHashMap<String, CGitLsTreeRecord>();
final BufferedReader br = new BufferedReader(new InputStreamReader(
new FileInputStream(pathOf("gitgit.lstree")), "UTF-8"));
copyMetaDataHelper(true);
}
- private void copyMetaDataHelper(final boolean keepStage) {
+ private static void copyMetaDataHelper(final boolean keepStage) {
DirCacheEntry e = new DirCacheEntry("some/path", DirCacheEntry.STAGE_2);
e.setAssumeValid(false);
e.setCreationTime(2L);
public class FileNameMatcherTest {
- private void assertMatch(final String pattern, final String input,
+ private static void assertMatch(final String pattern, final String input,
final boolean matchExpected, final boolean appendCanMatchExpected)
throws InvalidPatternException {
final FileNameMatcher matcher = new FileNameMatcher(pattern, null);
assertEquals(appendCanMatchExpected, matcher.canAppendMatch());
}
- private void assertFileNameMatch(final String pattern, final String input,
+ private static void assertFileNameMatch(final String pattern,
+ final String input,
final char excludedCharacter, final boolean matchExpected,
final boolean appendCanMatchExpected)
throws InvalidPatternException {
* @return
* Result of {@link IgnoreRule#isMatch(String, boolean)}
*/
- private boolean match(String pattern, String target) {
+ private static boolean match(String pattern, String target) {
IgnoreRule r = new IgnoreRule(pattern);
//If speed of this test is ever an issue, we can use a presetRule field
//to avoid recompiling a pattern each time.
branchConfig.getTrackingBranch());
}
- private Config parse(final String content) {
+ private static Config parse(final String content) {
final Config c = new Config(null);
try {
c.fromText(content);
assertEquals(result, config.toText());
}
- private void assertReadLong(long exp) throws ConfigInvalidException {
+ private static void assertReadLong(long exp) throws ConfigInvalidException {
assertReadLong(exp, String.valueOf(exp));
}
- private void assertReadLong(long exp, String act)
+ private static void assertReadLong(long exp, String act)
throws ConfigInvalidException {
final Config c = parse("[s]\na = " + act + "\n");
assertEquals(exp, c.getLong("s", null, "a", 0L));
}
- private Config parse(final String content) throws ConfigInvalidException {
+ private static Config parse(final String content)
+ throws ConfigInvalidException {
final Config c = new Config(null);
c.fromText(content);
return c;
private static final ObjectId SOME_FAKE_ID = ObjectId.fromString(
"0123456789abcdef0123456789abcdef01234567");
- private int compareNamesUsingSpecialCompare(String a,String b) throws UnsupportedEncodingException {
+ private static int compareNamesUsingSpecialCompare(String a, String b)
+ throws UnsupportedEncodingException {
char lasta = '\0';
byte[] abytes;
if (a.length() > 0 && a.charAt(a.length()-1) == '/') {
assertFalse(tw.next());
}
- private void assertCorrectId(final DirCache treeT, final TreeWalk tw) {
+ private static void assertCorrectId(final DirCache treeT, final TreeWalk tw) {
assertEquals(treeT.getEntry(tw.getPathString()).getObjectId(), tw
.getObjectId(0));
}
- private ObjectId commit(final ObjectInserter odi, final DirCache treeB,
+ private static ObjectId commit(final ObjectInserter odi,
+ final DirCache treeB,
final ObjectId[] parentIds) throws Exception {
final CommitBuilder c = new CommitBuilder();
c.setTreeId(treeB.writeTree(odi));
assertFalse(merge);
}
- private void assertCorrectId(final DirCache treeT, final TreeWalk tw) {
+ private static void assertCorrectId(final DirCache treeT, final TreeWalk tw) {
assertEquals(treeT.getEntry(tw.getPathString()).getObjectId(), tw
.getObjectId(0));
}
- private ObjectId commit(final ObjectInserter odi, final DirCache treeB,
+ private static ObjectId commit(final ObjectInserter odi,
+ final DirCache treeB,
final ObjectId[] parentIds) throws Exception {
final CommitBuilder c = new CommitBuilder();
c.setTreeId(treeB.writeTree(odi));
FileUtils.delete(trash, FileUtils.RECURSIVE | FileUtils.SKIP_MISSING);
}
- private void waitNextSec(File f) {
+ private static void waitNextSec(File f) {
long initialLastModified = f.lastModified();
do {
f.setLastModified(System.currentTimeMillis());
return f;
}
- private void append(File f, byte b) throws IOException {
+ private static void append(File f, byte b) throws IOException {
FileOutputStream os = new FileOutputStream(f, true);
try {
os.write(b);
in.close();
}
- private byte[] clone(int first, byte[] base) {
+ private static byte[] clone(int first, byte[] base) {
byte[] r = new byte[base.length];
System.arraycopy(base, 1, r, 1, r.length - 1);
r[0] = (byte) first;
return r;
}
- private byte[] delta(byte[] base, byte[] dest) throws IOException {
+ private static byte[] delta(byte[] base, byte[] dest) throws IOException {
ByteArrayOutputStream tmp = new ByteArrayOutputStream();
DeltaEncoder de = new DeltaEncoder(tmp, base.length, dest.length);
de.insert(dest, 0, 1);
return tmp.toByteArray();
}
- private void packHeader(TemporaryBuffer.Heap pack, int cnt)
+ private static void packHeader(TemporaryBuffer.Heap pack, int cnt)
throws IOException {
final byte[] hdr = new byte[8];
NB.encodeInt32(hdr, 0, 2);
pack.write(hdr, 0, 8);
}
- private void objectHeader(TemporaryBuffer.Heap pack, int type, int sz)
+ private static void objectHeader(TemporaryBuffer.Heap pack, int type, int sz)
throws IOException {
byte[] buf = new byte[8];
int nextLength = sz >>> 4;
pack.write(buf, 0, n);
}
- private void deflate(TemporaryBuffer.Heap pack, final byte[] content)
+ private static void deflate(TemporaryBuffer.Heap pack, final byte[] content)
throws IOException {
final Deflater deflater = new Deflater();
final byte[] buf = new byte[128];
deflater.end();
}
- private void digest(TemporaryBuffer.Heap buf) throws IOException {
+ private static void digest(TemporaryBuffer.Heap buf) throws IOException {
MessageDigest md = Constants.newMessageDigest();
md.update(buf.toByteArray());
buf.write(md.digest());
contentB.getId()));
}
- private void assertContent(PackIndex pi, List<ObjectId> expected) {
+ private static void assertContent(PackIndex pi, List<ObjectId> expected) {
assertEquals("Pack index has wrong size.", expected.size(),
pi.getObjectCount());
for (int i = 0; i < pi.getObjectCount(); i++)
expected.contains(pi.getObjectId(i)));
}
- private PackIndex writePack(FileRepository repo,
+ private static PackIndex writePack(FileRepository repo,
Set<? extends ObjectId> want, Set<PackIndex> excludeObjects)
throws IOException {
PackWriter pw = new PackWriter(repo);
"HEAD").getReverseEntries().get(0).getComment());
}
- private void writeReflog(Repository db, ObjectId newId, String msg,
+ private static void writeReflog(Repository db, ObjectId newId, String msg,
String refName) throws IOException {
RefDirectory refs = (RefDirectory) db.getRefDatabase();
RefDirectoryUpdate update = refs.newUpdate(refName, true);
e.getComment());
}
- private String iso(PersonIdent id) {
+ private static String iso(PersonIdent id) {
final SimpleDateFormat fmt;
fmt = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
fmt.setTimeZone(id.getTimeZone());
}
}
- private File getFile(String... pathComponents) throws IOException {
+ private static File getFile(String... pathComponents) throws IOException {
String rootPath = new File(new File("target"), "trash").getPath();
for (String pathComponent : pathComponents)
rootPath = rootPath + File.separatorChar + pathComponent;
return result;
}
- private void setBare(File gitDir, boolean bare) throws IOException,
+ private static void setBare(File gitDir, boolean bare) throws IOException,
ConfigInvalidException {
FileBasedConfig cfg = configFor(gitDir);
cfg.setBoolean(ConfigConstants.CONFIG_CORE_SECTION, null,
cfg.save();
}
- private void setWorkTree(File gitDir, File workTree) throws IOException,
+ private static void setWorkTree(File gitDir, File workTree)
+ throws IOException,
ConfigInvalidException {
String path = workTree.getAbsolutePath();
FileBasedConfig cfg = configFor(gitDir);
cfg.save();
}
- private FileBasedConfig configFor(File gitDir) throws IOException,
+ private static FileBasedConfig configFor(File gitDir) throws IOException,
ConfigInvalidException {
File configPath = new File(gitDir, Constants.CONFIG);
FileBasedConfig cfg = new FileBasedConfig(configPath, FS.DETECTED);
return cfg;
}
- private void assertGitdirPath(Repository repo, String... expected)
+ private static void assertGitdirPath(Repository repo, String... expected)
throws IOException {
File exp = getFile(expected).getCanonicalFile();
File act = repo.getDirectory().getCanonicalFile();
assertEquals("Wrong Git Directory", exp, act);
}
- private void assertWorkdirPath(Repository repo, String... expected)
+ private static void assertWorkdirPath(Repository repo, String... expected)
throws IOException {
File exp = getFile(expected).getCanonicalFile();
File act = repo.getWorkTree().getCanonicalFile();
}
}
- private byte[] compressStandardFormat(int type, byte[] data)
+ private static byte[] compressStandardFormat(int type, byte[] data)
throws IOException {
String typeString = Constants.typeString(type);
String length = String.valueOf(data.length);
return compressStandardFormat(typeString, length, data);
}
- private byte[] compressStandardFormat(String type, String length,
+ private static byte[] compressStandardFormat(String type, String length,
byte[] data) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
DeflaterOutputStream d = new DeflaterOutputStream(out);
return out.toByteArray();
}
- private byte[] compressPackFormat(int type, byte[] data) throws IOException {
+ private static byte[] compressPackFormat(int type, byte[] data)
+ throws IOException {
byte[] hdr = new byte[64];
int rawLength = data.length;
int nextLength = rawLength >>> 4;
checkLimits(cfg);
}
- private void checkLimits(final WindowCacheConfig cfg) {
+ private static void checkLimits(final WindowCacheConfig cfg) {
final WindowCache cache = WindowCache.getInstance();
assertTrue(cache.getOpenFiles() <= cfg.getPackedGitOpenFiles());
assertTrue(cache.getOpenBytes() <= cfg.getPackedGitLimit());
}
}
- private FetchResult fetchFromBundle(final Repository newRepo,
+ private static FetchResult fetchFromBundle(final Repository newRepo,
final byte[] bundle) throws URISyntaxException,
NotSupportedException, TransportException {
final URIish uri = new URIish("in-memory://");
assertEquals(0x7e, in.read());
}
- private void packHeader(TemporaryBuffer.Heap tinyPack, int cnt)
+ private static void packHeader(TemporaryBuffer.Heap tinyPack, int cnt)
throws IOException {
final byte[] hdr = new byte[8];
NB.encodeInt32(hdr, 0, 2);
tinyPack.write(hdr, 0, 8);
}
- private void deflate(TemporaryBuffer.Heap tinyPack, final byte[] content)
+ private static void deflate(TemporaryBuffer.Heap tinyPack,
+ final byte[] content)
throws IOException {
final Deflater deflater = new Deflater();
final byte[] buf = new byte[128];
} while (!deflater.finished());
}
- private void digest(TemporaryBuffer.Heap buf) throws IOException {
+ private static void digest(TemporaryBuffer.Heap buf) throws IOException {
MessageDigest md = Constants.newMessageDigest();
md.update(buf.toByteArray());
buf.write(md.digest());
assertSame(PacketLineIn.END, r.readString());
}
- private void receive(final ReceivePack rp,
+ private static void receive(final ReceivePack rp,
final TemporaryBuffer.Heap inBuf, final TemporaryBuffer.Heap outBuf)
throws IOException {
rp.receive(new ByteArrayInputStream(inBuf.toByteArray()), outBuf, null);
assertSame(PacketLineIn.END, r.readString());
}
- private void packHeader(TemporaryBuffer.Heap tinyPack, int cnt)
+ private static void packHeader(TemporaryBuffer.Heap tinyPack, int cnt)
throws IOException {
final byte[] hdr = new byte[8];
NB.encodeInt32(hdr, 0, 2);
tinyPack.write(hdr, 0, 8);
}
- private void copy(TemporaryBuffer.Heap tinyPack, ObjectLoader ldr)
+ private static void copy(TemporaryBuffer.Heap tinyPack, ObjectLoader ldr)
throws IOException {
final byte[] buf = new byte[64];
final byte[] content = ldr.getCachedBytes();
deflate(tinyPack, content);
}
- private void deflate(TemporaryBuffer.Heap tinyPack, final byte[] content)
+ private static void deflate(TemporaryBuffer.Heap tinyPack,
+ final byte[] content)
throws IOException {
final Deflater deflater = new Deflater();
final byte[] buf = new byte[128];
} while (!deflater.finished());
}
- private void digest(TemporaryBuffer.Heap buf) throws IOException {
+ private static void digest(TemporaryBuffer.Heap buf) throws IOException {
MessageDigest md = Constants.newMessageDigest();
md.update(buf.toByteArray());
buf.write(md.digest());
assertFalse(tw.next());
}
- private void assertEntry(String sha1string, String path, TreeWalk tw)
+ private static void assertEntry(String sha1string, String path, TreeWalk tw)
throws MissingObjectException, IncorrectObjectTypeException,
CorruptObjectException, IOException {
assertTrue(tw.next());
import org.eclipse.jgit.treewalk.filter.TreeFilter;
import org.junit.Test;
+@SuppressWarnings("deprecation")
public class TreeWalkBasicDiffTest extends RepositoryTestCase {
@Test
public void testMissingSubtree_DetectFileAdded_FileModified()
return treeWalk;
}
- private void assertPaths(TreeWalk treeWalk, String... paths)
+ private static void assertPaths(TreeWalk treeWalk, String... paths)
throws Exception {
for (int i = 0; i < paths.length; i++) {
assertTrue(treeWalk.next());
assertFalse(treeWalk.next());
}
- private void assertPath(String path, String... paths) {
+ private static void assertPath(String path, String... paths) {
for (String p : paths)
if (p.equals(path))
return;
}
}
- private String octalEscape(int i) {
+ private static String octalEscape(int i) {
String s = Integer.toOctalString(i);
while (s.length() < 3) {
s = "0" + s;
assertPersonIdent("Me <me@example.com 1234567890 -0700", null);
}
- private void assertPersonIdent(String line, PersonIdent expected) {
+ private static void assertPersonIdent(String line, PersonIdent expected) {
PersonIdent actual = RawParseUtils.parsePersonIdent(line);
assertEquals(expected, actual);
}
assertSame(REF_B, two.get(0));
}
- private RefList<Ref> toList(Ref... refs) {
+ private static RefList<Ref> toList(Ref... refs) {
RefList.Builder<Ref> b = new RefList.Builder<Ref>(refs.length);
b.addAll(refs, 0, refs.length);
return b.toRefList();
assertEquals(1, map.size());
}
- private RefList<Ref> toList(Ref... refs) {
+ private static RefList<Ref> toList(Ref... refs) {
RefList.Builder<Ref> b = new RefList.Builder<Ref>(refs.length);
b.addAll(refs, 0, refs.length);
return b.toRefList();
SystemReader.setInstance(new MockSystemReader());
}
- private void assertFormat(long ageFromNow, long timeUnit,
+ private static void assertFormat(long ageFromNow, long timeUnit,
String expectedFormat) {
Date d = new Date(SystemReader.getInstance().getCurrentTime()
- ageFromNow * timeUnit);
test(asBytes("1\r\n2\r\n3\0"), asBytes("1\n2\n3\0"), false);
}
- private void test(byte[] input, byte[] expected, boolean detectBinary) throws IOException {
+ private static void test(byte[] input, byte[] expected,
+ boolean detectBinary) throws IOException {
final InputStream bis1 = new ByteArrayInputStream(input);
final InputStream cis1 = new EolCanonicalizingInputStream(bis1, detectBinary);
int index1 = 0;
}
}
- private boolean interactive(URIish uri, CredentialItem[] items) {
+ private static boolean interactive(URIish uri, CredentialItem[] items) {
final GridBagConstraints gbc = new GridBagConstraints(0, 0, 1, 1, 1, 1,
GridBagConstraints.NORTHWEST, GridBagConstraints.NONE,
new Insets(0, 0, 0, 0), 0, 0);
projects / jgit.git / commitdiff