1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.mediaframeworktest.unit;
18 
19 import android.test.suitebuilder.annotation.SmallTest;
20 import android.util.Range;
21 import android.util.Rational;
22 
23 /**
24  * <pre>
25  * adb shell am instrument \
26  *      -e class 'com.android.mediaframeworktest.unit.RangeTest' \
27  *      -w com.android.mediaframeworktest/.MediaFrameworkUnitTestRunner
28  * </pre>
29  */
30 public class RangeTest extends junit.framework.TestCase {
31 
32     @SmallTest
testConstructor()33     public void testConstructor() {
34         // Trivial, same range
35         Range<Integer> intRange = new Range<Integer>(1, 1);
36 
37         assertLower(intRange, 1);
38         assertUpper(intRange, 1);
39 
40         // Different values in range
41         Range<Integer> intRange2 = new Range<Integer>(100, 200);
42         assertLower(intRange2, 100);
43         assertUpper(intRange2, 200);
44 
45         Range<Float> floatRange = new Range<Float>(Float.NEGATIVE_INFINITY,
46                 Float.POSITIVE_INFINITY);
47         assertLower(floatRange, Float.NEGATIVE_INFINITY);
48         assertUpper(floatRange, Float.POSITIVE_INFINITY);
49     }
50 
51     @SmallTest
testIllegalValues()52     public void testIllegalValues() {
53         // Test NPEs
54         try {
55             new Range<Integer>(null, null);
56             fail("Expected exception to be thrown for (null, null)");
57         } catch (NullPointerException e) {
58             // OK: both args are null
59         }
60 
61         try {
62             new Range<Integer>(null, 0);
63             fail("Expected exception to be thrown for (null, 0)");
64         } catch (NullPointerException e) {
65             // OK: left arg is null
66         }
67 
68         try {
69             new Range<Integer>(0, null);
70             fail("Expected exception to be thrown for (0, null)");
71         } catch (NullPointerException e) {
72             // OK: right arg is null
73         }
74 
75         // Test IAEs
76 
77         try {
78             new Range<Integer>(50, -50);
79             fail("Expected exception to be thrown for (50, -50)");
80         } catch (IllegalArgumentException e) {
81             // OK: 50 > -50 so it fails
82         }
83 
84         try {
85             new Range<Float>(0.0f, Float.NEGATIVE_INFINITY);
86             fail("Expected exception to be thrown for (0.0f, -Infinity)");
87         } catch (IllegalArgumentException e) {
88             // OK: 0.0f is > NEGATIVE_INFINITY, so it fails
89         }
90     }
91 
92     @SmallTest
testEquals()93     public void testEquals() {
94         Range<Float> oneHalf = Range.create(1.0f, 2.0f);
95         Range<Float> oneHalf2 = new Range<Float>(1.0f, 2.0f);
96         assertEquals(oneHalf, oneHalf2);
97         assertHashCodeEquals(oneHalf, oneHalf2);
98 
99         Range<Float> twoThirds = new Range<Float>(2.0f, 3.0f);
100         Range<Float> twoThirds2 = Range.create(2.0f, 3.0f);
101         assertEquals(twoThirds, twoThirds2);
102         assertHashCodeEquals(twoThirds, twoThirds2);
103 
104         Range<Rational> negativeOneTenthPositiveOneTenth =
105                 new Range<Rational>(new Rational(-1, 10), new Rational(1, 10));
106         Range<Rational> negativeOneTenthPositiveOneTenth2 =
107                 Range.create(new Rational(-1, 10), new Rational(1, 10));
108         assertEquals(negativeOneTenthPositiveOneTenth, negativeOneTenthPositiveOneTenth2);
109         assertHashCodeEquals(negativeOneTenthPositiveOneTenth, negativeOneTenthPositiveOneTenth2);
110     }
111 
112     @SmallTest
testInRange()113     public void testInRange() {
114         Range<Integer> hundredOneTwo = Range.create(100, 200);
115 
116         assertInRange(hundredOneTwo, 100);
117         assertInRange(hundredOneTwo, 200);
118         assertInRange(hundredOneTwo, 150);
119         assertOutOfRange(hundredOneTwo, 99);
120         assertOutOfRange(hundredOneTwo, 201);
121         assertOutOfRange(hundredOneTwo, 100000);
122 
123         Range<Float> infinities = Range.create(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY);
124 
125         assertInRange(infinities, Float.NEGATIVE_INFINITY);
126         assertInRange(infinities, Float.POSITIVE_INFINITY);
127         assertInRange(infinities, 0.0f);
128         assertOutOfRange(infinities, Float.NaN);
129 
130         Range<Rational> negativeOneTenthPositiveOneTenth =
131                 new Range<Rational>(new Rational(-1, 10), new Rational(1, 10));
132         assertInRange(negativeOneTenthPositiveOneTenth, new Rational(-1, 10));
133         assertInRange(negativeOneTenthPositiveOneTenth, new Rational(1, 10));
134         assertInRange(negativeOneTenthPositiveOneTenth, Rational.ZERO);
135         assertOutOfRange(negativeOneTenthPositiveOneTenth, new Rational(-100, 1));
136         assertOutOfRange(negativeOneTenthPositiveOneTenth, new Rational(100, 1));
137     }
138 
assertInRange(Range<T> object, T needle)139     private static <T extends Comparable<? super T>> void assertInRange(Range<T> object, T needle) {
140         assertAction("in-range", object, needle, true, object.contains(needle));
141     }
142 
assertOutOfRange(Range<T> object, T needle)143     private static <T extends Comparable<? super T>> void assertOutOfRange(Range<T> object,
144             T needle) {
145         assertAction("out-of-range", object, needle, false, object.contains(needle));
146     }
147 
assertUpper(Range<T> object, T expected)148     private static <T extends Comparable<? super T>> void assertUpper(Range<T> object, T expected) {
149         assertAction("upper", object, expected, object.getUpper());
150     }
151 
assertLower(Range<T> object, T expected)152     private static <T extends Comparable<? super T>> void assertLower(Range<T> object, T expected) {
153         assertAction("lower", object, expected, object.getLower());
154     }
155 
assertAction(String action, T object, T2 expected, T2 actual)156     private static <T, T2> void assertAction(String action, T object, T2 expected,
157             T2 actual) {
158         assertEquals("Expected " + object + " " + action + " to be ",
159                 expected, actual);
160     }
161 
assertAction(String action, T object, T2 needle, boolean expected, boolean actual)162     private static <T, T2> void assertAction(String action, T object, T2 needle, boolean expected,
163             boolean actual) {
164         String expectedMessage = expected ? action : ("not " + action);
165         assertEquals("Expected " + needle + " to be " + expectedMessage + " of " + object,
166                 expected, actual);
167     }
168 
assertHashCodeEquals( Range<T> left, Range<T> right)169     private static <T extends Comparable<? super T>> void assertHashCodeEquals(
170             Range<T> left, Range<T> right) {
171         assertEquals("Left hash code for " + left +
172                 " expected to be equal to right hash code for " + right,
173                 left.hashCode(), right.hashCode());
174     }
175 }
176