[RTT2] Add support for RTT with a Peer Wi-Fi Aware device

Add support for ranging to peer Wi-Fi Aware devices. These can
be specified either:
- In-band discovery using PeerHandle (which gets translated to a
  MAC address for ranging but masked back out when results are
  reported)
- Out-of-band discovery using a MAC address

Bug: 65015034
Test: unit tests + integration tests
Change-Id: I98f0bc06a0a408bc7fd543d564117fa303018adf

3 files changed, 227 insertions, 48 deletions

diff --git a/tests/wifitests/src/com/android/server/wifi/rtt/RttNativeTest.java b/tests/wifitests/src/com/android/server/wifi/rtt/RttNativeTest.java
index b4fe76503..c62d9acc7 100644
--- a/tests/wifitests/src/com/android/server/wifi/rtt/RttNativeTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/rtt/RttNativeTest.java
@@ -33,8 +33,6 @@ import android.hardware.wifi.V1_0.RttType;
 import android.hardware.wifi.V1_0.WifiStatus;
 import android.hardware.wifi.V1_0.WifiStatusCode;
 import android.net.wifi.rtt.RangingRequest;
-import android.net.wifi.rtt.RangingResult;
-import android.net.wifi.rtt.RangingResultCallback;
 
 import com.android.server.wifi.HalDeviceManager;
 import com.android.server.wifi.WifiNative;
