Fix deprecation warnings from Java 11 for tests

tomwhite · tomwhite · commit 3e307841f15e · 2019-09-17T14:53:08.000+01:00
diff --git a/src/test/java/org/broadinstitute/hellbender/testutils/VariantContextTestUtilsUnitTest.java b/src/test/java/org/broadinstitute/hellbender/testutils/VariantContextTestUtilsUnitTest.java
@@ -88,10 +88,10 @@ public void testNormalizeScientificNotation(Object toNormalize, Object expected)
     public Object[][] getIntegerValuesToNormalize(){
         final Object aSpecificObject = new Object();
         return new Object[][] {
-                {"27", new Integer(27)},
-                {"-27", new Integer(-27)},
-                {"0", new Integer(0)},
-                {"-27014", new Integer(-27014)},
+                {"27", 27},
+                {"-27", -27},
+                {"0", 0},
+                {"-27014", -27014},
                 {1, 1},
                 {1, 1},
                 {-1, -1},
diff --git a/src/test/java/org/broadinstitute/hellbender/tools/funcotator/FuncotatorIntegrationTest.java b/src/test/java/org/broadinstitute/hellbender/tools/funcotator/FuncotatorIntegrationTest.java
@@ -1143,10 +1143,10 @@ public void testVcfMafConcordance(final String inputVcf,
                 mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getContig).collect(Collectors.toList());
             }
             else if ( annotationsToCheckMaf.get(i).equals(MafOutputRendererConstants.FieldName_Start_Position) ) {
-                mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getStart).map(x -> new Integer(x)).map(Object::toString).collect(Collectors.toList());
+                mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getStart).map(Object::toString).collect(Collectors.toList());
             }
             else if ( annotationsToCheckMaf.get(i).equals(MafOutputRendererConstants.FieldName_End_Position) ) {
-                mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getEnd).map(x -> new Integer(x)).map(Object::toString).collect(Collectors.toList());
+                mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getEnd).map(Object::toString).collect(Collectors.toList());
             }
             else if ( annotationsToCheckMaf.get(i).equals(MafOutputRendererConstants.FieldName_Hugo_Symbol) ) {
                 mafFieldValues = maf.getRecords().stream().map(x -> x.getAnnotationValue(MafOutputRendererConstants.FieldName_Hugo_Symbol)).map(a -> a.isEmpty() ? "Unknown" : a).collect(Collectors.toList());
diff --git a/src/test/java/org/broadinstitute/hellbender/tools/spark/pathseq/PathSeqScoreIntegrationTest.java b/src/test/java/org/broadinstitute/hellbender/tools/spark/pathseq/PathSeqScoreIntegrationTest.java
@@ -43,11 +43,11 @@ private static Map<String, PSPathogenTaxonScore> getScores(final String[] lines)
             final PSPathogenTaxonScore score = new PSPathogenTaxonScore();
             final String taxonId = tok[0];
             score.setKingdomTaxonId(Math.abs(tok[4].hashCode()));
-            score.addSelfScore(new Double(tok[5]));
-            score.addScoreNormalized(new Double(tok[6]));
-            score.addTotalReads(new Integer(tok[7]));
-            score.addUnambiguousReads(new Integer(tok[8]));
-            score.setReferenceLength(new Long(tok[9]));
+            score.addSelfScore(Double.parseDouble(tok[5]));
+            score.addScoreNormalized(Double.parseDouble(tok[6]));
+            score.addTotalReads(Integer.parseInt(tok[7]));
+            score.addUnambiguousReads(Integer.parseInt((tok[8])));
+            score.setReferenceLength(Long.parseLong(tok[9]));
             Assert.assertFalse(scores.containsKey(taxonId), "Found more than one entry for taxon ID " + taxonId);
             scores.put(taxonId, score);
         }
