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.util.Range;
20 import android.util.Rational;
21 
22 import androidx.test.filters.SmallTest;
23 
24 /**
25  * <pre>
26  * adb shell am instrument \
27  *      -e class 'com.android.mediaframeworktest.unit.RangeTest' \
28  *      -w com.android.mediaframeworktest/.MediaFrameworkUnitTestRunner
29  * </pre>
30  */
31 public class RangeTest extends junit.framework.TestCase {
32 
33     @SmallTest
testConstructor()34     public void testConstructor() {
35         // Trivial, same range
36         Range<Integer> intRange = new Range<Integer>(1, 1);
37 
38         assertLower(intRange, 1);
39         assertUpper(intRange, 1);
40 
41         // Different values in range
42         Range<Integer> intRange2 = new Range<Integer>(100, 200);
43         assertLower(intRange2, 100);
44         assertUpper(intRange2, 200);
45 
46         Range<Float> floatRange = new Range<Float>(Float.NEGATIVE_INFINITY,
47                 Float.POSITIVE_INFINITY);
48         assertLower(floatRange, Float.NEGATIVE_INFINITY);
49         assertUpper(floatRange, Float.POSITIVE_INFINITY);
50     }
51 
52     @SmallTest
testIllegalValues()53     public void testIllegalValues() {
54         // Test NPEs
55         try {
56             new Range<Integer>(null, null);
57             fail("Expected exception to be thrown for (null, null)");
58         } catch (NullPointerException e) {
59             // OK: both args are null
60         }
61 
62         try {
63             new Range<Integer>(null, 0);
64             fail("Expected exception to be thrown for (null, 0)");
65         } catch (NullPointerException e) {
66             // OK: left arg is null
67         }
68 
69         try {
70             new Range<Integer>(0, null);
71             fail("Expected exception to be thrown for (0, null)");
72         } catch (NullPointerException e) {
73             // OK: right arg is null
74         }
75 
76         // Test IAEs
77 
78         try {
79             new Range<Integer>(50, -50);
80             fail("Expected exception to be thrown for (50, -50)");
81         } catch (IllegalArgumentException e) {
82             // OK: 50 > -50 so it fails
83         }
84 
85         try {
86             new Range<Float>(0.0f, Float.NEGATIVE_INFINITY);
87             fail("Expected exception to be thrown for (0.0f, -Infinity)");
88         } catch (IllegalArgumentException e) {
89             // OK: 0.0f is > NEGATIVE_INFINITY, so it fails
90         }
91     }
92 
93     @SmallTest
testEquals()94     public void testEquals() {
95         Range<Float> oneHalf = Range.create(1.0f, 2.0f);
96         Range<Float> oneHalf2 = new Range<Float>(1.0f, 2.0f);
97         assertEquals(oneHalf, oneHalf2);
98         assertHashCodeEquals(oneHalf, oneHalf2);
99 
100         Range<Float> twoThirds = new Range<Float>(2.0f, 3.0f);
101         Range<Float> twoThirds2 = Range.create(2.0f, 3.0f);
102         assertEquals(twoThirds, twoThirds2);
103         assertHashCodeEquals(twoThirds, twoThirds2);
104 
105         Range<Rational> negativeOneTenthPositiveOneTenth =
106                 new Range<Rational>(new Rational(-1, 10), new Rational(1, 10));
107         Range<Rational> negativeOneTenthPositiveOneTenth2 =
108                 Range.create(new Rational(-1, 10), new Rational(1, 10));
109         assertEquals(negativeOneTenthPositiveOneTenth, negativeOneTenthPositiveOneTenth2);
110         assertHashCodeEquals(negativeOneTenthPositiveOneTenth, negativeOneTenthPositiveOneTenth2);
111     }
112 
113     @SmallTest
testInRange()114     public void testInRange() {
115         Range<Integer> hundredOneTwo = Range.create(100, 200);
116 
117         assertInRange(hundredOneTwo, 100);
118         assertInRange(hundredOneTwo, 200);
119         assertInRange(hundredOneTwo, 150);
120         assertOutOfRange(hundredOneTwo, 99);
121         assertOutOfRange(hundredOneTwo, 201);
122         assertOutOfRange(hundredOneTwo, 100000);
123 
124         Range<Float> infinities = Range.create(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY);
125 
126         assertInRange(infinities, Float.NEGATIVE_INFINITY);
127         assertInRange(infinities, Float.POSITIVE_INFINITY);
128         assertInRange(infinities, 0.0f);
129         assertOutOfRange(infinities, Float.NaN);
130 
131         Range<Rational> negativeOneTenthPositiveOneTenth =
132                 new Range<Rational>(new Rational(-1, 10), new Rational(1, 10));
133         assertInRange(negativeOneTenthPositiveOneTenth, new Rational(-1, 10));
134         assertInRange(negativeOneTenthPositiveOneTenth, new Rational(1, 10));
135         assertInRange(negativeOneTenthPositiveOneTenth, Rational.ZERO);
136         assertOutOfRange(negativeOneTenthPositiveOneTenth, new Rational(-100, 1));
137         assertOutOfRange(negativeOneTenthPositiveOneTenth, new Rational(100, 1));
138     }
139 
assertInRange(Range<T> object, T needle)140     private static <T extends Comparable<? super T>> void assertInRange(Range<T> object, T needle) {
141         assertAction("in-range", object, needle, true, object.contains(needle));
142     }
143 
assertOutOfRange(Range<T> object, T needle)144     private static <T extends Comparable<? super T>> void assertOutOfRange(Range<T> object,
145             T needle) {
146         assertAction("out-of-range", object, needle, false, object.contains(needle));
147     }
148 
assertUpper(Range<T> object, T expected)149     private static <T extends Comparable<? super T>> void assertUpper(Range<T> object, T expected) {
150         assertAction("upper", object, expected, object.getUpper());
151     }
152 
assertLower(Range<T> object, T expected)153     private static <T extends Comparable<? super T>> void assertLower(Range<T> object, T expected) {
154         assertAction("lower", object, expected, object.getLower());
155     }
156 
assertAction(String action, T object, T2 expected, T2 actual)157     private static <T, T2> void assertAction(String action, T object, T2 expected,
158             T2 actual) {
159         assertEquals("Expected " + object + " " + action + " to be ",
160                 expected, actual);
161     }
162 
assertAction(String action, T object, T2 needle, boolean expected, boolean actual)163     private static <T, T2> void assertAction(String action, T object, T2 needle, boolean expected,
164             boolean actual) {
165         String expectedMessage = expected ? action : ("not " + action);
166         assertEquals("Expected " + needle + " to be " + expectedMessage + " of " + object,
167                 expected, actual);
168     }
169 
assertHashCodeEquals( Range<T> left, Range<T> right)170     private static <T extends Comparable<? super T>> void assertHashCodeEquals(
171             Range<T> left, Range<T> right) {
172         assertEquals("Left hash code for " + left +
173                 " expected to be equal to right hash code for " + right,
174                 left.hashCode(), right.hashCode());
175     }
176 }
177