> boolean expectInRange(String msg, T value,
T min, T max) {
return expectTrue(msg + String.format(", value " + value.toString()
+ " is out of range [%s, %s]",
min.toString(), max.toString()),
value.compareTo(max)<= 0 && value.compareTo(min) >= 0);
}
/**
* Check that two metering region arrays are similar enough by ensuring that each of their width,
* height, and all corners are within {@code errorPercent} of each other.
*
* Note that the length of the arrays must be the same, and each weight must be the same
* as well. We assume the order is also equivalent.
*
* At most 1 error per each dissimilar metering region is collected.
*
* @param msg Message to be logged
* @param expected The reference 'expected' values to be used to check against
* @param actual The actual values that were received
* @param errorPercent Within how many percent the components should be
*
* @return {@code true} if all expects passed, {@code false} otherwise
*/
public boolean expectMeteringRegionsAreSimilar(String msg,
MeteringRectangle[] expected, MeteringRectangle[] actual,
float errorPercent) {
String expectedActualMsg = String.format("expected (%s), actual (%s)",
Arrays.deepToString(expected), Arrays.deepToString(actual));
String differentSizesMsg = String.format(
"%s: rect lists are different sizes; %s",
msg, expectedActualMsg);
String differentWeightsMsg = String.format(
"%s: rect weights are different; %s",
msg, expectedActualMsg);
if (!expectTrue(differentSizesMsg, actual != null)) {
return false;
}
if (!expectEquals(differentSizesMsg, expected.length, actual.length)) return false;
boolean succ = true;
for (int i = 0; i < expected.length; ++i) {
if (i < actual.length) {
// Avoid printing multiple errors for the same rectangle
if (!expectRectsAreSimilar(
msg, expected[i].getRect(), actual[i].getRect(), errorPercent)) {
succ = false;
continue;
}
if (!expectEquals(differentWeightsMsg,
expected[i].getMeteringWeight(), actual[i].getMeteringWeight())) {
succ = false;
continue;
}
}
}
return succ;
}
/**
* Check that two rectangles are similar enough by ensuring that their width, height,
* and all corners are within {@code errorPercent} of each other.
*
* Only the first error is collected, to avoid spamming several error messages when
* the rectangle is hugely dissimilar.
*
* @param msg Message to be logged
* @param expected The reference 'expected' value to be used to check against
* @param actual The actual value that was received
* @param errorPercent Within how many percent the components should be
*
* @return {@code true} if all expects passed, {@code false} otherwise
*/
public boolean expectRectsAreSimilar(String msg, Rect expected, Rect actual,
float errorPercent) {
String formattedMsg = String.format("%s: rects are not similar enough; expected (%s), " +
"actual (%s), error percent (%s), reason: ",
msg, expected, actual, errorPercent);
if (!expectSimilarValues(
formattedMsg, "too wide", "too narrow", actual.width(), expected.width(),
errorPercent)) return false;
if (!expectSimilarValues(
formattedMsg, "too tall", "too short", actual.height(), expected.height(),
errorPercent)) return false;
if (!expectSimilarValues(
formattedMsg, "left pt too right", "left pt too left", actual.left, expected.left,
errorPercent)) return false;
if (!expectSimilarValues(
formattedMsg, "right pt too right", "right pt too left",
actual.right, expected.right, errorPercent)) return false;
if (!expectSimilarValues(
formattedMsg, "top pt too low", "top pt too high", actual.top, expected.top,
errorPercent)) return false;
if (!expectSimilarValues(
formattedMsg, "bottom pt too low", "bottom pt too high", actual.top, expected.top,
errorPercent)) return false;
return true;
}
/**
* Check that two sizes are similar enough by ensuring that their width and height
* are within {@code errorPercent} of each other.
*
* Only the first error is collected, to avoid spamming several error messages when
* the rectangle is hugely dissimilar.
*
* @param msg Message to be logged
* @param expected The reference 'expected' value to be used to check against
* @param actual The actual value that was received
* @param errorPercent Within how many percent the components should be
*
* @return {@code true} if all expects passed, {@code false} otherwise
*/
public boolean expectSizesAreSimilar(String msg, Size expected, Size actual,
float errorPercent) {
String formattedMsg = String.format("%s: rects are not similar enough; expected (%s), " +
"actual (%s), error percent (%s), reason: ",
msg, expected, actual, errorPercent);
if (!expectSimilarValues(
formattedMsg, "too wide", "too narrow", actual.getWidth(), expected.getWidth(),
errorPercent)) return false;
if (!expectSimilarValues(
formattedMsg, "too tall", "too short", actual.getHeight(), expected.getHeight(),
errorPercent)) return false;
return true;
}
/**
* Check that the rectangle is centered within a certain tolerance of {@code errorPercent},
* with respect to the {@code bounds} bounding rectangle.
*
* @param msg Message to be logged
* @param expectedBounds The width/height of the bounding rectangle
* @param actual The actual value that was received
* @param errorPercent Within how many percent the centering should be
*/
public void expectRectCentered(String msg, Size expectedBounds, Rect actual,
float errorPercent) {
String formattedMsg = String.format("%s: rect should be centered; expected bounds (%s), " +
"actual (%s), error percent (%s), reason: ",
msg, expectedBounds, actual, errorPercent);
int centerBoundX = expectedBounds.getWidth() / 2;
int centerBoundY = expectedBounds.getHeight() / 2;
expectSimilarValues(
formattedMsg, "too low", "too high", actual.centerY(), centerBoundY,
errorPercent);
expectSimilarValues(
formattedMsg, "too right", "too left", actual.centerX(), centerBoundX,
errorPercent);
}
private boolean expectSimilarValues(
String formattedMsg, String tooSmall, String tooLarge, int actualValue,
int expectedValue, float errorPercent) {
boolean succ = true;
succ = expectTrue(formattedMsg + tooLarge,
actualValue <= (expectedValue * (1.0f + errorPercent))) && succ;
succ = expectTrue(formattedMsg + tooSmall,
actualValue >= (expectedValue * (1.0f - errorPercent))) && succ;
return succ;
}
public void expectNotNull(String msg, Object obj) {
checkThat(msg, obj, CoreMatchers.notNullValue());
}
public void expectNull(String msg, Object obj) {
if (obj != null) {
addMessage(msg);
}
}
/**
* Check if the values in the array are monotonically increasing (decreasing) and not all
* equal.
*
* @param array The array of values to be checked
* @param ascendingOrder The monotonicity ordering to be checked with
*/
public > void checkArrayMonotonicityAndNotAllEqual(T[] array,
boolean ascendingOrder) {
String orderMsg = ascendingOrder ? ("increasing order") : ("decreasing order");
for (int i = 0; i < array.length - 1; i++) {
int compareResult = array[i + 1].compareTo(array[i]);
boolean condition = compareResult >= 0;
if (!ascendingOrder) {
condition = compareResult <= 0;
}
expectTrue(String.format("Adjacent values (%s and %s) %s monotonicity is broken",
array[i].toString(), array[i + 1].toString(), orderMsg), condition);
}
expectTrue("All values of this array are equal: " + array[0].toString(),
array[0].compareTo(array[array.length - 1]) != 0);
}
/**
* Check if the key value is not null and return the value.
*
* @param characteristics The {@link CameraCharacteristics} to get the key from.
* @param key The {@link CameraCharacteristics} key to be checked.
*
* @return The value of the key.
*/
public T expectKeyValueNotNull(CameraCharacteristics characteristics,
CameraCharacteristics.Key key) {
T value = characteristics.get(key);
if (value == null) {
addMessage("Key " + key.getName() + " shouldn't be null");
}
return value;
}
/**
* Check if the key value is not null and return the value.
*
* @param request The {@link CaptureRequest} to get the key from.
* @param key The {@link CaptureRequest} key to be checked.
*
* @return The value of the key.
*/
public T expectKeyValueNotNull(CaptureRequest request,
CaptureRequest.Key key) {
T value = request.get(key);
if (value == null) {
addMessage("Key " + key.getName() + " shouldn't be null");
}
return value;
}
/**
* Check if the key value is not null and return the value.
*
* @param request The {@link CaptureRequest#Builder} to get the key from.
* @param key The {@link CaptureRequest} key to be checked.
* @return The value of the key.
*/
public T expectKeyValueNotNull(Builder request, CaptureRequest.Key key) {
T value = request.get(key);
if (value == null) {
addMessage("Key " + key.getName() + " shouldn't be null");
}
return value;
}
/**
* Check if the key value is not null and return the value.
*
* @param result The {@link CaptureResult} to get the key from.
* @param key The {@link CaptureResult} key to be checked.
* @return The value of the key.
*/
public T expectKeyValueNotNull(CaptureResult result, CaptureResult.Key key) {
return expectKeyValueNotNull("", result, key);
}
/**
* Check if the key value is not null and return the value.
*
* @param msg The message to be logged.
* @param result The {@link CaptureResult} to get the key from.
* @param key The {@link CaptureResult} key to be checked.
* @return The value of the key.
*/
public T expectKeyValueNotNull(String msg, CaptureResult result, CaptureResult.Key key) {
T value = result.get(key);
if (value == null) {
addMessage(msg + " Key " + key.getName() + " shouldn't be null");
}
return value;
}
/**
* Check if the key is non-null and the value is not equal to target.
*
* @param request The The {@link CaptureRequest#Builder} to get the key from.
* @param key The {@link CaptureRequest} key to be checked.
* @param expected The expected value of the CaptureRequest key.
*/
public void expectKeyValueNotEquals(
Builder request, CaptureRequest.Key key, T expected) {
if (request == null || key == null || expected == null) {
throw new IllegalArgumentException("request, key and expected shouldn't be null");
}
T value;
if ((value = expectKeyValueNotNull(request, key)) == null) {
return;
}
String reason = "Key " + key.getName() + " shouldn't have value " + value.toString();
checkThat(reason, value, CoreMatchers.not(expected));
}
/**
* Check if the key is non-null and the value is not equal to target.
*
* @param result The {@link CaptureResult} to get the key from.
* @param key The {@link CaptureResult} key to be checked.
* @param expected The expected value of the CaptureResult key.
*/
public void expectKeyValueNotEquals(
CaptureResult result, CaptureResult.Key key, T expected) {
if (result == null || key == null || expected == null) {
throw new IllegalArgumentException("result, key and expected shouldn't be null");
}
T value;
if ((value = expectKeyValueNotNull(result, key)) == null) {
return;
}
String reason = "Key " + key.getName() + " shouldn't have value " + value.toString();
checkThat(reason, value, CoreMatchers.not(expected));
}
/**
* Check if the value is non-null and the value is equal to target.
*
* @param result The {@link CaptureResult} to lookup the value in.
* @param key The {@link CaptureResult} key to be checked.
* @param expected The expected value of the {@link CaptureResult} key.
*/
public void expectKeyValueEquals(CaptureResult result, CaptureResult.Key key,
T expected) {
if (result == null || key == null || expected == null) {
throw new IllegalArgumentException("request, key and expected shouldn't be null");
}
T value;
if ((value = expectKeyValueNotNull(result, key)) == null) {
return;
}
String reason = "Key " + key.getName() + " value " + value.toString()
+ " doesn't match the expected value " + expected.toString();
checkThat(reason, value, CoreMatchers.equalTo(expected));
}
/**
* Check if the key is non-null and the value is equal to target.
*
* Only check non-null if the target is null.
*
* @param request The The {@link CaptureRequest#Builder} to get the key from.
* @param key The {@link CaptureRequest} key to be checked.
* @param expected The expected value of the CaptureRequest key.
*/
public void expectKeyValueEquals(Builder request, CaptureRequest.Key key, T expected) {
if (request == null || key == null || expected == null) {
throw new IllegalArgumentException("request, key and expected shouldn't be null");
}
T value;
if ((value = expectKeyValueNotNull(request, key)) == null) {
return;
}
String reason = "Key " + key.getName() + " value " + value.toString()
+ " doesn't match the expected value " + expected.toString();
checkThat(reason, value, CoreMatchers.equalTo(expected));
}
/**
* Check if the key is non-null, and the key value is greater than the expected value.
*
* @param result {@link CaptureResult} to check.
* @param key The {@link CaptureResult} key to be checked.
* @param expected The expected to be compared to the value for the given key.
*/
public > void expectKeyValueGreaterOrEqual(
CaptureResult result, CaptureResult.Key key, T expected) {
T value;
if ((value = expectKeyValueNotNull(result, key)) == null) {
return;
}
expectGreaterOrEqual(key.getName(), expected, value);
}
/**
* Check if the key is non-null, and the key value is greater than the expected value.
*
* @param characteristics {@link CameraCharacteristics} to check.
* @param key The {@link CameraCharacteristics} key to be checked.
* @param expected The expected to be compared to the value for the given key.
*/
public > void expectKeyValueGreaterThan(
CameraCharacteristics characteristics, CameraCharacteristics.Key key, T expected) {
T value;
if ((value = expectKeyValueNotNull(characteristics, key)) == null) {
return;
}
expectGreater(key.getName(), expected, value);
}
/**
* Check if the key is non-null, and the key value is in the expected range.
*
* @param characteristics {@link CameraCharacteristics} to check.
* @param key The {@link CameraCharacteristics} key to be checked.
* @param min The min value of the range
* @param max The max value of the range
*/
public > void expectKeyValueInRange(
CameraCharacteristics characteristics, CameraCharacteristics.Key key, T min, T max) {
T value;
if ((value = expectKeyValueNotNull(characteristics, key)) == null) {
return;
}
expectInRange(key.getName(), value, min, max);
}
/**
* Check if the key is non-null, and the key value is one of the expected values.
*
* @param characteristics {@link CameraCharacteristics} to check.
* @param key The {@link CameraCharacteristics} key to be checked.
* @param expected The expected values for the given key.
*/
public void expectKeyValueIsIn(CameraCharacteristics characteristics,
CameraCharacteristics.Key key, T... expected) {
T value = expectKeyValueNotNull(characteristics, key);
if (value == null) {
return;
}
String reason = "Key " + key.getName() + " value " + value
+ " isn't one of the expected values " + Arrays.deepToString(expected);
expectContains(reason, expected, value);
}
/**
* Check if the key is non-null, and the key value is one of the expected values.
*
* @param request The The {@link CaptureRequest#Builder} to get the key from.
* @param key The {@link CaptureRequest} key to be checked.
* @param expected The expected values of the CaptureRequest key.
*/
public void expectKeyValueIsIn(Builder request, CaptureRequest.Key key, T... expected) {
T value = expectKeyValueNotNull(request, key);
if (value == null) {
return;
}
String reason = "Key " + key.getName() + " value " + value
+ " isn't one of the expected values " + Arrays.deepToString(expected);
expectContains(reason, expected, value);
}
/**
* Check if the key is non-null, and the key value contains the expected element.
*
* @param characteristics {@link CameraCharacteristics} to check.
* @param key The {@link CameraCharacteristics} key to be checked.
* @param expected The expected element to be contained in the value for the given key.
*/
public void expectKeyValueContains(CameraCharacteristics characteristics,
CameraCharacteristics.Key key, T expected) {
T[] value;
if ((value = expectKeyValueNotNull(characteristics, key)) == null) {
return;
}
String reason = "Key " + key.getName() + " value " + value
+ " doesn't contain the expected value " + expected;
expectContains(reason, value, expected);
}
/**
* Check if the key is non-null, and the key value contains the expected element.
*
* @param characteristics {@link CameraCharacteristics} to check.
* @param key The {@link CameraCharacteristics} key to be checked.
* @param expected The expected element to be contained in the value for the given key.
*/
public void expectKeyValueContains(CameraCharacteristics characteristics,
CameraCharacteristics.Key key, int expected) {
int[] value;
if ((value = expectKeyValueNotNull(characteristics, key)) == null) {
return;
}
String reason = "Key " + key.getName() + " value " + value
+ " doesn't contain the expected value " + expected;
expectContains(reason, value, expected);
}
/**
* Check if the key is non-null, and the key value contains the expected element.
*
* @param characteristics {@link CameraCharacteristics} to check.
* @param key The {@link CameraCharacteristics} key to be checked.
* @param expected The expected element to be contained in the value for the given key.
*/
public void expectKeyValueContains(CameraCharacteristics characteristics,
CameraCharacteristics.Key key, boolean expected) {
boolean[] value;
if ((value = expectKeyValueNotNull(characteristics, key)) == null) {
return;
}
String reason = "Key " + key.getName() + " value " + value
+ " doesn't contain the expected value " + expected;
expectContains(reason, value, expected);
}
/**
* Check if the {@code values} array contains the expected element.
*
* @param reason reason to print for failure.
* @param values array to check for membership in.
* @param expected the value to check.
*/
public void expectContains(String reason, T[] values, T expected) {
if (values == null) {
throw new NullPointerException();
}
checkThat(reason, expected, InMatcher.in(values));
}
public void expectContains(T[] values, T expected) {
String reason = "Expected value " + expected
+ " is not contained in the given values " + values;
expectContains(reason, values, expected);
}
/**
* Specialize {@link InMatcher} class for integer primitive array.
*/
private static class IntInMatcher extends InMatcher {
public IntInMatcher(int[] values) {
Preconditions.checkNotNull("values", values);
mValues = new ArrayList<>(values.length);
for (int i : values) {
mValues.add(i);
}
}
}
/**
* Check if the {@code values} array contains the expected element.
*
* Specialized for primitive int arrays
*
* @param reason reason to print for failure.
* @param values array to check for membership in.
* @param expected the value to check.
*/
public void expectContains(String reason, int[] values, int expected) {
if (values == null) {
throw new NullPointerException();
}
checkThat(reason, expected, new IntInMatcher(values));
}
public void expectContains(int[] values, int expected) {
String reason = "Expected value " + expected
+ " is not contained in the given values " + values;
expectContains(reason, values, expected);
}
/**
* Specialize {@link BooleanInMatcher} class for boolean primitive array.
*/
private static class BooleanInMatcher extends InMatcher {
public BooleanInMatcher(boolean[] values) {
Preconditions.checkNotNull("values", values);
mValues = new ArrayList<>(values.length);
for (boolean i : values) {
mValues.add(i);
}
}
}
/**
* Check if the {@code values} array contains the expected element.
*
* Specialized for primitive boolean arrays
*
* @param reason reason to print for failure.
* @param values array to check for membership in.
* @param expected the value to check.
*/
public void expectContains(String reason, boolean[] values, boolean expected) {
if (values == null) {
throw new NullPointerException();
}
checkThat(reason, expected, new BooleanInMatcher(values));
}
/**
* Check if the {@code values} array contains the expected element.
*
* Specialized for primitive boolean arrays
*
* @param values array to check for membership in.
* @param expected the value to check.
*/
public void expectContains(boolean[] values, boolean expected) {
String reason = "Expected value " + expected
+ " is not contained in the given values " + values;
expectContains(reason, values, expected);
}
/**
* Check if the element inside of the list are unique.
*
* @param msg The message to be logged
* @param list The list of values to be checked
*/
public void expectValuesUnique(String msg, List list) {
Set sizeSet = new HashSet(list);
expectTrue(msg + " each element must be distinct", sizeSet.size() == list.size());
}
public void expectImageProperties(String msg, Image image, int format, Size size,
long timestampNs) {
expectEquals(msg + "Image format is wrong.", image.getFormat(), format);
expectEquals(msg + "Image width is wrong.", image.getWidth(), size.getWidth());
expectEquals(msg + "Image height is wrong.", image.getHeight(), size.getHeight());
expectEquals(msg + "Image timestamp is wrong.", image.getTimestamp(), timestampNs);
}
}