Skip to content

Commit

Permalink
Further Truthy fixes.
Browse files Browse the repository at this point in the history 
RELNOTES=n/a
PiperOrigin-RevId: 442652778
  • Loading branch information
@eamonnmcmanus
eamonnmcmanus authored and Google Java Core Libraries committed Apr 19, 2022
1 parent 0ca124d commit 759c409
Show file tree
Hide file tree
Showing 6 changed files with 162 additions and 242 deletions.
80 changes: 31 additions & 49 deletions android/guava-tests/test/com/google/common/primitives/DoublesTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -252,22 +252,12 @@ public void testMin() {
}

public void testConstrainToRange() {
double tolerance = 1e-10;
assertThat(Doubles.constrainToRange((double) 1, (double) 0, (double) 5))
.isWithin(tolerance)
.of((double) 1);
assertThat(Doubles.constrainToRange((double) 1, (double) 1, (double) 5))
.isWithin(tolerance)
.of((double) 1);
assertThat(Doubles.constrainToRange((double) 1, (double) 3, (double) 5))
.isWithin(tolerance)
.of((double) 3);
assertThat(Doubles.constrainToRange((double) 1, (double) 0, (double) 5)).isEqualTo((double) 1);
assertThat(Doubles.constrainToRange((double) 1, (double) 1, (double) 5)).isEqualTo((double) 1);
assertThat(Doubles.constrainToRange((double) 1, (double) 3, (double) 5)).isEqualTo((double) 3);
assertThat(Doubles.constrainToRange((double) 0, (double) -5, (double) -1))
.isWithin(tolerance)
.of((double) -1);
assertThat(Doubles.constrainToRange((double) 5, (double) 2, (double) 2))
.isWithin(tolerance)
.of((double) 2);
.isEqualTo((double) -1);
assertThat(Doubles.constrainToRange((double) 5, (double) 2, (double) 2)).isEqualTo((double) 2);
try {
Doubles.constrainToRange((double) 1, (double) 3, (double) 2);
fail();
Expand All @@ -276,22 +266,16 @@ public void testConstrainToRange() {
}

public void testConcat() {
assertThat(Arrays.equals(EMPTY, Doubles.concat())).isTrue();
assertThat(Arrays.equals(EMPTY, Doubles.concat(EMPTY))).isTrue();
assertThat(Arrays.equals(EMPTY, Doubles.concat(EMPTY, EMPTY, EMPTY))).isTrue();
assertThat(Arrays.equals(ARRAY1, Doubles.concat(ARRAY1))).isTrue();
assertThat(Doubles.concat()).isEqualTo(EMPTY);
assertThat(Doubles.concat(EMPTY)).isEqualTo(EMPTY);
assertThat(Doubles.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);
assertThat(Doubles.concat(ARRAY1)).isEqualTo(ARRAY1);
assertThat(Doubles.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1);
assertThat(Arrays.equals(ARRAY1, Doubles.concat(EMPTY, ARRAY1, EMPTY))).isTrue();
assertThat(
Arrays.equals(
new double[] {(double) 1, (double) 1, (double) 1},
Doubles.concat(ARRAY1, ARRAY1, ARRAY1)))
.isTrue();
assertThat(
Arrays.equals(
new double[] {(double) 1, (double) 2, (double) 3, (double) 4},
Doubles.concat(ARRAY1, ARRAY234)))
.isTrue();
assertThat(Doubles.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1);
assertThat(Doubles.concat(ARRAY1, ARRAY1, ARRAY1))
.isEqualTo(new double[] {(double) 1, (double) 1, (double) 1});
assertThat(Doubles.concat(ARRAY1, ARRAY234))
.isEqualTo(new double[] {(double) 1, (double) 2, (double) 3, (double) 4});
}

public void testEnsureCapacity() {
Expand Down Expand Up @@ -362,14 +346,14 @@ public void testReverse() {
private static void testReverse(double[] input, double[] expectedOutput) {
input = Arrays.copyOf(input, input.length);
Doubles.reverse(input);
assertThat(Arrays.equals(expectedOutput, input)).isTrue();
assertThat(input).isEqualTo(expectedOutput);
}

private static void testReverse(
double[] input, int fromIndex, int toIndex, double[] expectedOutput) {
input = Arrays.copyOf(input, input.length);
Doubles.reverse(input, fromIndex, toIndex);
assertThat(Arrays.equals(expectedOutput, input)).isTrue();
assertThat(input).isEqualTo(expectedOutput);
}

public void testReverseIndexed() {
Expand Down Expand Up @@ -436,17 +420,17 @@ public void testStringConverterSerialization() {
public void testToArray() {
// need explicit type parameter to avoid javac warning!?
List<Double> none = Arrays.<Double>asList();
assertThat(Arrays.equals(EMPTY, Doubles.toArray(none))).isTrue();
assertThat(Doubles.toArray(none)).isEqualTo(EMPTY);

List<Double> one = Arrays.asList((double) 1);
assertThat(Arrays.equals(ARRAY1, Doubles.toArray(one))).isTrue();
assertThat(Doubles.toArray(one)).isEqualTo(ARRAY1);

double[] array = {(double) 0, (double) 1, Math.PI};

List<Double> three = Arrays.asList((double) 0, (double) 1, Math.PI);
assertThat(Arrays.equals(array, Doubles.toArray(three))).isTrue();
assertThat(Doubles.toArray(three)).isEqualTo(array);

assertThat(Arrays.equals(array, Doubles.toArray(Doubles.asList(array)))).isTrue();
assertThat(Doubles.toArray(Doubles.asList(array))).isEqualTo(array);
}

public void testToArray_threadSafe() {
Expand Down Expand Up @@ -483,19 +467,19 @@ public void testToArray_withConversion() {
List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2);
List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2);

assertThat(Arrays.equals(array, Doubles.toArray(bytes))).isTrue();
assertThat(Arrays.equals(array, Doubles.toArray(shorts))).isTrue();
assertThat(Arrays.equals(array, Doubles.toArray(ints))).isTrue();
assertThat(Arrays.equals(array, Doubles.toArray(floats))).isTrue();
assertThat(Arrays.equals(array, Doubles.toArray(longs))).isTrue();
assertThat(Arrays.equals(array, Doubles.toArray(doubles))).isTrue();
assertThat(Doubles.toArray(bytes)).isEqualTo(array);
assertThat(Doubles.toArray(shorts)).isEqualTo(array);
assertThat(Doubles.toArray(ints)).isEqualTo(array);
assertThat(Doubles.toArray(floats)).isEqualTo(array);
assertThat(Doubles.toArray(longs)).isEqualTo(array);
assertThat(Doubles.toArray(doubles)).isEqualTo(array);
}

public void testAsList_isAView() {
double[] array = {(double) 0, (double) 1};
List<Double> list = Doubles.asList(array);
list.set(0, (double) 2);
assertThat(Arrays.equals(new double[] {(double) 2, (double) 1}, array)).isTrue();
assertThat(array).isEqualTo(new double[] {(double) 2, (double) 1});
array[1] = (double) 3;
assertThat(list).containsExactly((double) 2, (double) 3).inOrder();
}
Expand All @@ -507,7 +491,7 @@ public void testAsList_toArray_roundTrip() {

// Make sure it returned a copy
list.set(0, (double) 4);
assertThat(Arrays.equals(new double[] {(double) 0, (double) 1, (double) 2}, newArray)).isTrue();
assertThat(newArray).isEqualTo(new double[] {(double) 0, (double) 1, (double) 2});
newArray[1] = (double) 5;
assertThat((double) list.get(1)).isEqualTo((double) 1);
}
Expand All @@ -516,11 +500,9 @@ public void testAsList_toArray_roundTrip() {
public void testAsList_subList_toArray_roundTrip() {
double[] array = {(double) 0, (double) 1, (double) 2, (double) 3};
List<Double> list = Doubles.asList(array);
assertThat(
Arrays.equals(
new double[] {(double) 1, (double) 2}, Doubles.toArray(list.subList(1, 3))))
.isTrue();
assertThat(Arrays.equals(new double[] {}, Doubles.toArray(list.subList(2, 2)))).isTrue();
assertThat(Doubles.toArray(list.subList(1, 3)))
.isEqualTo(new double[] {(double) 1, (double) 2});
assertThat(Doubles.toArray(list.subList(2, 2))).isEmpty();
}

public void testAsListEmpty() {
Expand Down
79 changes: 30 additions & 49 deletions android/guava-tests/test/com/google/common/primitives/FloatsTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -240,22 +240,11 @@ public void testMin() {
}

public void testConstrainToRange() {
float tolerance = 1e-10f;
assertThat(Floats.constrainToRange((float) 1, (float) 0, (float) 5))
.isWithin(tolerance)
.of((float) 1);
assertThat(Floats.constrainToRange((float) 1, (float) 1, (float) 5))
.isWithin(tolerance)
.of((float) 1);
assertThat(Floats.constrainToRange((float) 1, (float) 3, (float) 5))
.isWithin(tolerance)
.of((float) 3);
assertThat(Floats.constrainToRange((float) 0, (float) -5, (float) -1))
.isWithin(tolerance)
.of((float) -1);
assertThat(Floats.constrainToRange((float) 5, (float) 2, (float) 2))
.isWithin(tolerance)
.of((float) 2);
assertThat(Floats.constrainToRange((float) 1, (float) 0, (float) 5)).isEqualTo((float) 1);
assertThat(Floats.constrainToRange((float) 1, (float) 1, (float) 5)).isEqualTo((float) 1);
assertThat(Floats.constrainToRange((float) 1, (float) 3, (float) 5)).isEqualTo((float) 3);
assertThat(Floats.constrainToRange((float) 0, (float) -5, (float) -1)).isEqualTo((float) -1);
assertThat(Floats.constrainToRange((float) 5, (float) 2, (float) 2)).isEqualTo((float) 2);
try {
Floats.constrainToRange((float) 1, (float) 3, (float) 2);
fail();
Expand All @@ -264,22 +253,16 @@ public void testConstrainToRange() {
}

public void testConcat() {
assertThat(Arrays.equals(EMPTY, Floats.concat())).isTrue();
assertThat(Arrays.equals(EMPTY, Floats.concat(EMPTY))).isTrue();
assertThat(Arrays.equals(EMPTY, Floats.concat(EMPTY, EMPTY, EMPTY))).isTrue();
assertThat(Arrays.equals(ARRAY1, Floats.concat(ARRAY1))).isTrue();
assertThat(Floats.concat()).isEqualTo(EMPTY);
assertThat(Floats.concat(EMPTY)).isEqualTo(EMPTY);
assertThat(Floats.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);
assertThat(Floats.concat(ARRAY1)).isEqualTo(ARRAY1);
assertThat(Floats.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1);
assertThat(Arrays.equals(ARRAY1, Floats.concat(EMPTY, ARRAY1, EMPTY))).isTrue();
assertThat(
Arrays.equals(
new float[] {(float) 1, (float) 1, (float) 1},
Floats.concat(ARRAY1, ARRAY1, ARRAY1)))
.isTrue();
assertThat(
Arrays.equals(
new float[] {(float) 1, (float) 2, (float) 3, (float) 4},
Floats.concat(ARRAY1, ARRAY234)))
.isTrue();
assertThat(Floats.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1);
assertThat(Floats.concat(ARRAY1, ARRAY1, ARRAY1))
.isEqualTo(new float[] {(float) 1, (float) 1, (float) 1});
assertThat(Floats.concat(ARRAY1, ARRAY234))
.isEqualTo(new float[] {(float) 1, (float) 2, (float) 3, (float) 4});
}

public void testEnsureCapacity() {
Expand Down Expand Up @@ -348,14 +331,14 @@ public void testReverse() {
private static void testReverse(float[] input, float[] expectedOutput) {
input = Arrays.copyOf(input, input.length);
Floats.reverse(input);
assertThat(Arrays.equals(expectedOutput, input)).isTrue();
assertThat(input).isEqualTo(expectedOutput);
}

private static void testReverse(
float[] input, int fromIndex, int toIndex, float[] expectedOutput) {
input = Arrays.copyOf(input, input.length);
Floats.reverse(input, fromIndex, toIndex);
assertThat(Arrays.equals(expectedOutput, input)).isTrue();
assertThat(input).isEqualTo(expectedOutput);
}

public void testReverseIndexed() {
Expand Down Expand Up @@ -415,17 +398,17 @@ public void testStringConverterSerialization() {
public void testToArray() {
// need explicit type parameter to avoid javac warning!?
List<Float> none = Arrays.<Float>asList();
assertThat(Arrays.equals(EMPTY, Floats.toArray(none))).isTrue();
assertThat(Floats.toArray(none)).isEqualTo(EMPTY);

List<Float> one = Arrays.asList((float) 1);
assertThat(Arrays.equals(ARRAY1, Floats.toArray(one))).isTrue();
assertThat(Floats.toArray(one)).isEqualTo(ARRAY1);

float[] array = {(float) 0, (float) 1, (float) 3};

List<Float> three = Arrays.asList((float) 0, (float) 1, (float) 3);
assertThat(Arrays.equals(array, Floats.toArray(three))).isTrue();
assertThat(Floats.toArray(three)).isEqualTo(array);

assertThat(Arrays.equals(array, Floats.toArray(Floats.asList(array)))).isTrue();
assertThat(Floats.toArray(Floats.asList(array))).isEqualTo(array);
}

public void testToArray_threadSafe() {
Expand Down Expand Up @@ -462,19 +445,19 @@ public void testToArray_withConversion() {
List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2);
List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2);

assertThat(Arrays.equals(array, Floats.toArray(bytes))).isTrue();
assertThat(Arrays.equals(array, Floats.toArray(shorts))).isTrue();
assertThat(Arrays.equals(array, Floats.toArray(ints))).isTrue();
assertThat(Arrays.equals(array, Floats.toArray(floats))).isTrue();
assertThat(Arrays.equals(array, Floats.toArray(longs))).isTrue();
assertThat(Arrays.equals(array, Floats.toArray(doubles))).isTrue();
assertThat(Floats.toArray(bytes)).isEqualTo(array);
assertThat(Floats.toArray(shorts)).isEqualTo(array);
assertThat(Floats.toArray(ints)).isEqualTo(array);
assertThat(Floats.toArray(floats)).isEqualTo(array);
assertThat(Floats.toArray(longs)).isEqualTo(array);
assertThat(Floats.toArray(doubles)).isEqualTo(array);
}

public void testAsList_isAView() {
float[] array = {(float) 0, (float) 1};
List<Float> list = Floats.asList(array);
list.set(0, (float) 2);
assertThat(Arrays.equals(new float[] {(float) 2, (float) 1}, array)).isTrue();
assertThat(array).isEqualTo(new float[] {(float) 2, (float) 1});
array[1] = (float) 3;
assertThat(list).containsExactly((float) 2, (float) 3).inOrder();
}
Expand All @@ -486,7 +469,7 @@ public void testAsList_toArray_roundTrip() {

// Make sure it returned a copy
list.set(0, (float) 4);
assertThat(Arrays.equals(new float[] {(float) 0, (float) 1, (float) 2}, newArray)).isTrue();
assertThat(newArray).isEqualTo(new float[] {(float) 0, (float) 1, (float) 2});
newArray[1] = (float) 5;
assertThat((float) list.get(1)).isEqualTo((float) 1);
}
Expand All @@ -495,10 +478,8 @@ public void testAsList_toArray_roundTrip() {
public void testAsList_subList_toArray_roundTrip() {
float[] array = {(float) 0, (float) 1, (float) 2, (float) 3};
List<Float> list = Floats.asList(array);
assertThat(
Arrays.equals(new float[] {(float) 1, (float) 2}, Floats.toArray(list.subList(1, 3))))
.isTrue();
assertThat(Arrays.equals(new float[] {}, Floats.toArray(list.subList(2, 2)))).isTrue();
assertThat(Floats.toArray(list.subList(1, 3))).isEqualTo(new float[] {(float) 1, (float) 2});
assertThat(Floats.toArray(list.subList(2, 2))).isEmpty();
}

public void testAsListEmpty() {
Expand Down
43 changes: 20 additions & 23 deletions android/guava-tests/test/com/google/common/primitives/PrimitivesTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,7 +18,6 @@

import static com.google.common.truth.Truth.assertThat;

import com.google.common.collect.ImmutableSet;
import com.google.common.testing.NullPointerTester;
import java.util.Set;
import junit.framework.TestCase;
Expand Down Expand Up @@ -49,17 +48,16 @@ public void testUnwrap() {
public void testAllPrimitiveTypes() {
Set<Class<?>> primitives = Primitives.allPrimitiveTypes();
assertThat(primitives)
.isEqualTo(
ImmutableSet.<Object>of(
boolean.class,
byte.class,
char.class,
double.class,
float.class,
int.class,
long.class,
short.class,
void.class));
.containsExactly(
boolean.class,
byte.class,
char.class,
double.class,
float.class,
int.class,
long.class,
short.class,
void.class);

try {
primitives.remove(boolean.class);
Expand All @@ -71,17 +69,16 @@ public void testAllPrimitiveTypes() {
public void testAllWrapperTypes() {
Set<Class<?>> wrappers = Primitives.allWrapperTypes();
assertThat(wrappers)
.isEqualTo(
ImmutableSet.<Object>of(
Boolean.class,
Byte.class,
Character.class,
Double.class,
Float.class,
Integer.class,
Long.class,
Short.class,
Void.class));
.containsExactly(
Boolean.class,
Byte.class,
Character.class,
Double.class,
Float.class,
Integer.class,
Long.class,
Short.class,
Void.class);

try {
wrappers.remove(Boolean.class);
Expand Down

0 comments on commit 759c409

Please sign in to comment.