Add method to convert visible networks into Proto

chrome/android/junit/src/org/chromium/chrome/browser/omnibox/geo/VisibleNetworksTest.java

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.omnibox.geo;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.annotation.Config;
 
+import org.chromium.chrome.browser.omnibox.geo.PartnerLocationDescriptor.VisibleNetwork.Cell;
+import org.chromium.chrome.browser.omnibox.geo.PartnerLocationDescriptor.VisibleNetwork.WiFi;
 import org.chromium.chrome.browser.omnibox.geo.VisibleNetworks.VisibleCell;
 import org.chromium.chrome.browser.omnibox.geo.VisibleNetworks.VisibleCell.RadioType;
 import org.chromium.chrome.browser.omnibox.geo.VisibleNetworks.VisibleWifi;
 import org.chromium.testing.local.LocalRobolectricTestRunner;
 
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 
 /**
@@ skipping 86 matching lines @@
 
     @Test
     public void testVisibleWifiHashDifferentLevelAndTimestamp() {
         VisibleWifi visibleWifi3 = VisibleWifi.create(SSID2, BSSID2, LEVEL1, TIMESTAMP1);
         // visibleWifi3 has the same ssid and bssid as VISIBLE_WIFI2 but different level and
         // timestamp. The level and timestamp are excluded from the VisibleWifi hash function.
         assertEquals(VISIBLE_WIFI2.hashCode(), visibleWifi3.hashCode());
     }
 
     @Test
+    public void testVisibleWifiToProto() {
+        boolean connected = true;
+        PartnerLocationDescriptor.VisibleNetwork visibleNetwork = VISIBLE_WIFI1.toProto(connected);
+        WiFi wifi = visibleNetwork.wifi;
+
+        assertEquals(VISIBLE_WIFI1.bssid(), wifi.bssid);
+        assertEquals(VISIBLE_WIFI1.level(), wifi.levelDbm);
+        assertEquals(VISIBLE_WIFI1.timestampMs(), visibleNetwork.timestampMs);
+        assertEquals(connected, visibleNetwork.connected);
+    }
+
+    @Test
     public void testVisibleCellBuilder() {
         for (@RadioType int radioType : RADIO_TYPES) {
             VisibleCell visibleCell = VisibleCell.builder(radioType).build();
             assertEquals(radioType, visibleCell.radioType());
         }
     }
 
     @Test
     public void testVisibleCellEquals() {
         VisibleCell copyOfVisibleCell1 =
@@ skipping 29 matching lines @@
         assertNotEquals(VISIBLE_CELL2.hashCode(), VISIBLE_CELL1.hashCode());
     }
 
     @Test
     public void testVisibleCellHashDifferentTimestamp() {
         // The timestamp is not included in the VisibleCell hash function.
         assertEquals(VISIBLE_CELL1.hashCode(), VISIBLE_CELL1_DIFFERENT_TIMESTAMP.hashCode());
     }
 
     @Test
+    public void testVisibleCellToProto() {
+        boolean connected = true;
+        PartnerLocationDescriptor.VisibleNetwork visibleNetwork = VISIBLE_CELL1.toProto(connected);
+        PartnerLocationDescriptor.VisibleNetwork.Cell cell = visibleNetwork.cell;
+
+        assertEquals(VISIBLE_CELL1.cellId(), cell.cellId);
+        assertEquals(VISIBLE_CELL1.locationAreaCode(), cell.locationAreaCode);
+        assertEquals(VISIBLE_CELL1.mobileCountryCode(), cell.mobileCountryCode);
+        assertEquals(VISIBLE_CELL1.mobileNetworkCode(), cell.mobileNetworkCode);
+        assertEquals(VISIBLE_CELL1.primaryScramblingCode(), cell.primaryScramblingCode);
+        assertEquals(VISIBLE_CELL1.physicalCellId(), cell.physicalCellId);
+        assertEquals(VISIBLE_CELL1.trackingAreaCode(), cell.trackingAreaCode);
+        assertEquals(VISIBLE_CELL1.timestampMs(), visibleNetwork.timestampMs);
+        assertEquals(connected, visibleNetwork.connected);
+
+        switch (VISIBLE_CELL1.radioType()) {
+            case VisibleCell.UNKNOWN_RADIO_TYPE:

[Ted C, 2017/05/17 17:44:25]

I "think" this is a bit misleading.  There is only one radio type.  the switch
statement implies we are testing all of them, but we're only testing one.

For now, we should just use the one that is valid.

also, we should use assertEquals instead of assertTrue

[lbargu, 2017/05/18 12:42:48]

Done.

+                assertTrue(Cell.UNKNOWN == cell.type);
+                break;
+            case VisibleCell.UNKNOWN_MISSING_LOCATION_PERMISSION_RADIO_TYPE:
+                assertTrue(Cell.UNKNOWN == cell.type);
+                break;
+            case VisibleCell.WCDMA_RADIO_TYPE:
+                assertTrue(Cell.WCDMA == cell.type);
+                break;
+            case VisibleCell.LTE_RADIO_TYPE:
+                assertTrue(Cell.LTE == cell.type);
+                break;
+            case VisibleCell.GSM_RADIO_TYPE:
+                assertTrue(Cell.GSM == cell.type);
+                break;
+            case VisibleCell.CDMA_RADIO_TYPE:
+                assertTrue(Cell.CDMA == cell.type);
+                break;
+        }
+    }
+
+    @Test
     public void testVisibleNetworksCreate() {
         Set<VisibleCell> expectedVisibleCells =
                 new HashSet<VisibleCell>(Arrays.asList(VISIBLE_CELL1, VISIBLE_CELL2));
         Set<VisibleWifi> expectedVisibleWifis =
                 new HashSet<VisibleWifi>(Arrays.asList(VISIBLE_WIFI1, VISIBLE_WIFI2));
         VisibleNetworks visibleNetworks = VisibleNetworks.create(
                 VISIBLE_WIFI1, VISIBLE_CELL1, expectedVisibleWifis, expectedVisibleCells);
         assertEquals(VISIBLE_WIFI1, visibleNetworks.connectedWifi());
         assertEquals(VISIBLE_CELL1, visibleNetworks.connectedCell());
         assertEquals(expectedVisibleWifis, visibleNetworks.allVisibleWifis());
@@ skipping 20 matching lines @@
         assertNotEquals(VISIBLE_NETWORKS1.hashCode(), VISIBLE_NETWORKS2.hashCode());
     }
 
     @Test
     public void testVisibleNetworksIsEmpty() {
         VisibleNetworks visibleNetworks = VisibleNetworks.create(null, null, null, null);
         assertTrue(visibleNetworks.isEmpty());
         assertFalse(VISIBLE_NETWORKS1.isEmpty());
     }
 }