diff --git a/src/test/java/org/broadinstitute/hellbender/tools/spark/sv/utils/SVKmerShortUnitTest.java b/src/test/java/org/broadinstitute/hellbender/tools/spark/sv/utils/SVKmerShortUnitTest.java
@@ -104,7 +104,7 @@ public void testRandomMaskedKmers() {
             //Generate random indices to mask
             List<Byte> maskIndices = new ArrayList<>(K);
             for (int j = 0; j < K; j++) {
-                maskIndices.add(new Byte((byte) j));
+                maskIndices.add((byte) j);
             }
             Collections.shuffle(maskIndices);
             int maskSize = rand.nextInt(K - 3) + 2;
diff --git a/src/test/java/org/broadinstitute/hellbender/tools/spark/utils/LargeLongHopscotchSetTest.java b/src/test/java/org/broadinstitute/hellbender/tools/spark/utils/LargeLongHopscotchSetTest.java
@@ -132,7 +132,7 @@ void resizeTest() {
         Assert.assertTrue(hopscotchSet.size() == hashSet.size());
         LongIterator itrL = hopscotchSet.iterator();
         while (itrL.hasNext()) {
-            Assert.assertTrue(hashSet.contains(new Long(itrL.next())));
+            Assert.assertTrue(hashSet.contains(itrL.next()));
         }
         for (Long val : hashSet) {
             Assert.assertTrue(hopscotchSet.contains(val.longValue()));
@@ -155,7 +155,7 @@ void loadRandomLongsTest() {
         for (int valNo = 0; valNo != HHASH_NVALS; ++valNo) {
             final long randLong = randomLong(rng);
             hopscotchSet.add(randLong);
-            hashSet.add(new Long(randLong));
+            hashSet.add(randLong);
         }
         Assert.assertEquals(hashSet.size(), hopscotchSet.size());
         for (final Long val : hashSet) {
diff --git a/src/test/java/org/broadinstitute/hellbender/tools/spark/utils/LongBloomFilterTest.java b/src/test/java/org/broadinstitute/hellbender/tools/spark/utils/LongBloomFilterTest.java
@@ -84,7 +84,7 @@ void testRandomLongs() {
         final LongBloomFilter bloomFilter = new LongBloomFilter(HHASH_NVALS, FPP);
         for (int valNo = 0; valNo != HHASH_NVALS; ++valNo) {
             final long randLong = randomLong(rng);
-            hashSet.add(new Long(randLong));
+            hashSet.add(randLong);
             bloomFilter.add(randLong);
         }
         for (final Long val : hashSet) {
@@ -94,7 +94,7 @@ void testRandomLongs() {
         int num_total = 0;
         for (int valNo = 0; valNo != FPR_NVALS; ++valNo) {
             final long randLong = randomLong(rng);
-            if (!hashSet.contains(new Long(randLong))) {
+            if (!hashSet.contains(randLong)) {
                 num_total++;
                 if (bloomFilter.contains(randLong)) {
                     num_false_pos++;
diff --git a/src/test/java/org/broadinstitute/hellbender/tools/spark/utils/LongHopscotchSetTest.java b/src/test/java/org/broadinstitute/hellbender/tools/spark/utils/LongHopscotchSetTest.java
@@ -72,7 +72,7 @@ void capacityTest() {
             Assert.assertTrue(capacity >= size);
             Assert.assertTrue(capacity < 2 * size);
             final List<Integer> legalSizes = IntStream.of(SetSizeUtils.legalSizes).boxed().collect(Collectors.toList());
-            Assert.assertTrue(legalSizes.contains(new Integer((int) capacity)));
+            Assert.assertTrue(legalSizes.contains((int) capacity));
         }
     }
 
@@ -106,7 +106,7 @@ void iteratorTest() {
         final List<Long> filteredVals = new LinkedList<>();
         for (long testVal : testVals) {
             if (KEY_TO_REMOVE == testVal) {
-                filteredVals.add(new Long(testVal));
+                filteredVals.add(testVal);
             }
         }
         final int onesCount = filteredVals.size();
@@ -186,7 +186,7 @@ void loadRandomLongsTest() {
             for (int valNo = 0; valNo != HHASH_NVALS; ++valNo) {
                 final long randLong = randomLong(rng);
                 hopscotchSet.add(randLong);
-                hashSet.add(new Long(randLong));
+                hashSet.add(randLong);
             }
             Assert.assertEquals(hashSet.size(), hopscotchSet.size(), trialMsg);
             for (final Long val : hashSet) {
diff --git a/src/test/java/org/broadinstitute/hellbender/utils/HistogramUnitTest.java b/src/test/java/org/broadinstitute/hellbender/utils/HistogramUnitTest.java
@@ -16,8 +16,8 @@ public void testAdd() throws Exception {
         for (int i = 0; i <= 100; i++) {
             bimodalHist.add(1 + i / 1000.0);
         }
-        Assert.assertEquals(bimodalHist.get(1.0), new Integer(100), "");
-        Assert.assertEquals(bimodalHist.get(1.1), new Integer(1), "");
+        Assert.assertEquals(bimodalHist.get(1.0), Integer.valueOf(100), "");
+        Assert.assertEquals(bimodalHist.get(1.1), Integer.valueOf(1), "");
     }
 
     @Test
@@ -26,7 +26,7 @@ public void testAddingQuantizedValues() throws Exception {
         for (int i = 0; i < 100; i++) {
             hist.add(1.2);
         }
-        Assert.assertEquals(hist.get(1.2), new Integer(100));
+        Assert.assertEquals(hist.get(1.2), Integer.valueOf(100));
         Assert.assertEquals(hist.median(), 1.2, EPSILON);
     }
 
@@ -36,8 +36,8 @@ public void testBulkAdd() throws Exception {
         for (int i = 0; i <= 100; i++) {
             bimodalHist.add(1 + i / 1000.0, 2);
         }
-        Assert.assertEquals(bimodalHist.get(1.0), new Integer(200), "");
-        Assert.assertEquals(bimodalHist.get(1.1), new Integer(2), "");
+        Assert.assertEquals(bimodalHist.get(1.0), Integer.valueOf(200), "");
+        Assert.assertEquals(bimodalHist.get(1.1), Integer.valueOf(2), "");
     }
 
     @Test
diff --git a/src/test/java/org/broadinstitute/hellbender/utils/hmm/HMMUnitTest.java b/src/test/java/org/broadinstitute/hellbender/utils/hmm/HMMUnitTest.java
@@ -261,7 +261,7 @@ public void testBackward(final TestHMM model, final List<TestHMM.Datum> sequence
         for (int position = positions.size() - 1; position >= 0; position--) {
             for (final TestHMM.State state : TestHMM.State.values()) {
                 final double expectedValue = expected.get(position)[state.ordinal()];
-                final double observedValue = forwardBackwardResult.logBackwardProbability(new Integer(position), state);
+                final double observedValue = forwardBackwardResult.logBackwardProbability(Integer.valueOf(position), state);
                 final double observedValueUsingIndex = forwardBackwardResult.logBackwardProbability(position, state);
                 Assert.assertEquals(observedValueUsingIndex, observedValue);
                 final double epsilon = 0.001 * Math.min(Math.abs(expectedValue),
@@ -500,7 +500,7 @@ public void testLogProbabilityWithNullStateUsingPositionObject() {
 
         }
         Assert.assertNotNull(result);
-        result.logProbability(new Integer(2), (TestHMM.State)null);
+        result.logProbability(Integer.valueOf(2), (TestHMM.State)null);
     }
 
 
@@ -529,7 +529,7 @@ public void testLogDataLikelihoodWithWrongTargetUsingPositionObject() {
             Assert.fail("this part of the test must not fail");
 
         }
-        result.logDataLikelihood(new Integer(14));
+        result.logDataLikelihood(Integer.valueOf(14));
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
@@ -559,7 +559,7 @@ public void testLogBackProbabilityWithNullStateUsingPositionObject() {
 
         }
         Assert.assertNotNull(result);
-        result.logBackwardProbability(new Integer(2), null);
+        result.logBackwardProbability(Integer.valueOf(2), null);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
@@ -589,7 +589,7 @@ public void testLogForwardProbabilityWithNullStateUsingPositionObject() {
 
         }
         Assert.assertNotNull(result);
-        result.logForwardProbability(new Integer(2), null);
+        result.logForwardProbability(Integer.valueOf(2), null);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
@@ -649,7 +649,7 @@ public void testLogProbabilityWithMadeUpPositionObject() {
 
         }
         Assert.assertNotNull(result);
-        result.logProbability(new Integer(14), TestHMM.State.A);
+        result.logProbability(Integer.valueOf(14), TestHMM.State.A);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
@@ -679,7 +679,7 @@ public void testLogProbabilityWithASequenceThatIsTwoLongUsingPositionObject() {
 
         }
         Assert.assertNotNull(result);
-        result.logProbability(new Integer(2), Arrays.asList(TestHMM.State.A, TestHMM.State.A, TestHMM.State.B));
+        result.logProbability(Integer.valueOf(2), Arrays.asList(TestHMM.State.A, TestHMM.State.A, TestHMM.State.B));
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
@@ -769,7 +769,7 @@ public void testLogProbabilityWithNonExistentPositionObject() {
 
         }
         Assert.assertNotNull(result);
-        result.logProbability(new Integer(4), TestHMM.State.A);
+        result.logProbability(Integer.valueOf(4), TestHMM.State.A);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
diff --git a/src/test/java/org/broadinstitute/hellbender/utils/pairhmm/VectorPairHMMUnitTest.java b/src/test/java/org/broadinstitute/hellbender/utils/pairhmm/VectorPairHMMUnitTest.java
@@ -42,7 +42,7 @@ private List<Pair<PairHMM, Boolean> > getHMMs() {
                 loaded = false;
             }
 
-            final Pair<PairHMM, Boolean> hmm_load = new ImmutablePair<PairHMM, Boolean>(avxPairHMM, new Boolean(loaded));
+            final Pair<PairHMM, Boolean> hmm_load = new ImmutablePair<PairHMM, Boolean>(avxPairHMM, loaded);
             list.add(hmm_load);
         }
 
diff --git a/src/test/java/org/broadinstitute/hellbender/utils/recalibration/RecalDatumUnitTest.java b/src/test/java/org/broadinstitute/hellbender/utils/recalibration/RecalDatumUnitTest.java
@@ -217,7 +217,7 @@ public void testlog10QempLikelihood() {
             }
         }
 
-        long bigNum = new Long((long) Integer.MAX_VALUE);
+        long bigNum = Integer.MAX_VALUE;
         bigNum *= 2L;
         final double log10likelihood = RecalDatum.log10QempLikelihood(30, bigNum, 100000);
         Assert.assertTrue(log10likelihood < 0.0);

Original file line number	Diff line number	Diff line change
`@@ -1143,10 +1143,10 @@ public void testVcfMafConcordance(final String inputVcf,`
`1143`	`1143`	`mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getContig).collect(Collectors.toList());`
`1144`	`1144`	`}`
`1145`	`1145`	`else if ( annotationsToCheckMaf.get(i).equals(MafOutputRendererConstants.FieldName_Start_Position) ) {`
`1146`		`- mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getStart).map(x -> new Integer(x)).map(Object::toString).collect(Collectors.toList());`
	`1146`	`+ mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getStart).map(Object::toString).collect(Collectors.toList());`
`1147`	`1147`	`}`
`1148`	`1148`	`else if ( annotationsToCheckMaf.get(i).equals(MafOutputRendererConstants.FieldName_End_Position) ) {`
`1149`		`- mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getEnd).map(x -> new Integer(x)).map(Object::toString).collect(Collectors.toList());`
	`1149`	`+ mafFieldValues = maf.getRecords().stream().map(AnnotatedInterval::getEnd).map(Object::toString).collect(Collectors.toList());`
`1150`	`1150`	`}`
`1151`	`1151`	`else if ( annotationsToCheckMaf.get(i).equals(MafOutputRendererConstants.FieldName_Hugo_Symbol) ) {`
`1152`	`1152`	`mafFieldValues = maf.getRecords().stream().map(x -> x.getAnnotationValue(MafOutputRendererConstants.FieldName_Hugo_Symbol)).map(a -> a.isEmpty() ? "Unknown" : a).collect(Collectors.toList());`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ public void testRandomMaskedKmers() {`
`104`	`104`	`//Generate random indices to mask`
`105`	`105`	`List<Byte> maskIndices = new ArrayList<>(K);`
`106`	`106`	`for (int j = 0; j < K; j++) {`
`107`		`- maskIndices.add(new Byte((byte) j));`
	`107`	`+ maskIndices.add((byte) j);`
`108`	`108`	`}`
`109`	`109`	`Collections.shuffle(maskIndices);`
`110`	`110`	`int maskSize = rand.nextInt(K - 3) + 2;`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ void capacityTest() {`
`72`	`72`	`Assert.assertTrue(capacity >= size);`
`73`	`73`	`Assert.assertTrue(capacity < 2 * size);`
`74`	`74`	`final List<Integer> legalSizes = IntStream.of(SetSizeUtils.legalSizes).boxed().collect(Collectors.toList());`
`75`		`- Assert.assertTrue(legalSizes.contains(new Integer((int) capacity)));`
	`75`	`+ Assert.assertTrue(legalSizes.contains((int) capacity));`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`@@ -106,7 +106,7 @@ void iteratorTest() {`
`106`	`106`	`final List<Long> filteredVals = new LinkedList<>();`
`107`	`107`	`for (long testVal : testVals) {`
`108`	`108`	`if (KEY_TO_REMOVE == testVal) {`
`109`		`- filteredVals.add(new Long(testVal));`
	`109`	`+ filteredVals.add(testVal);`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`	`final int onesCount = filteredVals.size();`
`@@ -186,7 +186,7 @@ void loadRandomLongsTest() {`
`186`	`186`	`for (int valNo = 0; valNo != HHASH_NVALS; ++valNo) {`
`187`	`187`	`final long randLong = randomLong(rng);`
`188`	`188`	`hopscotchSet.add(randLong);`
`189`		`- hashSet.add(new Long(randLong));`
	`189`	`+ hashSet.add(randLong);`
`190`	`190`	`}`
`191`	`191`	`Assert.assertEquals(hashSet.size(), hopscotchSet.size(), trialMsg);`
`192`	`192`	`for (final Long val : hashSet) {`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,8 @@ public void testAdd() throws Exception {`
`16`	`16`	`for (int i = 0; i <= 100; i++) {`
`17`	`17`	`bimodalHist.add(1 + i / 1000.0);`
`18`	`18`	`}`
`19`		`- Assert.assertEquals(bimodalHist.get(1.0), new Integer(100), "");`
`20`		`- Assert.assertEquals(bimodalHist.get(1.1), new Integer(1), "");`
	`19`	`+ Assert.assertEquals(bimodalHist.get(1.0), Integer.valueOf(100), "");`
	`20`	`+ Assert.assertEquals(bimodalHist.get(1.1), Integer.valueOf(1), "");`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`@Test`
`@@ -26,7 +26,7 @@ public void testAddingQuantizedValues() throws Exception {`
`26`	`26`	`for (int i = 0; i < 100; i++) {`
`27`	`27`	`hist.add(1.2);`
`28`	`28`	`}`
`29`		`- Assert.assertEquals(hist.get(1.2), new Integer(100));`
	`29`	`+ Assert.assertEquals(hist.get(1.2), Integer.valueOf(100));`
`30`	`30`	`Assert.assertEquals(hist.median(), 1.2, EPSILON);`
`31`	`31`	`}`
`32`	`32`
`@@ -36,8 +36,8 @@ public void testBulkAdd() throws Exception {`
`36`	`36`	`for (int i = 0; i <= 100; i++) {`
`37`	`37`	`bimodalHist.add(1 + i / 1000.0, 2);`
`38`	`38`	`}`
`39`		`- Assert.assertEquals(bimodalHist.get(1.0), new Integer(200), "");`
`40`		`- Assert.assertEquals(bimodalHist.get(1.1), new Integer(2), "");`
	`39`	`+ Assert.assertEquals(bimodalHist.get(1.0), Integer.valueOf(200), "");`
	`40`	`+ Assert.assertEquals(bimodalHist.get(1.1), Integer.valueOf(2), "");`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`@Test`
Original file line number	Diff line number	Diff line change
`@@ -261,7 +261,7 @@ public void testBackward(final TestHMM model, final List<TestHMM.Datum> sequence`
`261`	`261`	`for (int position = positions.size() - 1; position >= 0; position--) {`
`262`	`262`	`for (final TestHMM.State state : TestHMM.State.values()) {`
`263`	`263`	`final double expectedValue = expected.get(position)[state.ordinal()];`
`264`		`- final double observedValue = forwardBackwardResult.logBackwardProbability(new Integer(position), state);`
	`264`	`+ final double observedValue = forwardBackwardResult.logBackwardProbability(Integer.valueOf(position), state);`
`265`	`265`	`final double observedValueUsingIndex = forwardBackwardResult.logBackwardProbability(position, state);`
`266`	`266`	`Assert.assertEquals(observedValueUsingIndex, observedValue);`
`267`	`267`	`final double epsilon = 0.001 * Math.min(Math.abs(expectedValue),`
`@@ -500,7 +500,7 @@ public void testLogProbabilityWithNullStateUsingPositionObject() {`
`500`	`500`
`501`	`501`	`}`
`502`	`502`	`Assert.assertNotNull(result);`
`503`		`- result.logProbability(new Integer(2), (TestHMM.State)null);`
	`503`	`+ result.logProbability(Integer.valueOf(2), (TestHMM.State)null);`
`504`	`504`	`}`
`505`	`505`
`506`	`506`
`@@ -529,7 +529,7 @@ public void testLogDataLikelihoodWithWrongTargetUsingPositionObject() {`
`529`	`529`	`Assert.fail("this part of the test must not fail");`
`530`	`530`
`531`	`531`	`}`
`532`		`- result.logDataLikelihood(new Integer(14));`
	`532`	`+ result.logDataLikelihood(Integer.valueOf(14));`
`533`	`533`	`}`
`534`	`534`
`535`	`535`	`@Test(expectedExceptions = IllegalArgumentException.class)`
`@@ -559,7 +559,7 @@ public void testLogBackProbabilityWithNullStateUsingPositionObject() {`
`559`	`559`
`560`	`560`	`}`
`561`	`561`	`Assert.assertNotNull(result);`
`562`		`- result.logBackwardProbability(new Integer(2), null);`
	`562`	`+ result.logBackwardProbability(Integer.valueOf(2), null);`
`563`	`563`	`}`
`564`	`564`
`565`	`565`	`@Test(expectedExceptions = IllegalArgumentException.class)`
`@@ -589,7 +589,7 @@ public void testLogForwardProbabilityWithNullStateUsingPositionObject() {`
`589`	`589`
`590`	`590`	`}`
`591`	`591`	`Assert.assertNotNull(result);`
`592`		`- result.logForwardProbability(new Integer(2), null);`
	`592`	`+ result.logForwardProbability(Integer.valueOf(2), null);`
`593`	`593`	`}`
`594`	`594`
`595`	`595`	`@Test(expectedExceptions = IllegalArgumentException.class)`
`@@ -649,7 +649,7 @@ public void testLogProbabilityWithMadeUpPositionObject() {`
`649`	`649`
`650`	`650`	`}`
`651`	`651`	`Assert.assertNotNull(result);`
`652`		`- result.logProbability(new Integer(14), TestHMM.State.A);`
	`652`	`+ result.logProbability(Integer.valueOf(14), TestHMM.State.A);`
`653`	`653`	`}`
`654`	`654`
`655`	`655`	`@Test(expectedExceptions = IllegalArgumentException.class)`
`@@ -679,7 +679,7 @@ public void testLogProbabilityWithASequenceThatIsTwoLongUsingPositionObject() {`
`679`	`679`
`680`	`680`	`}`
`681`	`681`	`Assert.assertNotNull(result);`
`682`		`- result.logProbability(new Integer(2), Arrays.asList(TestHMM.State.A, TestHMM.State.A, TestHMM.State.B));`
	`682`	`+ result.logProbability(Integer.valueOf(2), Arrays.asList(TestHMM.State.A, TestHMM.State.A, TestHMM.State.B));`
`683`	`683`	`}`
`684`	`684`
`685`	`685`	`@Test(expectedExceptions = IllegalArgumentException.class)`
`@@ -769,7 +769,7 @@ public void testLogProbabilityWithNonExistentPositionObject() {`
`769`	`769`
`770`	`770`	`}`
`771`	`771`	`Assert.assertNotNull(result);`
`772`		`- result.logProbability(new Integer(4), TestHMM.State.A);`
	`772`	`+ result.logProbability(Integer.valueOf(4), TestHMM.State.A);`
`773`	`773`	`}`
`774`	`774`
`775`	`775`	`@Test(expectedExceptions = IllegalArgumentException.class)`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ private List<Pair<PairHMM, Boolean> > getHMMs() {`
`42`	`42`	`loaded = false;`
`43`	`43`	`}`
`44`	`44`
`45`		`- final Pair<PairHMM, Boolean> hmm_load = new ImmutablePair<PairHMM, Boolean>(avxPairHMM, new Boolean(loaded));`
	`45`	`+ final Pair<PairHMM, Boolean> hmm_load = new ImmutablePair<PairHMM, Boolean>(avxPairHMM, loaded);`
`46`	`46`	`list.add(hmm_load);`
`47`	`47`	`}`
`48`	`48`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ public void testlog10QempLikelihood() {`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`
`220`		`- long bigNum = new Long((long) Integer.MAX_VALUE);`
	`220`	`+ long bigNum = Integer.MAX_VALUE;`
`221`	`221`	`bigNum *= 2L;`
`222`	`222`	`final double log10likelihood = RecalDatum.log10QempLikelihood(30, bigNum, 100000);`
`223`	`223`	`Assert.assertTrue(log10likelihood < 0.0);`