Extract and refactor logic to determine the data usage summary mark.

Created a new controller for DataUsageInfo and add appropriate
unit tests.

Bug: 30946416
Change-Id: Ida1281a771013fd807242f846edb4f2a9c0ccabb
Test: Robolectric tests with target RunSettingsRoboTests

src/com/android/settings/datausage/DataUsageInfoController.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 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.android.settings.datausage;
+
+import android.net.NetworkPolicy;
+import com.android.settingslib.net.DataUsageController.DataUsageInfo;
+
+/**
+ * Controller to handle caching and mobile data logic.
+ */
+public class DataUsageInfoController {
+    /**
+     * Take the cached data usage values in the NetworkPolicy to update DataUsageInfo.
+     */
+    public void updateDataLimit(DataUsageInfo info, NetworkPolicy policy) {
+        if (info == null || policy == null) {
+            return;
+        }
+        if (policy.warningBytes >= 0) {
+            info.warningLevel = policy.warningBytes;
+        }
+        if (policy.limitBytes >= 0) {
+            info.limitLevel = policy.limitBytes;
+        }
+    }
+
+    /**
+     * @returns the most appropriate limit for the data usage summary. Use the total usage when it
+     * is higher than the limit and warning level. Use the limit when it is set and less than usage.
+     * Otherwise use warning level.
+     */
+    public long getSummaryLimit(DataUsageInfo info) {
+        long limit = info.limitLevel;
+        if (limit <= 0) {
+            limit = info.warningLevel;
+        }
+        if (info.usageLevel > limit) {
+            limit = info.usageLevel;
+        }
+        return limit;
+    }
+}

src/com/android/settings/datausage/DataUsageSummary.java

@@ -20,7 +20,6 @@ import android.content.Context;
 import android.content.Intent;
 import android.net.ConnectivityManager;
 import android.net.INetworkStatsSession;
-import android.net.NetworkPolicy;
 import android.net.NetworkTemplate;
 import android.net.TrafficStats;
 import android.os.Bundle;
@@ -71,6 +70,7 @@ public class DataUsageSummary extends DataUsageBase implements Indexable, DataUs
     private static final String KEY_RESTRICT_BACKGROUND = "restrict_background";
 
     private DataUsageController mDataUsageController;
+    private DataUsageInfoController mDataInfoControler;
     private SummaryPreference mSummaryPreference;
     private Preference mLimitPreference;
     private NetworkTemplate mDefaultTemplate;
@@ -82,6 +82,7 @@ public class DataUsageSummary extends DataUsageBase implements Indexable, DataUs
 
         boolean hasMobileData = hasMobileData(getContext());
         mDataUsageController = new DataUsageController(getContext());
+        mDataInfoControler = new DataUsageInfoController();
         addPreferencesFromResource(R.xml.data_usage);
 
         int defaultSubId = getDefaultSubscriptionId(getContext());
@@ -225,18 +226,14 @@ public class DataUsageSummary extends DataUsageBase implements Indexable, DataUs
         DataUsageController.DataUsageInfo info = mDataUsageController.getDataUsageInfo(
                 mDefaultTemplate);
         Context context = getContext();
