/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.android.camera2.cameratoo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import android.media.Image;
import android.os.Environment;
import android.util.Size;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FilenameFilter;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import com.example.android.camera2.cameratoo.CameraTooActivity;
import org.junit.Test;
public class CameraTooTest {
private <T> void assertComparatorEq(T lhs, T rhs, Comparator<T> rel) {
assertEquals(String.format("%s should be equal to %s", lhs, rhs), rel.compare(lhs, rhs), 0);
assertEquals(String.format("%s should be equal to %s (reverse check)", lhs, rhs),
rel.compare(rhs, lhs), 0);
}
private <T> void assertComparatorLt(T lhs, T rhs, Comparator<T> rel) {
assertTrue(String.format("%s should be less than %s", lhs, rhs), rel.compare(lhs, rhs) < 0);
assertTrue(String.format("%s should be less than %s (reverse check)", lhs, rhs),
rel.compare(rhs, lhs) > 0);
}
@Test
public void compareSizesByArea() {
Size empty = new Size(0, 0), fatAndFlat = new Size(100, 0), tallAndThin = new Size(0, 100);
Size smallSquare = new Size(4, 4), horizRect = new Size(8, 2), vertRect = new Size(2, 8);
Size largeSquare = new Size(5, 5);
Comparator<Size> rel = new CameraTooActivity.CompareSizesByArea();
assertComparatorEq(empty, fatAndFlat, rel);
assertComparatorEq(empty, tallAndThin, rel);
assertComparatorEq(fatAndFlat, empty, rel);
assertComparatorEq(fatAndFlat, tallAndThin, rel);
assertComparatorEq(tallAndThin, empty, rel);
assertComparatorEq(tallAndThin, fatAndFlat, rel);
assertComparatorEq(smallSquare, horizRect, rel);
assertComparatorEq(smallSquare, vertRect, rel);
assertComparatorEq(horizRect, smallSquare, rel);
assertComparatorEq(horizRect, vertRect, rel);
assertComparatorEq(vertRect, smallSquare, rel);
assertComparatorEq(vertRect, horizRect, rel);
assertComparatorLt(empty, smallSquare, rel);
assertComparatorLt(empty, horizRect, rel);
assertComparatorLt(empty, vertRect, rel);
assertComparatorLt(fatAndFlat, smallSquare, rel);
assertComparatorLt(fatAndFlat, horizRect, rel);
assertComparatorLt(fatAndFlat, vertRect, rel);
assertComparatorLt(tallAndThin, smallSquare, rel);
assertComparatorLt(tallAndThin, horizRect, rel);
assertComparatorLt(tallAndThin, vertRect, rel);
assertComparatorLt(empty, largeSquare, rel);
assertComparatorLt(fatAndFlat, largeSquare, rel);
assertComparatorLt(tallAndThin, largeSquare, rel);
assertComparatorLt(smallSquare, largeSquare, rel);
assertComparatorLt(horizRect, largeSquare, rel);
assertComparatorLt(vertRect, largeSquare, rel);
}
private void assertOptimalSize(Size[] options, int minWidth, int minHeight, Size expected) {
Size verdict = CameraTooActivity.chooseBigEnoughSize(options, minWidth, minHeight);
assertEquals(String.format("Expected optimal size %s but got %s", expected, verdict),
verdict, expected);
}
@Test
public void chooseBigEnoughSize() {
Size empty = new Size(0, 0), fatAndFlat = new Size(100, 0), tallAndThin = new Size(0, 100);
Size smallSquare = new Size(4, 4), horizRect = new Size(8, 2), vertRect = new Size(2, 8);
Size largeSquare = new Size(5, 5);
Size[] siz =
{ empty, fatAndFlat, tallAndThin, smallSquare, horizRect, vertRect, largeSquare };
assertOptimalSize(siz, 0, 0, empty);
assertOptimalSize(siz, 1, 0, fatAndFlat);
assertOptimalSize(siz, 0, 1, tallAndThin);
assertOptimalSize(siz, 4, 4, smallSquare);
assertOptimalSize(siz, 1, 1, smallSquare);
assertOptimalSize(siz, 2, 1, smallSquare);
assertOptimalSize(siz, 1, 2, smallSquare);
assertOptimalSize(siz, 3, 4, smallSquare);
assertOptimalSize(siz, 4, 3, smallSquare);
assertOptimalSize(siz, 8, 2, horizRect);
assertOptimalSize(siz, 5, 1, horizRect);
assertOptimalSize(siz, 5, 2, horizRect);
assertOptimalSize(siz, 2, 8, vertRect);
assertOptimalSize(siz, 1, 5, vertRect);
assertOptimalSize(siz, 2, 5, vertRect);
assertOptimalSize(siz, 5, 5, largeSquare);
assertOptimalSize(siz, 3, 5, largeSquare);
assertOptimalSize(siz, 5, 3, largeSquare);
}
private static final FilenameFilter OUTPUT_FILE_DECIDER = new FilenameFilter() {
@Override
public boolean accept(File dir, String filename) {
return filename.indexOf("cameratoo") == 0 &&
filename.indexOf(".jpg") == filename.length() - ".jpg".length();
}};
private static <T> Set<T> newlyAddedElements(Set<T> before, Set<T> after) {
Set<T> result = new HashSet<T>(after);
result.removeAll(before);
return result;
}
@Test
public void capturedImageSaver() throws FileNotFoundException, IOException {
ByteBuffer buf = ByteBuffer.allocate(25);
for(int index = 0; index < buf.capacity(); ++index)
buf.put(index, (byte) index);
Image.Plane plane = mock(Image.Plane.class);
when(plane.getBuffer()).thenReturn(buf);
when(plane.getPixelStride()).thenReturn(1);
when(plane.getRowStride()).thenReturn(5);
Image.Plane[] onlyPlaneThatMatters = { plane };
Image image = mock(Image.class);
when(image.getPlanes()).thenReturn(onlyPlaneThatMatters);
when(image.getWidth()).thenReturn(5);
when(image.getHeight()).thenReturn(5);
File picturesFolder =
Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
Set<File> preListing =
new HashSet<File>(Arrays.asList(picturesFolder.listFiles(OUTPUT_FILE_DECIDER)));
CameraTooActivity.CapturedImageSaver saver =
new CameraTooActivity.CapturedImageSaver(image);
saver.run();
Set<File> postListing =
new HashSet<File>(Arrays.asList(picturesFolder.listFiles(OUTPUT_FILE_DECIDER)));
Set<File> newFiles = newlyAddedElements(preListing, postListing);
assertEquals(newFiles.size(), 1);
File picture = newFiles.iterator().next();
FileInputStream istream = new FileInputStream(picture);
for(int count = 0; count < buf.capacity(); ++count) {
assertEquals(istream.read(), buf.get(count));
}
assertEquals(istream.read(), -1);
assertTrue(picture.delete());
}
}
|
