ScoredNetworkTest.java revision c63d5b0c74ad7330d9893640cdfce0e03f91c0f1 
1/*
2 t Copyright (C) 2016 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 android.net;
18
19import static org.junit.Assert.*;
20
21import android.os.Build;
22import android.os.Bundle;
23import android.os.Parcel;
24import android.support.test.filters.SmallTest;
25import android.support.test.runner.AndroidJUnit4;
26
27import org.junit.Before;
28import org.junit.Test;
29import org.junit.runner.RunWith;
30
31import java.util.Arrays;
32
33/** Unit tests for {@link ScoredNetwork}. */
34@RunWith(AndroidJUnit4.class)
35public class ScoredNetworkTest {
36
37    private static final int RSSI_START = -110;
38    private static final int TEST_RSSI = -50;
39    private static final byte TEST_SCORE = 5;
40    private static final RssiCurve CURVE =
41            new RssiCurve(RSSI_START, 10, new byte[] {-1, 0, 1, 2, 3, 4, TEST_SCORE, 6, 7});
42
43    private static final byte RANKING_SCORE_OFFSET = 13;
44    private static final Bundle ATTRIBUTES;
45    static {
46        ATTRIBUTES = new Bundle();
47        ATTRIBUTES.putInt(
48                ScoredNetwork.ATTRIBUTES_KEY_RANKING_SCORE_OFFSET, RANKING_SCORE_OFFSET);
49    }
50
51    private static final NetworkKey KEY
52        = new NetworkKey(new WifiKey("\"ssid\"", "00:00:00:00:00:00"));
53
54    @Test
55    public void calculateRankingOffsetShouldThrowUnsupportedOperationException() {
56        // No curve or ranking score offset set in curve
57        ScoredNetwork scoredNetwork = new ScoredNetwork(KEY, null);
58        try {
59            scoredNetwork.calculateRankingScore(TEST_RSSI);
60            fail("Should have thrown UnsupportedOperationException");
61        } catch (UnsupportedOperationException e) {
62            // expected
63        }
64    }
65
66    @Test
67    public void calculateRankingOffsetWithRssiCurveShouldReturnExpectedScore() {
68        ScoredNetwork scoredNetwork = new ScoredNetwork(KEY, CURVE);
69        assertEquals(TEST_SCORE << Byte.SIZE, scoredNetwork.calculateRankingScore(TEST_RSSI));
70    }
71
72    @Test
73    public void rankingScoresShouldDifferByRankingScoreOffset() {
74        ScoredNetwork scoredNetwork1 = new ScoredNetwork(KEY, CURVE);
75        ScoredNetwork scoredNetwork2
76            = new ScoredNetwork(KEY, CURVE, false /* meteredHint */, ATTRIBUTES);
77        int scoreDifference =
78            scoredNetwork2.calculateRankingScore(TEST_RSSI)
79            - scoredNetwork1.calculateRankingScore(TEST_RSSI);
80        assertEquals(RANKING_SCORE_OFFSET, scoreDifference);
81    }
82
83    @Test
84    public void calculateRankingScoreShouldNotResultInIntegerOverflow() {
85        Bundle attr = new Bundle();
86        attr.putInt(ScoredNetwork.ATTRIBUTES_KEY_RANKING_SCORE_OFFSET, Integer.MAX_VALUE);
87        ScoredNetwork scoredNetwork
88            = new ScoredNetwork(KEY, CURVE, false /* meteredHint */, attr);
89        assertEquals(Integer.MAX_VALUE, scoredNetwork.calculateRankingScore(TEST_RSSI));
90    }
91
92    @Test
93    public void calculateRankingScoreShouldNotResultInIntegerUnderflow() {
94        Bundle attr = new Bundle();
95        attr.putInt(ScoredNetwork.ATTRIBUTES_KEY_RANKING_SCORE_OFFSET, Integer.MIN_VALUE);
96        ScoredNetwork scoredNetwork =
97                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, attr);
98        assertEquals(Integer.MIN_VALUE, scoredNetwork.calculateRankingScore(RSSI_START));
99    }
100
101    @Test
102    public void hasRankingScoreShouldReturnFalse() {
103        ScoredNetwork network = new ScoredNetwork(KEY, null /* rssiCurve */);
104        assertFalse(network.hasRankingScore());
105    }
106
107    @Test
108    public void hasRankingScoreShouldReturnTrueWhenAttributesHasRankingScoreOffset() {
109        ScoredNetwork network =
110                new ScoredNetwork(KEY, null /* rssiCurve */, false /* meteredHint */, ATTRIBUTES);
111        assertTrue(network.hasRankingScore());
112    }
113
114    @Test
115    public void hasRankingScoreShouldReturnTrueWhenCurveIsPresent() {
116        ScoredNetwork network =
117                new ScoredNetwork(KEY, CURVE , false /* meteredHint */);
118        assertTrue(network.hasRankingScore());
119    }
120
121    @Test
122    public void shouldWriteAndReadFromParcelWhenAllFieldsSet() {
123        ScoredNetwork network = new ScoredNetwork(KEY, CURVE, true /* meteredHint */, ATTRIBUTES);
124        ScoredNetwork newNetwork;
125
126        Parcel parcel = null;
127        try {
128            parcel = Parcel.obtain();
129            network.writeToParcel(parcel, 0 /* flags */);
130            parcel.setDataPosition(0);
131            newNetwork = ScoredNetwork.CREATOR.createFromParcel(parcel);
132        } finally {
133            if (parcel != null) {
134                parcel.recycle();
135            }
136        }
137        assertEquals(CURVE.start, newNetwork.rssiCurve.start);
138        assertEquals(CURVE.bucketWidth, newNetwork.rssiCurve.bucketWidth);
139        assertTrue(Arrays.equals(CURVE.rssiBuckets, newNetwork.rssiCurve.rssiBuckets));
140        assertTrue(newNetwork.meteredHint);
141        assertNotNull(newNetwork.attributes);
142        assertEquals(
143                RANKING_SCORE_OFFSET,
144                newNetwork.attributes.getInt(ScoredNetwork.ATTRIBUTES_KEY_RANKING_SCORE_OFFSET));
145    }
146
147    @Test
148    public void shouldWriteAndReadFromParcelWithoutBundle() {
149        ScoredNetwork network = new ScoredNetwork(KEY, CURVE, true /* meteredHint */);
150        ScoredNetwork newNetwork;
151
152        Parcel parcel = null;
153        try {
154            parcel = Parcel.obtain();
155            network.writeToParcel(parcel, 0 /* flags */);
156            parcel.setDataPosition(0);
157            newNetwork = ScoredNetwork.CREATOR.createFromParcel(parcel);
158        } finally {
159            if (parcel != null) {
160                parcel.recycle();
161            }
162        }
163        assertEquals(CURVE.start, newNetwork.rssiCurve.start);
164        assertEquals(CURVE.bucketWidth, newNetwork.rssiCurve.bucketWidth);
165        assertTrue(Arrays.equals(CURVE.rssiBuckets, newNetwork.rssiCurve.rssiBuckets));
166        assertTrue(newNetwork.meteredHint);
167        assertNull(newNetwork.attributes);
168    }
169}
170