@@ -122,10 +120,16 @@ public class RttNativeTest {
         collector.checkThat("entry 0: MAC", rttConfig.peer, equalTo(RttPeerType.AP));
 
         rttConfig = halRequest.get(1);
-        collector.checkThat("entry 0: MAC", rttConfig.addr,
+        collector.checkThat("entry 1: MAC", rttConfig.addr,
                 equalTo(HexEncoding.decode("0A0B0C0D0E00".toCharArray(), false)));
-        collector.checkThat("entry 0: MAC", rttConfig.type, equalTo(RttType.ONE_SIDED));
-        collector.checkThat("entry 0: MAC", rttConfig.peer, equalTo(RttPeerType.AP));
+        collector.checkThat("entry 1: MAC", rttConfig.type, equalTo(RttType.ONE_SIDED));
+        collector.checkThat("entry 1: MAC", rttConfig.peer, equalTo(RttPeerType.AP));
+
+        rttConfig = halRequest.get(2);
+        collector.checkThat("entry 2: MAC", rttConfig.addr,
+                equalTo(HexEncoding.decode("080908070605".toCharArray(), false)));
+        collector.checkThat("entry 2: MAC", rttConfig.type, equalTo(RttType.TWO_SIDED));
+        collector.checkThat("entry 2: MAC", rttConfig.peer, equalTo(RttPeerType.NAN));
     }
 
     /**
@@ -154,16 +158,16 @@ public class RttNativeTest {
         verify(mockRttServiceImpl).onRangingResults(eq(cmdId), mRttResultCaptor.capture());
 
         // verify contents of the framework results
-        List<RangingResult> fwkResults = mRttResultCaptor.getValue();
+        List<RttResult> rttR = mRttResultCaptor.getValue();
 
-        collector.checkThat("number of entries", fwkResults.size(), equalTo(1));
+        collector.checkThat("number of entries", rttR.size(), equalTo(1));
 
-        RangingResult fwkRes = fwkResults.get(0);
-        collector.checkThat("status", fwkRes.getStatus(),
-                equalTo(RangingResultCallback.STATUS_SUCCESS));
-        collector.checkThat("mac", fwkRes.getMacAddress(),
+        RttResult rttResult = rttR.get(0);
+        collector.checkThat("status", rttResult.status,
+                equalTo(RttStatus.SUCCESS));
+        collector.checkThat("mac", rttResult.addr,
                 equalTo(HexEncoding.decode("05060708090A".toCharArray(), false)));
-        collector.checkThat("distanceCm", fwkRes.getDistanceCm(), equalTo(150));
-        collector.checkThat("timestamp", fwkRes.getRangingTimestamp(), equalTo(666L));
+        collector.checkThat("distanceCm", rttResult.distanceInMm, equalTo(1500));
+        collector.checkThat("timestamp", rttResult.timeStampInUs, equalTo(666L));
     }
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java b/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java
index 43bf5d087..e5068fb46 100644
--- a/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java
@@ -17,24 +17,40 @@
 
 package com.android.server.wifi.rtt;
 
+import static com.android.server.wifi.rtt.RttTestUtils.compareListContentsNoOrdering;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
+import android.app.test.MockAnswerUtil;
 import android.content.Context;
+import android.hardware.wifi.V1_0.RttResult;
+import android.net.wifi.aware.IWifiAwareMacAddressProvider;
+import android.net.wifi.aware.IWifiAwareManager;
+import android.net.wifi.aware.PeerHandle;
 import android.net.wifi.rtt.IRttCallback;
 import android.net.wifi.rtt.RangingRequest;
 import android.net.wifi.rtt.RangingResult;
 import android.net.wifi.rtt.RangingResultCallback;
 import android.os.IBinder;
+import android.os.RemoteException;
 import android.os.test.TestLooper;
+import android.util.Pair;
 
 import com.android.server.wifi.util.WifiPermissionsUtil;
 
+import libcore.util.HexEncoding;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
@@ -42,7 +58,9 @@ import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Unit test harness for the RttServiceImpl class.
@@ -57,6 +75,10 @@ public class RttServiceImplTest {
     private ArgumentCaptor<Integer> mIntCaptor = ArgumentCaptor.forClass(Integer.class);
     private ArgumentCaptor<IBinder.DeathRecipient> mDeathRecipientCaptor = ArgumentCaptor
             .forClass(IBinder.DeathRecipient.class);
+    private ArgumentCaptor<RangingRequest> mRequestCaptor = ArgumentCaptor.forClass(
+            RangingRequest.class);
+    private ArgumentCaptor<List<RangingResult>> mResultsCaptor = ArgumentCaptor.forClass(
+            List.class);
 
     @Mock
     public Context mockContext;
@@ -65,6 +87,9 @@ public class RttServiceImplTest {
     public RttNative mockNative;
 
     @Mock
+    public IWifiAwareManager mockAwareManagerBinder;
+
+    @Mock
     public WifiPermissionsUtil mockPermissionUtil;
 
     @Mock
@@ -106,7 +131,7 @@ public class RttServiceImplTest {
                 anyInt())).thenReturn(true);
         when(mockNative.rangeRequest(anyInt(), any(RangingRequest.class))).thenReturn(true);
 
-        mDut.start(mMockLooper.getLooper(), mockNative, mockPermissionUtil);
+        mDut.start(mMockLooper.getLooper(), mockAwareManagerBinder, mockNative, mockPermissionUtil);
     }
 
     /**
@@ -116,7 +141,7 @@ public class RttServiceImplTest {
     public void testRangingFlow() throws Exception {
         int numIter = 10;
         RangingRequest[] requests = new RangingRequest[numIter];
-        List<List<RangingResult>> results = new ArrayList<>();
+        List<Pair<List<RttResult>, List<RangingResult>>> results = new ArrayList<>();
 
         for (int i = 0; i < numIter; ++i) {
             requests[i] = RttTestUtils.getDummyRangingRequest((byte) i);
@@ -134,15 +159,15 @@ public class RttServiceImplTest {
             verify(mockNative).rangeRequest(mIntCaptor.capture(), eq(requests[i]));
 
             // (3) native calls back with result
-            mDut.onRangingResults(mIntCaptor.getValue(), results.get(i));
+            mDut.onRangingResults(mIntCaptor.getValue(), results.get(i).first);
             mMockLooper.dispatchAll();
 
             // (4) verify that results dispatched
             verify(mockCallback).onRangingResults(RangingResultCallback.STATUS_SUCCESS,
-                    results.get(i));
+                    results.get(i).second);
 
             // (5) replicate results - shouldn't dispatch another callback
-            mDut.onRangingResults(mIntCaptor.getValue(), results.get(i));
+            mDut.onRangingResults(mIntCaptor.getValue(), results.get(i).first);
             mMockLooper.dispatchAll();
         }
 
@@ -150,20 +175,65 @@ public class RttServiceImplTest {
     }
 
     /**
+     * Validate a successful ranging flow with PeerHandles (i.e. verify translations)
+     */
+    @Test
+    public void testRangingFlowUsingAwarePeerHandles() throws Exception {
+        RangingRequest request = RttTestUtils.getDummyRangingRequest((byte) 0xA);
+        PeerHandle peerHandle = new PeerHandle(1022);
+        request.mRttPeers.add(new RangingRequest.RttPeerAware(peerHandle));
+        Map<Integer, byte[]> peerHandleToMacMap = new HashMap<>();
+        byte[] macAwarePeer = HexEncoding.decode("AABBCCDDEEFF".toCharArray(), false);
+        peerHandleToMacMap.put(1022, macAwarePeer);
+
+        AwareTranslatePeerHandlesToMac answer = new AwareTranslatePeerHandlesToMac(mDefaultUid,
+                peerHandleToMacMap);
+        doAnswer(answer).when(mockAwareManagerBinder).requestMacAddresses(anyInt(), any(), any());
+
+        // issue request
+        mDut.startRanging(mockIbinder, mPackageName, request, mockCallback);
+        mMockLooper.dispatchAll();
+
+        // verify that requested with MAC address translated from the PeerHandle issued to Native
+        verify(mockNative).rangeRequest(mIntCaptor.capture(), mRequestCaptor.capture());
+
+        RangingRequest finalRequest = mRequestCaptor.getValue();
+        assertNotEquals("Request to native is not null", null, finalRequest);
+        assertEquals("Size of request", request.mRttPeers.size(), finalRequest.mRttPeers.size());
+        assertEquals("Aware peer MAC", macAwarePeer,
+                ((RangingRequest.RttPeerAware) finalRequest.mRttPeers.get(
+                        finalRequest.mRttPeers.size() - 1)).peerMacAddress);
+
+        // issue results
+        Pair<List<RttResult>, List<RangingResult>> results =
+                RttTestUtils.getDummyRangingResults(mRequestCaptor.getValue());
+        mDut.onRangingResults(mIntCaptor.getValue(), results.first);
+        mMockLooper.dispatchAll();
+
+        // verify that results with MAC addresses filtered out and replaced by PeerHandles issued
+        // to callback
+        verify(mockCallback).onRangingResults(eq(RangingResultCallback.STATUS_SUCCESS),
+                mResultsCaptor.capture());
+
+        assertTrue(compareListContentsNoOrdering(results.second, mResultsCaptor.getValue()));
+
+        verifyNoMoreInteractions(mockNative, mockCallback);
+    }
+
+    /**
      * Validate failed ranging flow (native failure).
      */
     @Test
     public void testRangingFlowNativeFailure() throws Exception {
         int numIter = 10;
         RangingRequest[] requests = new RangingRequest[numIter];
-        List<List<RangingResult>> results = new ArrayList<>();
+        List<Pair<List<RttResult>, List<RangingResult>>> results = new ArrayList<>();
 
         for (int i = 0; i < numIter; ++i) {
             requests[i] = RttTestUtils.getDummyRangingRequest((byte) i);
             results.add(RttTestUtils.getDummyRangingResults(requests[i]));
         }
 
-
         // (1) request 10 ranging operations: fail the first one
         when(mockNative.rangeRequest(anyInt(), any(RangingRequest.class))).thenReturn(false);
         mDut.startRanging(mockIbinder, mPackageName, requests[0], mockCallback);
@@ -186,12 +256,12 @@ public class RttServiceImplTest {
 
             // (4) on failed HAL: even if native calls back with result we shouldn't dispatch
             // callback, otherwise expect result
-            mDut.onRangingResults(mIntCaptor.getValue(), results.get(i));
+            mDut.onRangingResults(mIntCaptor.getValue(), results.get(i).first);
             mMockLooper.dispatchAll();
 
             if (i != 0) {
                 verify(mockCallback).onRangingResults(RangingResultCallback.STATUS_SUCCESS,
-                        results.get(i));
+                        results.get(i).second);
             }
         }
 
@@ -204,7 +274,8 @@ public class RttServiceImplTest {
     @Test
     public void testRangingRequestWithoutRuntimePermission() throws Exception {
         RangingRequest request = RttTestUtils.getDummyRangingRequest((byte) 0);
-        List<RangingResult> results = RttTestUtils.getDummyRangingResults(request);
+        Pair<List<RttResult>, List<RangingResult>> results = RttTestUtils.getDummyRangingResults(
+                request);
 
         // (1) request ranging operation
         mDut.startRanging(mockIbinder, mPackageName, request, mockCallback);
@@ -217,10 +288,10 @@ public class RttServiceImplTest {
         when(mockPermissionUtil.checkCallersLocationPermission(eq(mPackageName),
                 anyInt())).thenReturn(false);
 
-        mDut.onRangingResults(mIntCaptor.getValue(), results);
+        mDut.onRangingResults(mIntCaptor.getValue(), results.first);
         mMockLooper.dispatchAll();
 
-        verify(mockCallback).onRangingResults(eq(RangingResultCallback.STATUS_FAIL), any());
+        verify(mockCallback).onRangingResults(eq(RangingResultCallback.STATUS_FAIL), isNull());
 
         verifyNoMoreInteractions(mockNative, mockCallback);
     }
@@ -233,7 +304,7 @@ public class RttServiceImplTest {
     public void testBinderDeathOfRangingApp() throws Exception {
         int numIter = 10;
         RangingRequest[] requests = new RangingRequest[numIter];
-        List<List<RangingResult>> results = new ArrayList<>();
+        List<Pair<List<RttResult>, List<RangingResult>>> results = new ArrayList<>();
 
         for (int i = 0; i < numIter; ++i) {
             requests[i] = RttTestUtils.getDummyRangingRequest((byte) i);
@@ -265,7 +336,7 @@ public class RttServiceImplTest {
             // (5) native calls back with results - should get requests for the odd attempts and
             // should only get callbacks for the odd attempts (the non-dead UID)
             if (i == 0 || i % 2 == 1) {
-                mDut.onRangingResults(mIntCaptor.getValue(), results.get(i));
+                mDut.onRangingResults(mIntCaptor.getValue(), results.get(i).first);
                 mMockLooper.dispatchAll();
 
                 // note that we are getting a callback for the first operation - it was dispatched
@@ -273,7 +344,7 @@ public class RttServiceImplTest {
                 // dead so in reality this will throw a RemoteException which the service will
                 // handle correctly.
                 verify(mockCallback).onRangingResults(RangingResultCallback.STATUS_SUCCESS,
-                        results.get(i));
+                        results.get(i).second);
             }
         }
 
@@ -287,7 +358,8 @@ public class RttServiceImplTest {
     @Test
     public void testUnexpectedResult() throws Exception {
         RangingRequest request = RttTestUtils.getDummyRangingRequest((byte) 0);
-        List<RangingResult> results = RttTestUtils.getDummyRangingResults(request);
+        Pair<List<RttResult>, List<RangingResult>> results = RttTestUtils.getDummyRangingResults(
+                request);
 
         // (1) request ranging operation
         mDut.startRanging(mockIbinder, mPackageName, request, mockCallback);
@@ -297,15 +369,16 @@ public class RttServiceImplTest {
         verify(mockNative).rangeRequest(mIntCaptor.capture(), eq(request));
 
         // (3) native calls back with result - but wrong ID
-        mDut.onRangingResults(mIntCaptor.getValue() + 1, RttTestUtils.getDummyRangingResults(null));
+        mDut.onRangingResults(mIntCaptor.getValue() + 1,
+                RttTestUtils.getDummyRangingResults(null).first);
         mMockLooper.dispatchAll();
 
         // (4) now send results with correct ID (different set of results to differentiate)
-        mDut.onRangingResults(mIntCaptor.getValue(), results);
+        mDut.onRangingResults(mIntCaptor.getValue(), results.first);
         mMockLooper.dispatchAll();
 
         // (5) verify that results dispatched
-        verify(mockCallback).onRangingResults(RangingResultCallback.STATUS_SUCCESS, results);
+        verify(mockCallback).onRangingResults(RangingResultCallback.STATUS_SUCCESS, results.second);
 
         verifyNoMoreInteractions(mockNative, mockCallback);
     }
@@ -317,13 +390,13 @@ public class RttServiceImplTest {
     @Test
     public void testMissingResults() throws Exception {
         RangingRequest request = RttTestUtils.getDummyRangingRequest((byte) 0);
-        List<RangingResult> results = RttTestUtils.getDummyRangingResults(request);
-        List<RangingResult> resultsMissing = new ArrayList<>(results);
-        resultsMissing.remove(0);
-        List<RangingResult> resultsExpected = new ArrayList<>(resultsMissing);
-        resultsExpected.add(
-                new RangingResult(RangingResultCallback.STATUS_FAIL, results.get(0).getMacAddress(),
-                        0, 0, 0, 0));
+        Pair<List<RttResult>, List<RangingResult>> results = RttTestUtils.getDummyRangingResults(
+                request);
+        results.first.remove(0);
+        RangingResult removed = results.second.remove(0);
+        results.second.add(
+                new RangingResult(RangingResultCallback.STATUS_FAIL, removed.getMacAddress(), 0, 0,
+                        0, 0));
 
         // (1) request ranging operation
         mDut.startRanging(mockIbinder, mPackageName, request, mockCallback);
@@ -333,13 +406,48 @@ public class RttServiceImplTest {
         verify(mockNative).rangeRequest(mIntCaptor.capture(), eq(request));
 
         // (3) return results with missing entries
-        mDut.onRangingResults(mIntCaptor.getValue(), resultsMissing);
+        mDut.onRangingResults(mIntCaptor.getValue(), results.first);
         mMockLooper.dispatchAll();
 
         // (5) verify that (full) results dispatched
-        verify(mockCallback).onRangingResults(RangingResultCallback.STATUS_SUCCESS,
-                resultsExpected);
+        verify(mockCallback).onRangingResults(eq(RangingResultCallback.STATUS_SUCCESS),
+                mResultsCaptor.capture());
+        assertTrue(compareListContentsNoOrdering(results.second, mResultsCaptor.getValue()));
 
         verifyNoMoreInteractions(mockNative, mockCallback);
     }
+
+    /*
+     * Utilities
+     */
+
+    private class AwareTranslatePeerHandlesToMac extends MockAnswerUtil.AnswerWithArguments {
+        private int mExpectedUid;
+        private Map<Integer, byte[]> mPeerIdToMacMap;
+
+        AwareTranslatePeerHandlesToMac(int expectedUid, Map<Integer, byte[]> peerIdToMacMap) {
+            mExpectedUid = expectedUid;
+            mPeerIdToMacMap = peerIdToMacMap;
+        }
+
+        public void answer(int uid, List<Integer> peerIds, IWifiAwareMacAddressProvider callback) {
+            assertEquals("Invalid UID", mExpectedUid, uid);
+
+            Map<Integer, byte[]> result = new HashMap<>();
+            for (Integer peerId: peerIds) {
+                byte[] mac = mPeerIdToMacMap.get(peerId);
+                if (mac == null) {
+                    continue;
+                }
+
+                result.put(peerId, mac);
+            }
+
+            try {
+                callback.macAddress(result);
+            } catch (RemoteException e) {
+                e.printStackTrace();
+            }
+        }
+    }
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/rtt/RttTestUtils.java b/tests/wifitests/src/com/android/server/wifi/rtt/RttTestUtils.java
index 9512b2ac8..b3eef3156 100644
--- a/tests/wifitests/src/com/android/server/wifi/rtt/RttTestUtils.java
+++ b/tests/wifitests/src/com/android/server/wifi/rtt/RttTestUtils.java
@@ -18,10 +18,13 @@ package com.android.server.wifi.rtt;
 
 import static com.android.server.wifi.util.NativeUtil.macAddressToByteArray;
 
+import android.hardware.wifi.V1_0.RttResult;
+import android.hardware.wifi.V1_0.RttStatus;
 import android.net.wifi.ScanResult;
 import android.net.wifi.rtt.RangingRequest;
 import android.net.wifi.rtt.RangingResult;
 import android.net.wifi.rtt.RangingResultCallback;
+import android.util.Pair;
 
 import libcore.util.HexEncoding;
 
@@ -33,6 +36,26 @@ import java.util.List;
  */
 public class RttTestUtils {
     /**
+     * Compare the two lists and return true for equality, false otherwise. The two lists are
+     * considered identical if they have the same number of elements and contain equal elements
+     * (equality of elements using the equal() operator of the component objects).
+     *
+     * Note: null != empty list
+     */
+    public static boolean compareListContentsNoOrdering(List a, List b) {
+        if (a == b) {
+            return true;
+        }
+        if (a == null || b == null) {
+            return false; // at this point they're not both null
+        }
+        if (a.size() != b.size()) { // at this point neither is null
+            return false;
+        }
+        return a.containsAll(b) && b.containsAll(a);
+    }
+
+    /**
      * Returns a dummy ranging request with 2 requests:
      * - First: 802.11mc capable
      * - Second: 802.11mc not capable
@@ -45,30 +68,54 @@ public class RttTestUtils {
         scan1.setFlag(ScanResult.FLAG_80211mc_RESPONDER);
         ScanResult scan2 = new ScanResult();
         scan2.BSSID = "0A:0B:0C:0D:0E:" + String.format("%02d", lastMacByte);
+        byte[] mac1 = HexEncoding.decode("080908070605".toCharArray(), false);
 
         builder.addAp(scan1);
         builder.addAp(scan2);
+        builder.addWifiAwarePeer(mac1);
 
         return builder.build();
     }
 
     /**
-     * Returns a set of dummy ranging results.
+     * Returns a matched set of dummy ranging results: HAL RttResult and the public API
+     * RangingResult.
      *
      * @param request If non-null will be used as a template (BSSID) for the range results.
      */
-    public static List<RangingResult> getDummyRangingResults(RangingRequest request) {
+    public static Pair<List<RttResult>, List<RangingResult>> getDummyRangingResults(
+            RangingRequest request) {
         int rangeCmBase = 15;
         int rangeStdDevCmBase = 3;
         int rssiBase = -20;
         long rangeTimestampBase = 666;
+        List<RttResult> halResults = new ArrayList<>();
         List<RangingResult> results = new ArrayList<>();
 
         if (request != null) {
             for (RangingRequest.RttPeer peer: request.mRttPeers) {
-                results.add(new RangingResult(RangingResultCallback.STATUS_SUCCESS,
-                        macAddressToByteArray(((RangingRequest.RttPeerAp) peer).scanResult.BSSID),
-                        rangeCmBase++, rangeStdDevCmBase++, rssiBase++, rangeTimestampBase++));
+                RangingResult rangingResult = null;
+                byte[] overrideMac = null;
+                if (peer instanceof RangingRequest.RttPeerAp) {
+                    rangingResult = new RangingResult(RangingResultCallback.STATUS_SUCCESS,
+                            macAddressToByteArray(
+                                    ((RangingRequest.RttPeerAp) peer).scanResult.BSSID),
+                            rangeCmBase++, rangeStdDevCmBase++, rssiBase++, rangeTimestampBase++);
+                } else if (peer instanceof RangingRequest.RttPeerAware) {
+                    RangingRequest.RttPeerAware awarePeer = (RangingRequest.RttPeerAware) peer;
+                    if (awarePeer.peerHandle != null) {
+                        rangingResult = new RangingResult(RangingResultCallback.STATUS_SUCCESS,
+                                awarePeer.peerHandle, rangeCmBase++, rangeStdDevCmBase++,
+                                rssiBase++, rangeTimestampBase++);
+                        overrideMac = awarePeer.peerMacAddress;
+                    } else {
+                        rangingResult = new RangingResult(RangingResultCallback.STATUS_SUCCESS,
+                                awarePeer.peerMacAddress, rangeCmBase++, rangeStdDevCmBase++,
+                                rssiBase++, rangeTimestampBase++);
+                    }
+                }
+                results.add(rangingResult);
+                halResults.add(getMatchingRttResult(rangingResult, overrideMac));
             }
         } else {
             results.add(new RangingResult(RangingResultCallback.STATUS_SUCCESS,
@@ -77,8 +124,28 @@ public class RttTestUtils {
             results.add(new RangingResult(RangingResultCallback.STATUS_SUCCESS,
                     HexEncoding.decode("1A0B0C0D0E0F".toCharArray(), false), rangeCmBase++,
                     rangeStdDevCmBase++, rssiBase++, rangeTimestampBase++));
+            results.add(new RangingResult(RangingResultCallback.STATUS_SUCCESS,
+                    HexEncoding.decode("080908070605".toCharArray(), false), rangeCmBase++,
+                    rangeStdDevCmBase++, rssiBase++, rangeTimestampBase++));
+            halResults.add(getMatchingRttResult(results.get(0), null));
+            halResults.add(getMatchingRttResult(results.get(1), null));
+            halResults.add(getMatchingRttResult(results.get(2), null));
         }
 
-        return results;
+        return new Pair<>(halResults, results);
+    }
+
+    private static RttResult getMatchingRttResult(RangingResult rangingResult, byte[] overrideMac) {
+        RttResult rttResult = new RttResult();
+        rttResult.status = rangingResult.getStatus() == RangingResultCallback.STATUS_SUCCESS
+                ? RttStatus.SUCCESS : RttStatus.FAILURE;
+        System.arraycopy(overrideMac == null ? rangingResult.getMacAddress() : overrideMac, 0,
+                rttResult.addr, 0, 6);
+        rttResult.distanceInMm = rangingResult.getDistanceCm() * 10;
+        rttResult.distanceSdInMm = rangingResult.getDistanceStdDevCm() * 10;
+        rttResult.rssi = rangingResult.getRssi();
+        rttResult.timeStampInUs = rangingResult.getRangingTimestamp();
+
+        return rttResult;
     }
 }