@GwtIncompatible("ObjectArrays.concat(Object[], Object[], Class)")
public void testConcatBasic() {
String[] result =
ObjectArrays.concat(new String[] {"a", "b"}, new String[] {"c", "d"}, String.class);
assertEquals(String[].class, result.getClass());
ASSERT.that(result).hasContentsInOrder("a", "b", "c", "d");
}
@GwtIncompatible("ObjectArrays.newArray(Class, int)")
public void testNewArray_fromClass_OfArray() {
String[][] array = ObjectArrays.newArray(String[].class, 1);
assertEquals(String[][].class, array.getClass());
assertEquals(1, array.length);
assertNull(array[0]);
}
private void doTestToArrayImpl2(List<Integer> list, Integer[] array1, boolean expectModify) {
Integer[] starting = ObjectArrays.arraysCopyOf(array1, array1.length);
Integer[] array2 = ObjectArrays.arraysCopyOf(array1, array1.length);
Object[] reference = list.toArray(array1);
Object[] target = ObjectArrays.toArrayImpl(list, array2);
assertEquals(reference.getClass(), target.getClass());
assertTrue(Arrays.equals(reference, target));
assertTrue(Arrays.equals(reference, target));
Object[] expectedArray1 = expectModify ? reference : starting;
Object[] expectedArray2 = expectModify ? target : starting;
assertTrue(Arrays.equals(expectedArray1, array1));
assertTrue(Arrays.equals(expectedArray2, array2));
}
private void ensureCapacity(int minCapacity) {
if (minCapacity > entries.length) {
entries =
ObjectArrays.arraysCopyOf(
entries, ImmutableCollection.Builder.expandedCapacity(entries.length, minCapacity));
}
}
@Test
public void testCollectionInstance() {
Maps.newLinkedHashMap();
Lists.newArrayList();
Sets.newHashSet();
ObjectArrays.newArray(Integer.class, 10);
}
public IAndroidTarget[] getTargets(boolean includeMissing) {
IAndroidTarget[] result = getTargets();
if (includeMissing) {
result = ObjectArrays.concat(result, getMissingTargets(), IAndroidTarget.class);
}
return result;
}
/* */ public void clear()
/* */ {
/* 368 */ if (this.size == 0) return;
/* 369 */ this.size = 0;
/* 370 */ BooleanArrays.fill(this.used, false);
/* */
/* 372 */ ObjectArrays.fill(this.key, null);
/* */ }
@Override
public <T> T[] toArray(T[] other) {
if (other.length < size) {
other = ObjectArrays.newArray(other, size);
} else if (other.length > size) {
other[size] = null;
}
System.arraycopy(array, offset, other, 0, size);
return other;
}
// TODO: Move to ObjectArrays (same code in ImmutableList).
@Override
public <T> T[] toArray(T[] array) {
int size = size();
if (array.length < size) {
array = ObjectArrays.newArray(array, size);
} else if (array.length > size) {
array[size] = null;
}
System.arraycopy(elements, fromIndex, array, 0, size);
return array;
}
static ImmutableSortedSet construct(Comparator paramComparator, int paramInt, Object... paramVarArgs)
{
int i = sortAndUnique(paramComparator, paramInt, paramVarArgs);
if (i == 0) {
return emptySet(paramComparator);
}
if (i < paramVarArgs.length) {
paramVarArgs = ObjectArrays.arraysCopyOf(paramVarArgs, i);
}
return new RegularImmutableSortedSet(ImmutableList.asImmutableList(paramVarArgs), paramComparator);
}
@Test
public void should_fail_if_actual_is_empty() {
AssertionInfo info = someInfo();
try {
arrays.assertNotEmpty(info, emptyArray());
} catch (AssertionError e) {
verify(failures).failure(info, shouldNotBeEmpty());
return;
}
failBecauseExpectedAssertionErrorWasNotThrown();
}
@Override
public <T> T[] toArray(T[] array) {
if (array.length == 0) {
array = ObjectArrays.newArray(array, 1);
} else if (array.length > 1) {
array[1] = null;
}
// Writes will produce ArrayStoreException when the toArray() doc requires.
Object[] objectArray = array;
objectArray[0] = element;
return array;
}
public <T> T[] toArray(T[] paramArrayOfT)
{
if (paramArrayOfT.length == 0)
paramArrayOfT = ObjectArrays.a(paramArrayOfT, 1);
while (true)
{
paramArrayOfT[0] = this.a;
return paramArrayOfT;
if (paramArrayOfT.length > 1)
paramArrayOfT[1] = null;
}
}
public <T> T[] toArray(T[] paramArrayOfT) {
Object localObject;
if (paramArrayOfT.length == 0) {
localObject = ObjectArrays.newArray(paramArrayOfT, 1);
}
for (; ; ) {
localObject[0] = element;
return (T[]) localObject;
localObject = paramArrayOfT;
if (paramArrayOfT.length > 1) {
paramArrayOfT[1] = null;
localObject = paramArrayOfT;
}
}
}
/*
* TODO(hhchan): Revert once we have a separate, manual emulation of this
* class.
*/
@Override
public <T> T[] toArray(T[] other) {
int size = size();
if (other.length < size) {
other = ObjectArrays.newArray(other, size);
} else if (other.length > size) {
other[size] = null;
}
// Writes will produce ArrayStoreException when the toArray() doc requires
Object[] otherAsObjectArray = other;
int index = 0;
for (Entry<?> element : this) {
otherAsObjectArray[index++] = element;
}
return other;
}
@Override
@SuppressWarnings("nullness")
// Suppressed due to annotations of toArray
public <T> /*@Nullable*/ T[] toArray(T[] other) {
int size = size();
if (other.length < size) {
other = ObjectArrays.newArray(other, size);
} else if (other.length > size) {
other[size] = null;
}
// Writes will produce ArrayStoreException when the toArray() doc requires.
Object[] otherAsObjectArray = other;
int index = 0;
for (E element : this) {
otherAsObjectArray[index++] = element;
}
return other;
}
static int sortAndUnique(Comparator paramComparator, int paramInt, Object... paramVarArgs)
{
if (paramInt == 0) {
return 0;
}
for (int i = 0; i < paramInt; i++) {
ObjectArrays.checkElementNotNull(paramVarArgs[i], i);
}
Arrays.sort(paramVarArgs, 0, paramInt, paramComparator);
i = 1;
for (int j = 1; j < paramInt; j++)
{
Object localObject1 = paramVarArgs[j];
Object localObject2 = paramVarArgs[(i - 1)];
if (paramComparator.compare(localObject1, localObject2) != 0) {
paramVarArgs[(i++)] = localObject1;
}
}
Arrays.fill(paramVarArgs, i, paramInt, null);
return i;
}
public void testPrependOneElement() {
String[] result = ObjectArrays.concat("foo", new String[] {"bar"});
ASSERT.that(result).hasContentsInOrder("foo", "bar");
}
public void testNonEmptyToLonger() {
checkArrayEquals(
new String[10], ObjectArrays.newArray(new String[] {"a", "b", "c", "d", "e"}, 10));
}
@GwtIncompatible("ObjectArrays.concat(Object[], Object[], Class)")
public void testConcatEmptyNonempty() {
String[] result = ObjectArrays.concat(new String[0], new String[] {"a", "b"}, String.class);
assertEquals(String[].class, result.getClass());
ASSERT.that(result).has().exactly("a", "b").inOrder();
}
private static void doTestNewArrayEquals(Object[] expected, int length) {
checkArrayEquals(expected, ObjectArrays.newArray(expected, length));
}
private void doTestToArrayImpl1(List<Integer> list) {
Object[] reference = list.toArray();
Object[] target = ObjectArrays.toArrayImpl(list);
assertEquals(reference.getClass(), target.getClass());
assertTrue(Arrays.equals(reference, target));
}
@GwtIncompatible("ObjectArrays.concat(Object[], Object[], Class)")
public void testConcatWithMoreGeneralType() {
Serializable[] result = ObjectArrays.concat(new String[0], new String[0], Serializable.class);
assertEquals(Serializable[].class, result.getClass());
}
@GwtIncompatible("ObjectArrays.concat(Object[], Object[], Class)")
public void testConcatEmptyEmpty() {
String[] result = ObjectArrays.concat(new String[0], new String[0], String.class);
assertEquals(String[].class, result.getClass());
assertEquals(0, result.length);
}
/**
* Creates a new tree set and fills it with the elements of a given array using a given {@link
* Comparator}.
*
* @param a an array whose elements will be used to fill the set.
* @param offset the first element to use.
* @param length the number of elements to use.
* @param c a {@link Comparator} (even better, a type-specific comparator).
*/
public ObjectRBTreeSet(
final K[] a, final int offset, final int length, final Comparator<? super K> c) {
this(c);
ObjectArrays.ensureOffsetLength(a, offset, length);
for (int i = 0; i < length; i++) add(a[offset + i]);
}
public void testNewArray_fromArray_OfArray() {
String[][] array = ObjectArrays.newArray(new String[0][0], 1);
assertEquals(String[][].class, array.getClass());
assertEquals(1, array.length);
assertNull(array[0]);
}
public void testNewArray_fromArray_Empty() {
String[] in = new String[0];
String[] empty = ObjectArrays.newArray(in, 0);
assertEquals(0, empty.length);
}
public void testPrependZeroElements() {
String[] result = ObjectArrays.concat("foo", new String[] {});
ASSERT.that(result).hasContentsInOrder("foo");
}
@GwtIncompatible("ObjectArrays.newArray(Class, int)")
public void testNewArray_fromClass_Empty() {
String[] empty = ObjectArrays.newArray(String.class, 0);
assertEquals(String[].class, empty.getClass());
assertEquals(0, empty.length);
}
public void testAppendTwoElements() {
String[] result = ObjectArrays.concat(new String[] {"foo", "bar"}, "baz");
ASSERT.that(result).hasContentsInOrder("foo", "bar", "baz");
}
