Suppress boxing warnings where we know they are ok

Invoke the wrapper types' valueOf via static imports.
For booleans used in asserts, add a new assert in
the JUnit utility package since out current version of JUnit
does not have the assert(boolean, boolean) method.

Change-Id: I9099bd8efbc8c133479344d51ce7dabed8958a2b

org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/glue/RegexGroupFilter.java

 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 
+import static java.lang.Integer.valueOf;
+
 import org.eclipse.jgit.http.server.HttpServerText;
 
 /**
 	 */
 	public RegexGroupFilter(final int groupIdx) {
 		if (groupIdx < 1)
-			throw new IllegalArgumentException(MessageFormat.format(HttpServerText.get().invalidIndex, groupIdx));
+			throw new IllegalArgumentException(MessageFormat.format(
+					HttpServerText.get().invalidIndex, valueOf(groupIdx)));
 		this.groupIdx = groupIdx - 1;
 	}
 
 		if (groupIdx < g.length)
 			chain.doFilter(g[groupIdx], rsp);
 		else
-			throw new ServletException(MessageFormat.format(HttpServerText.get().invalidRegexGroup, (groupIdx + 1)));
+			throw new ServletException(MessageFormat.format(
+					HttpServerText.get().invalidRegexGroup,
+					valueOf(groupIdx + 1)));
 	}
 
 	private static WrappedRequest[] groupsFor(final ServletRequest r) {

org.eclipse.jgit.iplog/src/org/eclipse/jgit/iplog/CQ.java

 
 package org.eclipse.jgit.iplog;
 
+import static java.lang.Long.valueOf;
+
 import java.text.MessageFormat;
 import java.util.Comparator;
 
 
 	@Override
 	public String toString() {
-		return MessageFormat.format(IpLogText.get().CQString, getID());
+		return MessageFormat.format(IpLogText.get().CQString, valueOf(getID()));
 	}
 }

org.eclipse.jgit.junit/src/org/eclipse/jgit/junit/Assert.java