-        NetworkPolicy policy = services.mPolicyEditor.getPolicy(mDefaultTemplate);
+
-        info.warningLevel = policy.warningBytes;
+        mDataInfoControler.updateDataLimit(info,
+                services.mPolicyEditor.getPolicy(mDefaultTemplate));
+
         if (mSummaryPreference != null) {
             mSummaryPreference.setTitle(
                     formatTitle(context, getString(mDataUsageTemplate), info.usageLevel));
-            long limit = info.limitLevel;
+            long limit = mDataInfoControler.getSummaryLimit(info);
-            if (limit <= 0) {
-                limit = info.warningLevel;
-            }
-            if (info.usageLevel > limit) {
-                limit = info.usageLevel;
-            }
             mSummaryPreference.setSummary(info.period);
             mSummaryPreference.setLabels(Formatter.formatFileSize(context, 0),
                     Formatter.formatFileSize(context, limit));

tests/robotests/src/com/android/settings/datausage/DataUsageInfoControllerTest.java

@@ -0,0 +1,146 @@
+package com.android.settings.datausage;
+
+import android.net.NetworkPolicy;
+import android.net.NetworkTemplate;
+import com.android.settings.TestConfig;
+import junit.framework.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import static com.android.settingslib.net.DataUsageController.*;
+import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.fail;
+import static org.junit.Assert.assertEquals;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class DataUsageInfoControllerTest {
+    private DataUsageInfoController mInfoController;
+    private  DataUsageInfo info;
+
+    @Before
+    public void setUp()  {
+        mInfoController = new DataUsageInfoController();
+        info = new DataUsageInfo();
+    }
+
+    @Test
+    public void testLowUsageLowWarning_LimitUsed() {
+        info.warningLevel = 5;
+        info.limitLevel = 10;
+        info.usageLevel = 5;
+        assertEquals(mInfoController.getSummaryLimit(info), info.limitLevel);
+    }
+
+    @Test
+    public void testLowUsageEqualWarning_LimitUsed() {
+        info.warningLevel = 10;
+        info.limitLevel = 10;
+        info.usageLevel = 5;
+        assertEquals(mInfoController.getSummaryLimit(info), info.limitLevel);
+    }
+
+    @Test
+    public void testNoLimitNoUsage_WarningUsed() {
+        info.warningLevel = 10;
+        info.limitLevel = 0;
+        info.usageLevel = 0;
+        assertEquals(mInfoController.getSummaryLimit(info), info.warningLevel);
+    }
+
+    @Test
+    public void testNoLimitLowUsage_WarningUsed() {
+        info.warningLevel = 10;
+        info.limitLevel = 0;
+        info.usageLevel = 5;
+        assertEquals(mInfoController.getSummaryLimit(info), info.warningLevel);
+    }
+
+    @Test
+    public void testLowWarningNoLimit_UsageUsed() {
+        info.warningLevel = 5;
+        info.limitLevel = 0;
+        info.usageLevel = 10;
+        assertEquals(mInfoController.getSummaryLimit(info), info.usageLevel);
+    }
+
+    @Test
+    public void testLowWarningLowLimit_UsageUsed() {
+        info.warningLevel = 5;
+        info.limitLevel = 5;
+        info.usageLevel = 10;
+        assertEquals(mInfoController.getSummaryLimit(info), info.usageLevel);
+    }
+
+    private NetworkPolicy getDefaultNetworkPolicy() {
+        NetworkTemplate template = new NetworkTemplate(NetworkTemplate.MATCH_WIFI_WILDCARD,
+                null, null);
+        int cycleDay  = -1;
+        String cycleTimezone = "UTC";
+        long warningBytes = -1;
+        long limitBytes = -1;
+        return new NetworkPolicy(template,cycleDay, cycleTimezone, warningBytes, limitBytes, true);
+    }
+
+    @Test
+    public void testNullArguments_NoError() {
+        try {
+            mInfoController.updateDataLimit(null, null);
+            mInfoController.updateDataLimit(info, null);
+            mInfoController.updateDataLimit(null, getDefaultNetworkPolicy());
+        } catch (Exception e) {
+            fail("Update Data Limit should drop calls with null arguments");
+        }
+    }
+
+    @Test
+    public void testNegativeWarning_UpdatedToZero() {
+        NetworkPolicy policy = getDefaultNetworkPolicy();
+        policy.warningBytes = -5;
+        mInfoController.updateDataLimit(info, policy);
+        Assert.assertEquals(0, info.warningLevel);
+    }
+
+    @Test
+    public void testWarningZero_UpdatedToZero() {
+        NetworkPolicy policy = getDefaultNetworkPolicy();
+        policy.warningBytes = 0;
+        mInfoController.updateDataLimit(info, policy);
+        Assert.assertEquals(0, info.warningLevel);
+    }
+
+    @Test
+    public void testWarningPositive_UpdatedToWarning() {
+        NetworkPolicy policy = getDefaultNetworkPolicy();
+        policy.warningBytes = 5;
+        mInfoController.updateDataLimit(info, policy);
+        Assert.assertEquals(policy.warningBytes, info.warningLevel);
+    }
+
+    @Test
+    public void testLimitNegative_UpdatedToZero() {
+        NetworkPolicy policy = getDefaultNetworkPolicy();
+        policy.limitBytes = -5;
+        mInfoController.updateDataLimit(info, policy);
+        Assert.assertEquals(0, info.limitLevel);
+    }
+
+    @Test
+    public void testLimitZero_UpdatedToZero() {
+        NetworkPolicy policy = getDefaultNetworkPolicy();
+        policy.limitBytes = 0;
+        mInfoController.updateDataLimit(info, policy);
+        Assert.assertEquals(0, info.limitLevel);
+    }
+
+    @Test
+    public void testLimitPositive_UpdatedToLimit() {
+        NetworkPolicy policy = getDefaultNetworkPolicy();
+        policy.limitBytes = 5;
+        mInfoController.updateDataLimit(info, policy);
+        Assert.assertEquals(policy.limitBytes, info.limitLevel);
+    }
+}