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
17package com.android.mediaframeworktest.unit;
18
19import android.test.suitebuilder.annotation.SmallTest;
20import android.util.Range;
21import 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 */
30public class RangeTest extends junit.framework.TestCase {
31
32    @SmallTest
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
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
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
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
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
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
148    private static <T extends Comparable<? super T>> void assertUpper(Range<T> object, T expected) {
149        assertAction("upper", object, expected, object.getUpper());
150    }
151
152    private static <T extends Comparable<? super T>> void assertLower(Range<T> object, T expected) {
153        assertAction("lower", object, expected, object.getLower());
154    }
155
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
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
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