+/*
+ * Copyright (C) 2012, Robin Rosenberg
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ *   copyright notice, this list of conditions and the following
+ *   disclaimer in the documentation and/or other materials provided
+ *   with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ *   names of its contributors may be used to endorse or promote
+ *   products derived from this software without specific prior
+ *   written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.junit;
+
+import static java.lang.Boolean.valueOf;
+
+public class Assert {
+
+	public static void assertEquals(boolean expect, boolean actual) {
+		org.junit.Assert.assertEquals(valueOf(expect), valueOf(actual));
+	}
+
+	public static void assertEquals(String message, boolean expect,
+			boolean actual) {
+		org.junit.Assert
+				.assertEquals(message, valueOf(expect), valueOf(actual));
+	}
+}

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/AbstractFetchCommand.java

 
 package org.eclipse.jgit.pgm;
 
+import static java.lang.Character.valueOf;
+
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.text.MessageFormat;
 					shownURI = true;
 				}
 
-				outw.format(" %c %-17s %-10s -> %s", type, longType, src, dst);
+				outw.format(" %c %-17s %-10s -> %s", valueOf(type), longType,
+						src, dst);
 				outw.println();
 			}
 		} finally {

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/AmazonS3Client.java

 
 package org.eclipse.jgit.pgm;
 
+import static java.lang.Integer.valueOf;
+
 import java.io.EOFException;
 import java.io.File;
 import java.io.FileInputStream;
 				while (len > 0) {
 					final int n = in.read(tmp);
 					if (n < 0)
-						throw new EOFException(MessageFormat.format(CLIText.get().expectedNumberOfbytes, len));
+						throw new EOFException(MessageFormat.format(
+								CLIText.get().expectedNumberOfbytes,
+								valueOf(len)));
 					outs.write(tmp, 0, n);
 					len -= n;
 				}

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/Blame.java

 
 package org.eclipse.jgit.pgm;
 
+import static java.lang.Integer.valueOf;
+import static java.lang.Long.valueOf;
 import static org.eclipse.jgit.lib.Constants.OBJECT_ID_STRING_LENGTH;
 
 import java.io.File;
 				maxSourceLine = Math.max(maxSourceLine, blame.getSourceLine(line));
 			}
 
-			String pathFmt = MessageFormat.format(" %{0}s", pathWidth);
+			String pathFmt = MessageFormat.format(" %{0}s", valueOf(pathWidth));
 			String numFmt = MessageFormat.format(" %{0}d",
-					1 + (int) Math.log10(maxSourceLine + 1));
+					valueOf(1 + (int) Math.log10(maxSourceLine + 1)));
 			String lineFmt = MessageFormat.format(" %{0}d) ",
-					1 + (int) Math.log10(end + 1));
+					valueOf(1 + (int) Math.log10(end + 1)));
 			String authorFmt = MessageFormat.format(" (%-{0}s %{1}s",
-					authorWidth, dateWidth);
+					valueOf(authorWidth), valueOf(dateWidth));
 
 			for (int line = begin; line < end; line++) {
 				outw.print(abbreviate(blame.getSourceCommit(line)));
 				if (showSourcePath)
 					outw.format(pathFmt, path(line));
 				if (showSourceLine)
-					outw.format(numFmt, blame.getSourceLine(line) + 1);
+					outw.format(numFmt, valueOf(blame.getSourceLine(line) + 1));
 				if (!noAuthor)
 					outw.format(authorFmt, author(line), date(line));
-				outw.format(lineFmt, line + 1);
+				outw.format(lineFmt, valueOf(line + 1));
 				outw.flush();
 				blame.getResultContents().writeLine(outs, line);
 				outs.flush();
 		dateFmt.setTimeZone(author.getTimeZone());
 		if (!showRawTimestamp)
 			return dateFmt.format(author.getWhen());
-		return String.format("%d %s", author.getWhen().getTime() / 1000L,
+		return String.format("%d %s",
+				valueOf(author.getWhen().getTime() / 1000L),
 				dateFmt.format(author.getWhen()));
 	}
 

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/Diff.java

 
 package org.eclipse.jgit.pgm;
 
+import static java.lang.Integer.valueOf;
 import static org.eclipse.jgit.lib.Constants.HEAD;
 import static org.eclipse.jgit.lib.Constants.OBJECT_ID_STRING_LENGTH;
 
 				out.println("M\t" + ent.getNewPath());
 				break;
 			case COPY:
-				out.format("C%1$03d\t%2$s\t%3$s", ent.getScore(), //
+				out.format("C%1$03d\t%2$s\t%3$s", valueOf(ent.getScore()), //
 						ent.getOldPath(), ent.getNewPath());
 				out.println();
 				break;
 			case RENAME:
-				out.format("R%1$03d\t%2$s\t%3$s", ent.getScore(), //
+				out.format("R%1$03d\t%2$s\t%3$s", valueOf(ent.getScore()), //
 						ent.getOldPath(), ent.getNewPath());
 				out.println();
 				break;

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/Push.java

 
 package org.eclipse.jgit.pgm;
 
+import static java.lang.Character.valueOf;
+
 import java.io.IOException;
 import java.text.MessageFormat;
 import java.util.ArrayList;
 	private void printUpdateLine(final char flag, final String summary,
 			final String srcRef, final String destRef, final String message)
 			throws IOException {
-		outw.format(" %c %-17s", flag, summary);
+		out.format(" %c %-17s", valueOf(flag), summary);
 
 		if (srcRef != null)
 			outw.format(" %s ->", abbreviateRef(srcRef, true));

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/DiffAlgorithms.java

 
 package org.eclipse.jgit.pgm.debug;
 
+import static java.lang.Integer.valueOf;
+import static java.lang.Long.valueOf;
+
 import java.io.File;
 import java.lang.management.ManagementFactory;
 import java.lang.management.ThreadMXBean;
 			outw.println(name + ": start at " + startId.name());
 		}
 
-		outw.format("  %12d files,     %8d commits\n", files, commits);
-		outw.format("  N=%10d min lines, %8d max lines\n", minN, maxN);
+		outw.format("  %12d files,     %8d commits\n", valueOf(files),
+				valueOf(commits));
+		outw.format("  N=%10d min lines, %8d max lines\n", valueOf(minN),
+				valueOf(maxN));
 
 		outw.format("%-25s %12s ( %12s  %12s )\n", //
 				"Algorithm", "Time(ns)", "Time(ns) on", "Time(ns) on");
 		for (Test test : all) {
 			outw.format("%-25s %12d ( %12d  %12d )", //
 					test.algorithm.name, //
-					test.runningTimeNanos, //
-					test.minN.runningTimeNanos, //
-					test.maxN.runningTimeNanos);
+					valueOf(test.runningTimeNanos), //
+					valueOf(test.minN.runningTimeNanos), //
+					valueOf(test.maxN.runningTimeNanos));
 			outw.println();
 		}
 		outw.println();

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/MakeCacheTree.java

 
 package org.eclipse.jgit.pgm.debug;
 
+import static java.lang.Integer.valueOf;
+
 import java.io.IOException;
 import java.text.MessageFormat;
 
 	}
 
 	private void show(final DirCacheTree tree) throws IOException {
-		outw.println(MessageFormat.format(CLIText.get().cacheTreePathInfo
-				, tree.getPathString(), tree.getEntrySpan(), tree.getChildCount()));
+		outw.println(MessageFormat.format(CLIText.get().cacheTreePathInfo,
+				tree.getPathString(), valueOf(tree.getEntrySpan()),
+				valueOf(tree.getChildCount())));
 
 		for (int i = 0; i < tree.getChildCount(); i++)
 			show(tree.getChild(i));

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/ReadDirCache.java

 
 package org.eclipse.jgit.pgm.debug;
 
+import static java.lang.Long.valueOf;
+
 import java.text.MessageFormat;
 
 import org.eclipse.jgit.pgm.CLIText;
 			db.readDirCache();
 		final long end = System.currentTimeMillis();
 		outw.print(" ");
-		outw.println(MessageFormat.format(CLIText.get().averageMSPerRead, (end - start) / cnt));
+		outw.println(MessageFormat.format(CLIText.get().averageMSPerRead,
+				valueOf((end - start) / cnt)));
 	}
 }

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/ShowCacheTree.java

 
 package org.eclipse.jgit.pgm.debug;
 
+import static java.lang.Integer.valueOf;
+
 import java.io.IOException;
 import java.text.MessageFormat;
 
 	}
 
 	private void show(final DirCacheTree tree) throws IOException {
-		outw.println(MessageFormat.format(CLIText.get().cacheTreePathInfo
-				, tree.getPathString(), tree.getEntrySpan(), tree.getChildCount()));
+		outw.println(MessageFormat.format(CLIText.get().cacheTreePathInfo,
+				tree.getPathString(), valueOf(tree.getEntrySpan()),
+				valueOf(tree.getChildCount())));
 
 		for (int i = 0; i < tree.getChildCount(); i++)
 			show(tree.getChild(i));

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/ShowDirCache.java

 
 package org.eclipse.jgit.pgm.debug;
 
+import static java.lang.Integer.valueOf;
+
 import java.text.SimpleDateFormat;
 import java.util.Date;
 
 			final int stage = ent.getStage();
 
 			outw.print(mode);
-			outw.format(" %6d", len);
+			outw.format(" %6d", valueOf(len));
 			outw.print(' ');
 			outw.print(fmt.format(mtime));
 			outw.print(' ');

org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/debug/TextHashFunctions.java

 
 package org.eclipse.jgit.pgm.debug;
 
+import static java.lang.Integer.valueOf;
+import static java.lang.Long.valueOf;
+
 import java.io.File;
 import java.lang.reflect.Field;
 import java.security.MessageDigest;
 			outw.println(name + ":");
 		}
 		outw.format("  %6d files; %5d avg. unique lines/file\n", //
-				fileCnt, //
-				lineCnt / fileCnt);
+				valueOf(fileCnt), //
+				valueOf(lineCnt / fileCnt));
 		outw.format("%-20s %-15s %9s\n", "Hash", "Fold", "Max Len");
 		outw.println("-----------------------------------------------");
 		String lastHashName = null;
 			outw.format("%-20s %-15s %9d\n", //
 					hashName, //
 					fun.fold.name, //
-					fun.maxChainLength);
+					valueOf(fun.maxChainLength));
 			lastHashName = fun.hash.name;
 		}
 		outw.println();

org.eclipse.jgit.test/tst/org/eclipse/jgit/dircache/DirCacheCGitCompatabilityTest.java

 
 package org.eclipse.jgit.dircache;
 
+import static org.eclipse.jgit.junit.Assert.assertEquals;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;

org.eclipse.jgit.test/tst/org/eclipse/jgit/fnmatch/FileNameMatcherTest.java

 
 package org.eclipse.jgit.fnmatch;
 
-import static org.junit.Assert.assertEquals;
+import static org.eclipse.jgit.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreNodeTest.java

  */
 package org.eclipse.jgit.ignore;
 
