Skip to content

Commit 7c8e5fe

Browse files
joeljfischerjoeljfischer
authored
Merge pull request #1107 from smartdevicelink/feature/align_scm
Align SystemCapabilityManager with iOS
2 parents 062848f + 1cf9d7b commit 7c8e5fe

3 files changed

Lines changed: 413 additions & 64 deletions

File tree

‎android/sdl_android/src/androidTest/java/com/smartdevicelink/test/proxy/SystemCapabilityManagerTests.java‎

Lines changed: 281 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@
1919
import com.smartdevicelink.proxy.rpc.ButtonCapabilities;
2020
import com.smartdevicelink.proxy.rpc.DisplayCapabilities;
2121
import com.smartdevicelink.proxy.rpc.DisplayCapability;
22+
import com.smartdevicelink.proxy.rpc.GetSystemCapability;
2223
import com.smartdevicelink.proxy.rpc.GetSystemCapabilityResponse;
2324
import com.smartdevicelink.proxy.rpc.HMICapabilities;
2425
import com.smartdevicelink.proxy.rpc.OnSystemCapabilityUpdated;
@@ -57,18 +58,37 @@
5758
import com.smartdevicelink.util.CorrelationIdGenerator;
5859
import com.smartdevicelink.util.Version;
5960

61+
import org.mockito.invocation.InvocationOnMock;
62+
import org.mockito.stubbing.Answer;
63+
6064
import java.util.ArrayList;
6165
import java.util.Collections;
6266
import java.util.List;
6367
import java.util.concurrent.CopyOnWriteArrayList;
6468

