@Override public WeakReference<Object> call() { WeakReference<Object> wr = new FinalizableWeakReference<Object>(new Integer(23), frq) { @Override public void finalizeReferent() { finalized.release(); } }; return wr; } }
@Override @Bean public Integer m1() { return new Integer(42); } }
public Object doubleOrQuits(ProceedingJoinPoint pjp) throws Throwable { int value = ((Integer) pjp.getArgs()[0]).intValue(); pjp.getArgs()[0] = new Integer(value * 2); return pjp.proceed(); }
public void testToStringLenient_oneIntegerField() { String toTest = MoreObjects.toStringHelper(new TestClass()).add("field1", new Integer(42)).toString(); assertTrue(toTest, toTest.matches(".*\\{field1\\=42\\}")); }
public void testLeastOfIterator_ties() { Integer foo = new Integer(Integer.MAX_VALUE - 10); Integer bar = new Integer(Integer.MAX_VALUE - 10); assertNotSame(foo, bar); assertEquals(foo, bar); List<Integer> list = Arrays.asList(3, foo, bar, -1); List<Integer> result = numberOrdering.leastOf(list.iterator(), list.size()); assertEquals(ImmutableList.of(-1, 3, foo, bar), result); }
public void testPutAllThrows() { try { map.putAll(ImmutableMap.of(TypeToken.of(Integer.class), new Integer(5))); fail(); } catch (UnsupportedOperationException expected) { } }
public void testLeastOfIterable_ties() { Integer foo = new Integer(Integer.MAX_VALUE - 10); Integer bar = new Integer(Integer.MAX_VALUE - 10); assertNotSame(foo, bar); assertEquals(foo, bar); List<Integer> list = Arrays.asList(3, foo, bar, -1); List<Integer> result = numberOrdering.leastOf(list, list.size()); assertEquals(ImmutableList.of(-1, 3, foo, bar), result); }
public void testHashCode() throws Exception { int h1 = Objects.hashCode(1, "two", 3.0); int h2 = Objects.hashCode(new Integer(1), new String("two"), new Double(3.0)); // repeatable assertEquals(h1, h2); // These don't strictly need to be true, but they're nice properties. assertTrue(Objects.hashCode(1, 2, null) != Objects.hashCode(1, 2)); assertTrue(Objects.hashCode(1, 2, null) != Objects.hashCode(1, null, 2)); assertTrue(Objects.hashCode(1, null, 2) != Objects.hashCode(1, 2)); assertTrue(Objects.hashCode(1, 2, 3) != Objects.hashCode(3, 2, 1)); assertTrue(Objects.hashCode(1, 2, 3) != Objects.hashCode(2, 3, 1)); }
public void testPutThrows() { try { map.put(TypeToken.of(Integer.class), new Integer(5)); fail(); } catch (UnsupportedOperationException expected) { } }
@GwtIncompatible // Class names are obfuscated in GWT public void testToString_oneIntegerField() { String toTest = MoreObjects.toStringHelper(new TestClass()).add("field1", new Integer(42)).toString(); assertEquals("TestClass{field1=42}", toTest); }
public void testNewIdentityHashSet() { Set<Integer> set = Sets.newIdentityHashSet(); Integer value1 = new Integer(12357); Integer value2 = new Integer(12357); assertTrue(set.add(value1)); assertFalse(set.contains(value2)); assertTrue(set.contains(value1)); assertTrue(set.add(value2)); assertEquals(2, set.size()); }
public void testIteratorMinAndMax() { List<Integer> ints = Lists.newArrayList(5, 3, 0, 9); assertEquals(9, (int) numberOrdering.max(ints.iterator())); assertEquals(0, (int) numberOrdering.min(ints.iterator())); // when the values are the same, the first argument should be returned Integer a = new Integer(4); Integer b = new Integer(4); ints = Lists.newArrayList(a, b, b); assertSame(a, numberOrdering.max(ints.iterator())); assertSame(a, numberOrdering.min(ints.iterator())); }
public void testEntrySet_contain() { WellBehavedMap<Foo, Integer> map = WellBehavedMap.wrap(new EnumMap<Foo, Integer>(Foo.class)); map.putAll(ImmutableMap.of(Foo.X, 1, Foo.Y, 2, Foo.Z, 3)); // testing with the exact entry assertTrue(map.entrySet().contains(Maps.immutableEntry(Foo.X, 1))); assertTrue(map.entrySet().contains(Maps.immutableEntry(Foo.Y, new Integer(2)))); // testing an entry with a contained key, but not the same value assertFalse(map.entrySet().contains(Maps.immutableEntry(Foo.X, 5))); // testing a non-existent key assertFalse(map.entrySet().contains(Maps.immutableEntry(Foo.T, 0))); }
public void testWeak_afterGC() throws InterruptedException { Integer canonical = new Integer(5); Integer not = new Integer(5); Interner<Integer> pool = Interners.newWeakInterner(); assertSame(canonical, pool.intern(canonical)); WeakReference<Integer> signal = new WeakReference<>(canonical); canonical = null; // Hint to the JIT that canonical is unreachable GcFinalization.awaitClear(signal); assertSame(not, pool.intern(not)); }
public void testIterableMinAndMax() { List<Integer> ints = Lists.newArrayList(5, 3, 0, 9); assertEquals(9, (int) numberOrdering.max(ints)); assertEquals(0, (int) numberOrdering.min(ints)); // when the values are the same, the first argument should be returned Integer a = new Integer(4); Integer b = new Integer(4); ints = Lists.newArrayList(a, b, b); assertSame(a, numberOrdering.max(ints)); assertSame(a, numberOrdering.min(ints)); }
public void testPutAndGetInstance() { assertNull(map.putInstance(Integer.class, new Integer(5))); Integer oldValue = map.putInstance(Integer.class, new Integer(7)); assertEquals(5, (int) oldValue); Integer newValue = map.getInstance(Integer.class); assertEquals(7, (int) newValue); // Won't compile: map.putInstance(Double.class, new Long(42)); }
public void testPutAndGetInstance() { assertNull(map.putInstance(Integer.class, new Integer(5))); Integer oldValue = map.putInstance(Integer.class, new Integer(7)); assertEquals(5, (int) oldValue); Integer newValue = map.getInstance(Integer.class); assertEquals(7, (int) newValue); assertEquals(7, (int) map.getInstance(TypeToken.of(Integer.class))); // Won't compile: map.putInstance(Double.class, new Long(42)); }
public void testEqualsEquivalent() { EquivalenceTester.of(Equivalence.equals()) .addEquivalenceGroup(new Integer(42), 42) .addEquivalenceGroup("a") .test(); }
public void testParameterMinAndMax() { assertEquals(5, (int) numberOrdering.max(3, 5)); assertEquals(5, (int) numberOrdering.max(5, 3)); assertEquals(3, (int) numberOrdering.min(3, 5)); assertEquals(3, (int) numberOrdering.min(5, 3)); // when the values are the same, the first argument should be returned Integer a = new Integer(4); Integer b = new Integer(4); assertSame(a, numberOrdering.max(a, b)); assertSame(a, numberOrdering.min(a, b)); }