+import static org.eclipse.jgit.junit.Assert.assertEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;

org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ObjectCheckerTest.java

 
 package org.eclipse.jgit.lib;
 
+import static java.lang.Integer.valueOf;
+import static java.lang.Long.valueOf;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
 
 			fail("Did not throw CorruptObjectException");
 		} catch (CorruptObjectException e) {
 			final String m = e.getMessage();
-			assertEquals(MessageFormat.format(JGitText.get().corruptObjectInvalidType2, Constants.OBJ_BAD), m);
+			assertEquals(MessageFormat.format(
+					JGitText.get().corruptObjectInvalidType2,
+					valueOf(Constants.OBJ_BAD)), m);
 		}
 	}
 

org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RacyGitTests.java

  */
 package org.eclipse.jgit.lib;
 
+import static java.lang.Long.valueOf;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 			if (i == 5)
 				fsTick(lastFile);
 		}
-		modTimes.add(fsTick(lastFile));
+		modTimes.add(valueOf(fsTick(lastFile)));
 		for (int i = 0; i < 10; i++) {
 			lastFile = new File(db.getWorkTree(), "1." + i);
 			FileUtils.createNewFile(lastFile);
 		}
-		modTimes.add(fsTick(lastFile));
+		modTimes.add(valueOf(fsTick(lastFile)));
 		for (int i = 0; i < 10; i++) {
 			lastFile = new File(db.getWorkTree(), "2." + i);
 			FileUtils.createNewFile(lastFile);
 
 		// wait to ensure that modtimes of the file doesn't match last index
 		// file modtime
-		modTimes.add(fsTick(db.getIndexFile()));
+		modTimes.add(valueOf(fsTick(db.getIndexFile())));
 
 		// create two files
 		addToWorkDir("a", "a");
 
 		// wait to ensure that file-modTimes and therefore index entry modTime
 		// doesn't match the modtime of index-file after next persistance
-		modTimes.add(fsTick(lastFile));
+		modTimes.add(valueOf(fsTick(lastFile)));
 
 		// now add both files to the index. No racy git expected
 		resetIndex(new FileTreeIteratorWithTimeControl(db, modTimes));

org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefTest.java

 
 package org.eclipse.jgit.lib;
 
+import static org.eclipse.jgit.junit.Assert.assertEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;

org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/ValidRefNameTest.java

 
 package org.eclipse.jgit.lib;
 
-import static org.junit.Assert.assertEquals;
+import static org.eclipse.jgit.junit.Assert.assertEquals;
 
 import org.junit.Test;
 

org.eclipse.jgit.test/tst/org/eclipse/jgit/patch/PatchCcErrorTest.java

 
 package org.eclipse.jgit.patch;
 
+import static java.lang.Integer.valueOf;
+import static java.lang.Long.valueOf;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 		{
 			final FormatError e = p.getErrors().get(0);
 			assertSame(FormatError.Severity.ERROR, e.getSeverity());
-			assertEquals(
-					MessageFormat.format(JGitText.get().truncatedHunkLinesMissingForAncestor, 1, 1),
-					e.getMessage());
+			assertEquals(MessageFormat.format(
+					JGitText.get().truncatedHunkLinesMissingForAncestor,
+					valueOf(1), valueOf(1)), e.getMessage());
 			assertEquals(346, e.getOffset());
 			assertTrue(e.getLineText().startsWith(
 					"@@@ -55,12 -163,13 +163,15 @@@ public "));
 		{
 			final FormatError e = p.getErrors().get(1);
 			assertSame(FormatError.Severity.ERROR, e.getSeverity());
-			assertEquals(
-					MessageFormat.format(JGitText.get().truncatedHunkLinesMissingForAncestor, 2, 2),
-					e.getMessage());
+			assertEquals(MessageFormat.format(
+					JGitText.get().truncatedHunkLinesMissingForAncestor,
+					valueOf(2), valueOf(2)), e.getMessage());
 			assertEquals(346, e.getOffset());
 			assertTrue(e.getLineText().startsWith(
 					"@@@ -55,12 -163,13 +163,15 @@@ public "));

org.eclipse.jgit.test/tst/org/eclipse/jgit/storage/file/GCTest.java

  */
 package org.eclipse.jgit.storage.file;
 
+import static java.lang.Integer.valueOf;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertSame;
 				syncPoint.await();
 				try {
 					gc.packRefs();
-					return 0;
+					return valueOf(0);
 				} catch (IOException e) {
-					return 1;
+					return valueOf(1);
 				}
 			}
 		};
 		try {
 			Future<Integer> p1 = pool.submit(packRefs);
 			Future<Integer> p2 = pool.submit(packRefs);
-			assertTrue(p1.get() + p2.get() == 1);
+			assertEquals(1, p1.get().intValue() + p2.get().intValue());
 		} finally {
 			pool.shutdown();
 			pool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
 				try {
 					gc.setProgressMonitor(this);
 					gc.repack();
-					return 0;
+					return valueOf(0);
 				} catch (IOException e) {
 					// leave the syncPoint in broken state so any awaiting
 					// threads and any threads that call await in the future get
 					} catch (InterruptedException ignored) {
 						//
 					}
-					return 1;
+					return valueOf(1);
 				}
 			}
 		}
 			DoRepack repack2 = new DoRepack();
 			Future<Integer> result1 = pool.submit(repack1);
 			Future<Integer> result2 = pool.submit(repack2);