69+
import static org.mockito.ArgumentMatchers.any;
70+
import static org.mockito.Mockito.doAnswer;
71+
import static org.mockito.Mockito.mock;
72+
import static org.mockito.Mockito.times;
73+
import static org.mockito.Mockito.verify;
74+
import static org.mockito.Mockito.when;
75+
6576
public class SystemCapabilityManagerTests extends AndroidTestCase2 {
6677
public static final String TAG = "SystemCapabilityManagerTests";
6778
public static SystemCapabilityManager systemCapabilityManager;
79+
private SystemCapability systemCapability;
80+
private VideoStreamingCapability videoStreamingCapability;
6881

6982
@Override
7083
protected void setUp() throws Exception{
7184
super.setUp();
85+
86+
systemCapability = new SystemCapability(SystemCapabilityType.VIDEO_STREAMING);
87+
videoStreamingCapability = new VideoStreamingCapability();
88+
videoStreamingCapability.setMaxBitrate(Test.GENERAL_INT);
89+
videoStreamingCapability.setPreferredResolution(Test.GENERAL_IMAGERESOLUTION);
90+
videoStreamingCapability.setSupportedFormats(Test.GENERAL_VIDEOSTREAMINGFORMAT_LIST);
91+
systemCapability.setCapabilityForType(SystemCapabilityType.VIDEO_STREAMING, videoStreamingCapability);
7292
}
7393

7494
@Override
@@ -187,11 +207,14 @@ public void testGetVSCapability(){
187207

188208
systemCapabilityManager = new SystemCapabilityManager(new InternalSDLInterface() {
189209
@Override
190-
public void sendRPCRequest(RPCRequest message) {
210+
public void sendRPC(RPCMessage message) {
191211
GetSystemCapabilityResponse response = new GetSystemCapabilityResponse();
192212
response.setSystemCapability(referenceCapability);
193213
response.setSuccess(true);
194-
message.getOnRPCResponseListener().onResponse(CorrelationIdGenerator.generateId(), response);
214+
if (message instanceof RPCRequest) {
215+
RPCRequest request = (RPCRequest) message;
216+
request.getOnRPCResponseListener().onResponse(CorrelationIdGenerator.generateId(), response);
217+
}
195218
}
196219
});
197220

@@ -211,13 +234,268 @@ public void onError(String info) {
211234
});
212235
}
213236

237+
private Answer<Void> createOnSendGetSystemCapabilityAnswer (final boolean success, final Boolean subscribe) {
238+
Answer<Void> onSendGetSystemCapabilityAnswer = new Answer<Void>() {
239+
@Override
240+
public Void answer(InvocationOnMock invocation) {
241+
Object[] args = invocation.getArguments();
242+
GetSystemCapability getSystemCapability = (GetSystemCapability) args[0];
243+
if (subscribe != null) {
244+
assertEquals(subscribe, getSystemCapability.getSubscribe());
245+
}
246+
GetSystemCapabilityResponse response;
247+
if (success) {
248+
response = new GetSystemCapabilityResponse(Result.SUCCESS, true);
249+
} else {
250+
response = new GetSystemCapabilityResponse(Result.REJECTED, false);
251+
}
252+
response.setSystemCapability(systemCapability);
253+
getSystemCapability.getOnRPCResponseListener().onResponse(CorrelationIdGenerator.generateId(), response);
254+
return null;
255+
}
256+
};
257+
return onSendGetSystemCapabilityAnswer;
258+
}
259+
260+
public void testGetCapability() {
261+
ISdl internalInterface;
262+
SystemCapabilityManager scm;
263+
OnSystemCapabilityListener onSystemCapabilityListener;
264+
VideoStreamingCapability retrievedCapability;
265+
266+
267+
// Test case 1 (capability not cached, listener not null, forceUpdate false)
268+
internalInterface = mock(ISdl.class);
269+
scm = new SystemCapabilityManager(internalInterface);
270+
onSystemCapabilityListener = mock(OnSystemCapabilityListener.class);
271+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, null)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
272+
scm.setCapability(SystemCapabilityType.VIDEO_STREAMING, null);
273+
retrievedCapability = (VideoStreamingCapability) scm.getCapability(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener, false);
274+
assertNull(retrievedCapability);
275+
verify(internalInterface, times(1)).sendRPC(any(GetSystemCapability.class));
276+
verify(onSystemCapabilityListener, times(1)).onCapabilityRetrieved(any(Object.class));
277+
278+
279+
// Test case 2 (capability cached, listener not null, forceUpdate true)
280+
internalInterface = mock(ISdl.class);
281+
scm = new SystemCapabilityManager(internalInterface);
282+
onSystemCapabilityListener = mock(OnSystemCapabilityListener.class);
283+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, null)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
284+
scm.setCapability(SystemCapabilityType.VIDEO_STREAMING, videoStreamingCapability);
285+
retrievedCapability = (VideoStreamingCapability) scm.getCapability(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener, true);
286+
assertTrue(Test.TRUE, Validator.validateVideoStreamingCapability((VideoStreamingCapability) systemCapability.getCapabilityForType(SystemCapabilityType.VIDEO_STREAMING), retrievedCapability));
287+
verify(internalInterface, times(1)).sendRPC(any(GetSystemCapability.class));
288+
verify(onSystemCapabilityListener, times(1)).onCapabilityRetrieved(any(Object.class));
289+
290+
291+
// Test case 3 (capability cached, listener null, forceUpdate true)
292+
internalInterface = mock(ISdl.class);
293+
scm = new SystemCapabilityManager(internalInterface);
294+
onSystemCapabilityListener = null;
295+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, null)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
296+
scm.setCapability(SystemCapabilityType.VIDEO_STREAMING, videoStreamingCapability);
297+
retrievedCapability = (VideoStreamingCapability) scm.getCapability(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener, true);
298+
assertTrue(Test.TRUE, Validator.validateVideoStreamingCapability((VideoStreamingCapability) systemCapability.getCapabilityForType(SystemCapabilityType.VIDEO_STREAMING), retrievedCapability));
299+
verify(internalInterface, times(1)).sendRPC(any(GetSystemCapability.class));
300+
301+
302+
// Test case 4 (capability cached, listener null, forceUpdate false)
303+
internalInterface = mock(ISdl.class);
304+
scm = new SystemCapabilityManager(internalInterface);
305+
onSystemCapabilityListener = null;
306+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, null)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
307+
scm.setCapability(SystemCapabilityType.VIDEO_STREAMING, videoStreamingCapability);
308+
retrievedCapability = (VideoStreamingCapability) scm.getCapability(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener, false);
309+
assertTrue(Test.TRUE, Validator.validateVideoStreamingCapability((VideoStreamingCapability) systemCapability.getCapabilityForType(SystemCapabilityType.VIDEO_STREAMING), retrievedCapability));
310+
verify(internalInterface, times(0)).sendRPC(any(GetSystemCapability.class));
311+
}
312+
313+
public void testAddOnSystemCapabilityListenerWithSubscriptionsSupportedAndCapabilityCached() {
314+
SdlMsgVersion sdlMsgVersion = new SdlMsgVersion(6, 0); // This version supports capability subscriptions
315+
sdlMsgVersion.setPatchVersion(0);
316+
ISdl internalInterface = mock(ISdl.class);
317+
when(internalInterface.getSdlMsgVersion()).thenReturn(sdlMsgVersion);
318+
SystemCapabilityManager scm = new SystemCapabilityManager(internalInterface);
319+
scm.setCapability(SystemCapabilityType.VIDEO_STREAMING, videoStreamingCapability);
320+
321+
322+
// Add listener1
323+
// When the first listener is added, GetSystemCapability request should go out with subscribe=true
324+
OnSystemCapabilityListener onSystemCapabilityListener1 = mock(OnSystemCapabilityListener.class);
325+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, true)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
326+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener1);
327+
verify(internalInterface, times(1)).sendRPC(any(GetSystemCapability.class));
328+
verify(onSystemCapabilityListener1, times(1)).onCapabilityRetrieved(any(Object.class));
329+
330+
331+
// Add listener2
332+
OnSystemCapabilityListener onSystemCapabilityListener2 = mock(OnSystemCapabilityListener.class);
333+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener2);
334+
verify(onSystemCapabilityListener2, times(1)).onCapabilityRetrieved(any(Object.class));
335+
336+
337+
// Add listener3
338+
OnSystemCapabilityListener onSystemCapabilityListener3 = mock(OnSystemCapabilityListener.class);
339+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener3);
340+
verify(onSystemCapabilityListener3, times(1)).onCapabilityRetrieved(any(Object.class));
341+
342+
343+
// Remove listener1
344+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener1);
345+
346+
347+
// Remove listener2
348+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener2);
349+
350+
351+
// Remove listener3
352+
// When the last listener is removed, GetSystemCapability request should go out with subscribe=false
353+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, false)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
354+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener3);
355+
verify(internalInterface, times(2)).sendRPC(any(GetSystemCapability.class));
356+
}
357+
358+
public void testAddOnSystemCapabilityListenerWithSubscriptionsSupportedAndCapabilityNotCached() {
359+
SdlMsgVersion sdlMsgVersion = new SdlMsgVersion(6, 0); // This version supports capability subscriptions
360+
sdlMsgVersion.setPatchVersion(0);
361+
ISdl internalInterface = mock(ISdl.class);
362+
when(internalInterface.getSdlMsgVersion()).thenReturn(sdlMsgVersion);
363+
SystemCapabilityManager scm = new SystemCapabilityManager(internalInterface);
364+
scm.setCapability(SystemCapabilityType.VIDEO_STREAMING, null);
365+
366+
367+
// Add listener1
368+
// When the first listener is added, GetSystemCapability request should go out with subscribe=true
369+
OnSystemCapabilityListener onSystemCapabilityListener1 = mock(OnSystemCapabilityListener.class);
370+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, true)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
371+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener1);
372+
verify(internalInterface, times(1)).sendRPC(any(GetSystemCapability.class));
373+
verify(onSystemCapabilityListener1, times(1)).onCapabilityRetrieved(any(Object.class));
374+
375+
376+
// Add listener2
377+
OnSystemCapabilityListener onSystemCapabilityListener2 = mock(OnSystemCapabilityListener.class);
378+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener2);
379+
verify(onSystemCapabilityListener2, times(1)).onCapabilityRetrieved(any(Object.class));
380+
381+
382+
// Add listener3
383+
OnSystemCapabilityListener onSystemCapabilityListener3 = mock(OnSystemCapabilityListener.class);
384+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener3);
385+
verify(onSystemCapabilityListener3, times(1)).onCapabilityRetrieved(any(Object.class));
386+
387+
388+
// Remove listener1
389+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener1);
390+
391+
392+
// Remove listener2
393+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener2);
394+
395+
396+
// Remove listener3
397+
// When the last listener is removed, GetSystemCapability request should go out with subscribe=false
398+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, false)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
399+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener3);
400+
verify(internalInterface, times(2)).sendRPC(any(GetSystemCapability.class));
401+
}
402+
403+
public void testAddOnSystemCapabilityListenerWithSubscriptionsNotSupportedAndCapabilityCached() {
404+
SdlMsgVersion sdlMsgVersion = new SdlMsgVersion(5, 0); // This version doesn't support capability subscriptions
405+
sdlMsgVersion.setPatchVersion(0);
406+
ISdl internalInterface = mock(ISdl.class);
407+
when(internalInterface.getSdlMsgVersion()).thenReturn(sdlMsgVersion);
408+
SystemCapabilityManager scm = new SystemCapabilityManager(internalInterface);
409+
scm.setCapability(SystemCapabilityType.VIDEO_STREAMING, videoStreamingCapability);
410+
411+
412+
// Add listener1
413+
// When the first listener is added, GetSystemCapability request should not go out because subscription is not supported and the capability is cached
414+
OnSystemCapabilityListener onSystemCapabilityListener1 = mock(OnSystemCapabilityListener.class);
415+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, true)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
416+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener1);
417+
verify(internalInterface, times(0)).sendRPC(any(GetSystemCapability.class));
418+
verify(onSystemCapabilityListener1, times(1)).onCapabilityRetrieved(any(Object.class));
419+
420+
421+
// Add listener2
422+
OnSystemCapabilityListener onSystemCapabilityListener2 = mock(OnSystemCapabilityListener.class);
423+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener2);
424+
verify(onSystemCapabilityListener2, times(1)).onCapabilityRetrieved(any(Object.class));
425+
426+
427+
// Add listener3
428+
OnSystemCapabilityListener onSystemCapabilityListener3 = mock(OnSystemCapabilityListener.class);
429+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener3);
430+
verify(onSystemCapabilityListener3, times(1)).onCapabilityRetrieved(any(Object.class));
431+
432+
433+
// Remove listener1
434+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener1);
435+
436+
437+
// Remove listener2
438+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener2);
439+
440+
441+
// Remove listener3
442+
// When the last listener is removed, GetSystemCapability request should not go out because subscription is not supported
443+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, false)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
444+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener3);
445+
verify(internalInterface, times(0)).sendRPC(any(GetSystemCapability.class));
446+
}
447+
448+
public void testAddOnSystemCapabilityListenerWithSubscriptionsNotSupportedAndCapabilityNotCached() {
449+
SdlMsgVersion sdlMsgVersion = new SdlMsgVersion(5, 0); // This version doesn't support capability subscriptions
450+
sdlMsgVersion.setPatchVersion(0);
451+
ISdl internalInterface = mock(ISdl.class);
452+
when(internalInterface.getSdlMsgVersion()).thenReturn(sdlMsgVersion);
453+
SystemCapabilityManager scm = new SystemCapabilityManager(internalInterface);
454+
scm.setCapability(SystemCapabilityType.VIDEO_STREAMING, null);
455+
456+
457+
// Add listener1
458+
// When the first listener is added, GetSystemCapability request should out because because capability is not cached
459+
OnSystemCapabilityListener onSystemCapabilityListener1 = mock(OnSystemCapabilityListener.class);
460+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, true)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
461+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener1);
462+
verify(internalInterface, times(1)).sendRPC(any(GetSystemCapability.class));
463+
verify(onSystemCapabilityListener1, times(1)).onCapabilityRetrieved(any(Object.class));
464+
465+
466+
// Add listener2
467+
OnSystemCapabilityListener onSystemCapabilityListener2 = mock(OnSystemCapabilityListener.class);
468+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener2);
469+
verify(onSystemCapabilityListener2, times(1)).onCapabilityRetrieved(any(Object.class));
470+
471+
472+
// Add listener3
473+
OnSystemCapabilityListener onSystemCapabilityListener3 = mock(OnSystemCapabilityListener.class);
474+
scm.addOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener3);
475+
verify(onSystemCapabilityListener3, times(1)).onCapabilityRetrieved(any(Object.class));
476+
477+
478+
// Remove listener1
479+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener1);
480+
481+
482+
// Remove listener2
483+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener2);
484+
485+
486+
// Remove listener3
487+
// When the last listener is removed, GetSystemCapability request should not go out because subscription is not supported
488+
doAnswer(createOnSendGetSystemCapabilityAnswer(true, false)).when(internalInterface).sendRPC(any(GetSystemCapability.class));
489+
scm.removeOnSystemCapabilityListener(SystemCapabilityType.VIDEO_STREAMING, onSystemCapabilityListener3);
490+
verify(internalInterface, times(1)).sendRPC(any(GetSystemCapability.class));
491+
}
492+
214493
public void testListConversion(){
215494
SystemCapabilityManager systemCapabilityManager = createSampleManager();
216495
Object capability = systemCapabilityManager.getCapability(SystemCapabilityType.SOFTBUTTON);
217496
assertNotNull(capability);
218497
List<SoftButtonCapabilities> list = SystemCapabilityManager.convertToList(capability, SoftButtonCapabilities.class);
219498
assertNotNull(list);
220-
221499
}
222500

223501
public void testFalsePositive(){

0 commit comments

Comments
 (0)