-			assertTrue(result1.get() + result2.get() == 0);
+			assertEquals(0, result1.get().intValue() + result2.get().intValue());
 		} finally {
 			pool.shutdown();
 			pool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

org.eclipse.jgit.test/tst/org/eclipse/jgit/storage/file/RefUpdateTest.java

 
 package org.eclipse.jgit.storage.file;
 
+import static org.eclipse.jgit.junit.Assert.assertEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;

org.eclipse.jgit.test/tst/org/eclipse/jgit/transport/SideBandOutputStreamTest.java

 
 package org.eclipse.jgit.transport;
 
+import static java.lang.Integer.valueOf;
+import static java.lang.Long.valueOf;
 import static org.eclipse.jgit.transport.SideBandOutputStream.CH_DATA;
 import static org.eclipse.jgit.transport.SideBandOutputStream.CH_ERROR;
 import static org.eclipse.jgit.transport.SideBandOutputStream.CH_PROGRESS;
 			new SideBandOutputStream(CH_DATA, Integer.MAX_VALUE, rawOut);
 			fail("Accepted " + Integer.MAX_VALUE + " for buffer size");
 		} catch (IllegalArgumentException e) {
-			assertEquals(MessageFormat.format(JGitText.get().packetSizeMustBeAtMost, Integer.MAX_VALUE, 65520), e.getMessage());
+			assertEquals(MessageFormat.format(
+					JGitText.get().packetSizeMustBeAtMost,
+					valueOf(Integer.MAX_VALUE), valueOf(65520)), e.getMessage());
 		}
 	}
 

org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/NotTreeFilterTest.java

 
 package org.eclipse.jgit.treewalk.filter;
 
-import static org.junit.Assert.assertEquals;
+import static org.eclipse.jgit.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNotSame;