method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
Merlin { public void bind() { merlinServiceBinder.bindService(); } Merlin(MerlinServiceBinder merlinServiceBinder, Registrar registrar); void setEndpoint(Endpoint endpoint, ResponseCodeValidator validator); void bind(); void unbind(); void registerConnectable(Connectable connectable); void registerDisconnectable(Disconnectable disconnectable); void registerBindable(Bindable bindable); }### Answer:
@Test public void whenBinding_thenBindsService() { merlin.bind(); verify(serviceBinder).bindService(); } |
### Question:
Merlin { public void unbind() { merlinServiceBinder.unbind(); registrar.clearRegistrations(); } Merlin(MerlinServiceBinder merlinServiceBinder, Registrar registrar); void setEndpoint(Endpoint endpoint, ResponseCodeValidator validator); void bind(); void unbind(); void registerConnectable(Connectable connectable); void registerDisconnectable(Disconnectable disconnectable); void registerBindable(Bindable bindable); }### Answer:
@Test public void whenUnbinding_thenUnbindsService() { merlin.unbind(); verify(serviceBinder).unbind(); }
@Test public void whenUnbinding_thenClearsRegistrations() { merlin.unbind(); verify(registrar).clearRegistrations(); } |
### Question:
Merlin { public void registerConnectable(Connectable connectable) { registrar.registerConnectable(connectable); } Merlin(MerlinServiceBinder merlinServiceBinder, Registrar registrar); void setEndpoint(Endpoint endpoint, ResponseCodeValidator validator); void bind(); void unbind(); void registerConnectable(Connectable connectable); void registerDisconnectable(Disconnectable disconnectable); void registerBindable(Bindable bindable); }### Answer:
@Test public void whenRegisteringConnectable_thenRegistersConnectable() { Connectable connectable = mock(Connectable.class); merlin.registerConnectable(connectable); verify(registrar).registerConnectable(connectable); } |
### Question:
Merlin { public void registerDisconnectable(Disconnectable disconnectable) { registrar.registerDisconnectable(disconnectable); } Merlin(MerlinServiceBinder merlinServiceBinder, Registrar registrar); void setEndpoint(Endpoint endpoint, ResponseCodeValidator validator); void bind(); void unbind(); void registerConnectable(Connectable connectable); void registerDisconnectable(Disconnectable disconnectable); void registerBindable(Bindable bindable); }### Answer:
@Test public void whenRegisteringDisconnectable_thenRegistersDisconnectable() { Disconnectable disconnectable = mock(Disconnectable.class); merlin.registerDisconnectable(disconnectable); verify(registrar).registerDisconnectable(disconnectable); } |
### Question:
Merlin { public void registerBindable(Bindable bindable) { registrar.registerBindable(bindable); } Merlin(MerlinServiceBinder merlinServiceBinder, Registrar registrar); void setEndpoint(Endpoint endpoint, ResponseCodeValidator validator); void bind(); void unbind(); void registerConnectable(Connectable connectable); void registerDisconnectable(Disconnectable disconnectable); void registerBindable(Bindable bindable); }### Answer:
@Test public void whenRegisteringBindable_thenRegistersBindable() { Bindable bindable = mock(Bindable.class); merlin.registerBindable(bindable); verify(registrar).registerBindable(bindable); } |
### Question:
ConnectivityChangeEventExtractor { ConnectivityChangeEvent extractFrom(Network network) { NetworkInfo networkInfo = connectivityManager.getNetworkInfo(network); if (null != networkInfo) { boolean connected = networkInfo.isConnected(); String reason = networkInfo.getReason(); String extraInfo = networkInfo.getExtraInfo(); return ConnectivityChangeEvent.createWithNetworkInfoChangeEvent(connected, extraInfo, reason); } else { return ConnectivityChangeEvent.createWithoutConnection(); } } ConnectivityChangeEventExtractor(ConnectivityManager connectivityManager); }### Answer:
@Test public void givenNetworkInfo_whenExtracting_thenReturnsConnectivityChangeEvent() { given(connectivityManager.getNetworkInfo(ANY_NETWORK)).willReturn(networkInfo); ConnectivityChangeEvent connectivityChangeEvent = eventExtractor.extractFrom(ANY_NETWORK); assertThat(connectivityChangeEvent).isEqualTo(ConnectivityChangeEvent.createWithNetworkInfoChangeEvent( CONNECTED, ANY_EXTRA_INFO, ANY_REASON )); }
@Test public void givenNetworkInfoIsUnavailable_whenExtracting_thenReturnsConnectivityChangeEventWithoutConnection() { given(connectivityManager.getNetworkInfo(ANY_NETWORK)).willReturn(UNAVAILABLE_NETWORK_INFO); ConnectivityChangeEvent connectivityChangeEvent = eventExtractor.extractFrom(ANY_NETWORK); assertThat(connectivityChangeEvent).isEqualTo(ConnectivityChangeEvent.createWithoutConnection()); } |
### Question:
EndpointPinger { void ping(PingerCallback pingerCallback) { PingTask pingTask = pingTaskFactory.create(endpoint, pingerCallback); pingTask.execute(); } EndpointPinger(Endpoint endpoint, PingTaskFactory pingTaskFactory); }### Answer:
@Test public void whenPinging_thenCreatesPingTask() { endpointPinger.ping(pingerCallback); verify(pingTaskFactory).create(ENDPOINT, pingerCallback); }
@Test public void whenPinging_thenExecutesPingTask() { endpointPinger.ping(pingerCallback); verify(pingTask).execute(); } |
### Question:
EndpointPinger { void noNetworkToPing(PingerCallback pingerCallback) { pingerCallback.onFailure(); } EndpointPinger(Endpoint endpoint, PingTaskFactory pingTaskFactory); }### Answer:
@Test public void whenNoNetworkToPing_thenCallsOnFailure() { endpointPinger.noNetworkToPing(pingerCallback); verify(pingerCallback).onFailure(); } |
### Question:
ConnectivityReceiverConnectivityChangeNotifier { void notify(Context context, Intent intent) { if (intent != null && connectivityActionMatchesActionFor(intent)) { MerlinsBeard merlinsBeard = merlinsBeardCreator.createMerlinsBeard(context); ConnectivityChangeEvent connectivityChangeEvent = creator.createFrom(intent, merlinsBeard); notifyMerlinService(context, connectivityChangeEvent); } } ConnectivityReceiverConnectivityChangeNotifier(ConnectivityReceiver.MerlinsBeardCreator merlinsBeardCreator,
ConnectivityReceiver.MerlinBinderRetriever merlinBinderRetriever,
ConnectivityChangeEventCreator creator); }### Answer:
@Test public void givenNullIntent_whenNotifying_thenNeverNotifiesOfConnectivityChangeEvent() { Intent intent = null; notifier.notify(context, intent); verify(connectivityChangesNotifier, never()).notify(any(ConnectivityChangeEvent.class)); }
@Test public void givenIntentWithoutConnectivityAction_whenNotifying_thenNeverNotifiesOfConnectivityChangeEvent() { Intent intent = givenIntentWithoutConnectivityAction(); notifier.notify(context, intent); verify(connectivityChangesNotifier, never()).notify(any(ConnectivityChangeEvent.class)); }
@Test public void givenIntentWithConnectivityAction_whenNotifying_thenNotifiesOfConnectivityChangeEvent() { Intent intent = givenIntentWithConnectivityAction(); notifier.notify(context, intent); verify(connectivityChangesNotifier).notify(ANY_CHANGE_EVENT); }
@Test public void givenIntentWithConnectivityAction_butNullBinder_whenNotifying_thenNeverNotifiesOfConnectivityChangeEvent() { Intent intent = givenIntentWithConnectivityAction(); given(merlinBinderRetriever.retrieveConnectivityChangesNotifier(context)).willReturn(null); notifier.notify(context, intent); verify(connectivityChangesNotifier, never()).notify(any(ConnectivityChangeEvent.class)); }
@Test public void givenIntentWithConnectivityAction_butIncorrectBinder_whenNotifying_thenNeverNotifiesOfConnectivityChangeEvent() { Intent intent = givenIntentWithConnectivityAction(); given(merlinBinderRetriever.retrieveConnectivityChangesNotifier(context)).willReturn(incorrectBinder()); notifier.notify(context, intent); verify(connectivityChangesNotifier, never()).notify(any(ConnectivityChangeEvent.class)); }
@Test public void givenIntentWithConnectivityAction_butCannotNotify_whenNotifying_thenNeverNotifiesOfConnectivityChangeEvent() { Intent intent = givenIntentWithConnectivityAction(); given(connectivityChangesNotifier.canNotify()).willReturn(CANNOT_NOTIFY); notifier.notify(context, intent); verify(connectivityChangesNotifier, never()).notify(any(ConnectivityChangeEvent.class)); } |
### Question:
Registrar { void registerConnectable(Connectable connectable) { connectables().register(connectable); } Registrar(Register<Connectable> connectables, Register<Disconnectable> disconnectables, Register<Bindable> bindables); }### Answer:
@Test(expected = IllegalStateException.class) public void givenMissingRegister_whenRegisteringConnectable_thenThrowsIllegalStateException() { registrar = new Registrar(null, null, null); Connectable connectable = mock(Connectable.class); registrar.registerConnectable(connectable); }
@Test public void givenRegister_whenRegisteringConnectable_thenRegistersConnectableWithConnector() { Connectable connectable = mock(Connectable.class); registrar.registerConnectable(connectable); verify(connectables).register(connectable); } |
### Question:
ConnectivityChangesRegister { void register(MerlinService.ConnectivityChangesNotifier connectivityChangesNotifier) { if (androidVersion.isLollipopOrHigher()) { registerNetworkCallbacks(connectivityChangesNotifier); } else { registerBroadcastReceiver(); } } ConnectivityChangesRegister(Context context,
ConnectivityManager connectivityManager,
AndroidVersion androidVersion,
ConnectivityChangeEventExtractor connectivityChangeEventExtractor); }### Answer:
@Test public void givenRegisteredBroadcastReceiver_whenBindingForASecondTime_thenOriginalBroadcastReceiverIsRegisteredAgain() { ArgumentCaptor<ConnectivityReceiver> broadcastReceiver = givenRegisteredBroadcastReceiver(); connectivityChangesRegister.register(connectivityChangesNotifier); verify(context, times(2)).registerReceiver(eq(broadcastReceiver.getValue()), refEq(new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION))); }
@TargetApi(Build.VERSION_CODES.LOLLIPOP) @Test public void givenRegisteredMerlinNetworkCallbacks_whenBindingForASecondTime_thenOriginalNetworkCallbacksIsRegisteredAgain() { ArgumentCaptor<ConnectivityCallbacks> merlinNetworkCallback = givenRegisteredMerlinNetworkCallbacks(); connectivityChangesRegister.register(connectivityChangesNotifier); verify(connectivityManager, times(2)).registerNetworkCallback(refEq((new NetworkRequest.Builder()).build()), eq(merlinNetworkCallback.getValue())); } |
### Question:
ConnectivityChangesRegister { void unregister() { if (androidVersion.isLollipopOrHigher()) { unregisterNetworkCallbacks(); } else { unregisterBroadcastReceiver(); } } ConnectivityChangesRegister(Context context,
ConnectivityManager connectivityManager,
AndroidVersion androidVersion,
ConnectivityChangeEventExtractor connectivityChangeEventExtractor); }### Answer:
@Test public void givenRegisteredBroadcastReceiver_whenUnbinding_thenUnregistersOriginallyRegisteredBroadcastReceiver() { ArgumentCaptor<ConnectivityReceiver> broadcastReceiver = givenRegisteredBroadcastReceiver(); connectivityChangesRegister.unregister(); verify(context).unregisterReceiver(broadcastReceiver.getValue()); }
@TargetApi(Build.VERSION_CODES.LOLLIPOP) @Test public void givenRegisteredMerlinNetworkCallback_whenUnbinding_thenUnregistersOriginallyRegisteredNetworkCallbacks() { ArgumentCaptor<ConnectivityCallbacks> merlinNetworkCallback = givenRegisteredMerlinNetworkCallbacks(); connectivityChangesRegister.unregister(); verify(connectivityManager).unregisterNetworkCallback(merlinNetworkCallback.getValue()); } |
### Question:
BindCallbackManager extends MerlinCallbackManager<Bindable> { void onMerlinBind(NetworkStatus networkStatus) { Logger.d("onBind"); for (Bindable bindable : registerables()) { bindable.onBind(networkStatus); } } BindCallbackManager(Register<Bindable> register); }### Answer:
@Test public void givenRegisteredConnectable_whenCallingOnConnect_thenCallsConnectForConnectable() { Bindable bindable = givenRegisteredBindable(); bindCallbackManager.onMerlinBind(networkStatus); verify(bindable).onBind(networkStatus); }
@Test public void givenMultipleRegisteredConnectables_whenCallingOnConnect_thenCallsConnectForAllConnectables() { List<Bindable> bindables = givenMultipleRegisteredBindables(); bindCallbackManager.onMerlinBind(networkStatus); for (Bindable bindable : bindables) { verify(bindable).onBind(networkStatus); } } |
### Question:
ConnectivityChangesForwarder { void forwardInitialNetworkStatus() { if (bindCallbackManager == null) { return; } if (hasPerformedEndpointPing()) { bindCallbackManager.onMerlinBind(lastEndpointPingNetworkStatus); return; } bindCallbackManager.onMerlinBind(networkStatusRetriever.retrieveNetworkStatus()); } ConnectivityChangesForwarder(NetworkStatusRetriever networkStatusRetriever,
DisconnectCallbackManager disconnectCallbackManager,
ConnectCallbackManager connectCallbackManager,
BindCallbackManager bindCallbackManager,
EndpointPinger endpointPinger); }### Answer:
@Test public void givenNetworkWasConnected_whenNotifyingOfInitialState_thenForwardsNetworkAvailableToListener() { givenNetworkWas(CONNECTED); connectivityChangesForwarder.forwardInitialNetworkStatus(); verify(bindCallbackManager).onMerlinBind(AVAILABLE_NETWORK); }
@Test public void givenNetworkWasDisconnected_whenNotifyingOfInitialState_thenForwardsNetworkUnavailableToListener() { givenNetworkWas(DISCONNECTED); connectivityChangesForwarder.forwardInitialNetworkStatus(); verify(bindCallbackManager).onMerlinBind(NetworkStatus.newUnavailableInstance()); }
@Test public void givenEndpointPingHasNotOccurred_whenNotifyingOfInitialState_thenForwardsNetworkAvailableToListener() { given(networkStatusRetriever.retrieveNetworkStatus()).willReturn(AVAILABLE_NETWORK); connectivityChangesForwarder.forwardInitialNetworkStatus(); verify(bindCallbackManager).onMerlinBind(AVAILABLE_NETWORK); }
@Test public void givenNetworkWasConnected_andNullBindListener_whenNotifyingOfInitialState_thenForwardsNetworkAvailableToListener() { connectivityChangesForwarder = new ConnectivityChangesForwarder( networkStatusRetriever, disconnectCallbackManager, connectCallbackManager, null, endpointPinger ); givenNetworkWas(CONNECTED); connectivityChangesForwarder.forwardInitialNetworkStatus(); verify(bindCallbackManager, never()).onMerlinBind(any(NetworkStatus.class)); }
@Test public void givenEndpointPingHasNotOccurred_andNullBindListener_whenNotifyingOfInitialState_thenForwardsNetworkAvailableToListener() { connectivityChangesForwarder = new ConnectivityChangesForwarder( networkStatusRetriever, disconnectCallbackManager, connectCallbackManager, null, endpointPinger ); given(networkStatusRetriever.retrieveNetworkStatus()).willReturn(AVAILABLE_NETWORK); connectivityChangesForwarder.forwardInitialNetworkStatus(); verify(bindCallbackManager, never()).onMerlinBind(any(NetworkStatus.class)); } |
### Question:
Registrar { void registerDisconnectable(Disconnectable disconnectable) { disconnectables().register(disconnectable); } Registrar(Register<Connectable> connectables, Register<Disconnectable> disconnectables, Register<Bindable> bindables); }### Answer:
@Test(expected = IllegalStateException.class) public void givenMissingRegister_thenRegisteringDisconnectable_thenThrowsIllegalStateException() { registrar = new Registrar(null, null, null); Disconnectable disconnectable = mock(Disconnectable.class); registrar.registerDisconnectable(disconnectable); }
@Test public void givenRegister_whenRegisteringDisconnectable_thenRegistersDisconnectableWithDisconnector() { Disconnectable disconnectable = mock(Disconnectable.class); registrar.registerDisconnectable(disconnectable); verify(this.disconnectables).register(disconnectable); } |
### Question:
ConnectivityChangesForwarder { void forward(ConnectivityChangeEvent connectivityChangeEvent) { if (matchesPreviousEndpointPingNetworkStatus(connectivityChangeEvent)) { return; } networkStatusRetriever.fetchWithPing(endpointPinger, endpointPingerCallback); lastEndpointPingNetworkStatus = connectivityChangeEvent.asNetworkStatus(); } ConnectivityChangesForwarder(NetworkStatusRetriever networkStatusRetriever,
DisconnectCallbackManager disconnectCallbackManager,
ConnectCallbackManager connectCallbackManager,
BindCallbackManager bindCallbackManager,
EndpointPinger endpointPinger); }### Answer:
@Test public void givenConnectivityChangeEvent_whenNotifyingOfConnectivityChangeEvent_thenDelegatesRefreshingToRetriever() { ConnectivityChangeEvent connectivityChangeEvent = ConnectivityChangeEvent.createWithNetworkInfoChangeEvent(CONNECTED, ANY_INFO, ANY_REASON); connectivityChangesForwarder.forward(connectivityChangeEvent); verify(networkStatusRetriever).fetchWithPing(eq(endpointPinger), any(EndpointPinger.PingerCallback.class)); } |
### Question:
ConnectivityReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { connectivityReceiverConnectivityChangeNotifier.notify(context, intent); } ConnectivityReceiver(); ConnectivityReceiver(ConnectivityReceiverConnectivityChangeNotifier connectivityReceiverConnectivityChangeNotifier); @Override void onReceive(Context context, Intent intent); }### Answer:
@Test public void whenReceivingAnIntent_thenForwardsToConnectivityChangeNotifier() { connectivityReceiver.onReceive(context, intent); verify(notifier).notify(context, intent); } |
### Question:
NetworkStatusRetriever { void fetchWithPing(EndpointPinger endpointPinger, EndpointPinger.PingerCallback pingerCallback) { if (merlinsBeard.isConnected()) { endpointPinger.ping(pingerCallback); } else { endpointPinger.noNetworkToPing(pingerCallback); } } NetworkStatusRetriever(MerlinsBeard merlinsBeard); }### Answer:
@Test public void givenMerlinsBeardIsConnected_whenFetchingWithPing_thenPingsUsingHostPinger() { given(merlinsBeards.isConnected()).willReturn(CONNECTED); networkStatusRetriever.fetchWithPing(endpointPinger, pingerCallback); verify(endpointPinger).ping(pingerCallback); }
@Test public void givenMerlinsBeardIsDisconnected_whenFetchingWithPing_thenCallsNoNetworkToPing() { given(merlinsBeards.isConnected()).willReturn(DISCONNECTED); networkStatusRetriever.fetchWithPing(endpointPinger, pingerCallback); verify(endpointPinger).noNetworkToPing(pingerCallback); } |
### Question:
NetworkStatusRetriever { NetworkStatus retrieveNetworkStatus() { if (merlinsBeard.isConnected()) { return NetworkStatus.newAvailableInstance(); } else { return NetworkStatus.newUnavailableInstance(); } } NetworkStatusRetriever(MerlinsBeard merlinsBeard); }### Answer:
@Test public void givenMerlinsBeardIsConnected_whenGettingNetworkStatus_thenReturnsNetworkStatusAvailable() { given(merlinsBeards.isConnected()).willReturn(CONNECTED); NetworkStatus networkStatus = networkStatusRetriever.retrieveNetworkStatus(); assertThat(networkStatus).isEqualTo(NetworkStatus.newAvailableInstance()); }
@Test public void givenMerlinsBeardIsDisconnected_whenGettingNetworkStatus_thenReturnsNetworkStatusUnavailable() { given(merlinsBeards.isConnected()).willReturn(DISCONNECTED); NetworkStatus networkStatus = networkStatusRetriever.retrieveNetworkStatus(); assertThat(networkStatus).isEqualTo(NetworkStatus.newUnavailableInstance()); } |
### Question:
Registrar { void registerBindable(Bindable bindable) { bindables().register(bindable); } Registrar(Register<Connectable> connectables, Register<Disconnectable> disconnectables, Register<Bindable> bindables); }### Answer:
@Test(expected = IllegalStateException.class) public void givenMissingRegister_whenRegisteringBindable_thenThrowsIllegalStateException() { registrar = new Registrar(null, null, null); Bindable bindable = mock(Bindable.class); registrar.registerBindable(bindable); }
@Test public void givenRegister_whenRegisteringBindable_thenRegistersBindableWithBinder() { Bindable bindable = mock(Bindable.class); registrar.registerBindable(bindable); verify(bindables).register(bindable); } |
### Question:
MerlinsBeard { public boolean isConnected() { NetworkInfo activeNetworkInfo = networkInfo(); return activeNetworkInfo != null && activeNetworkInfo.isConnected(); } MerlinsBeard(ConnectivityManager connectivityManager, AndroidVersion androidVersion, EndpointPinger captivePortalPinger, Ping CaptivePortalPing); @Deprecated static MerlinsBeard from(Context context); boolean isConnected(); boolean isConnectedToMobileNetwork(); boolean isConnectedToWifi(); String getMobileNetworkSubtypeName(); void hasInternetAccess(final InternetAccessCallback callback); @WorkerThread boolean hasInternetAccess(); }### Answer:
@Test public void givenNetworkIsDisconnected_whenCheckingForConnectivity_thenReturnsFalse() { given(connectivityManager.getActiveNetworkInfo()).willReturn(networkInfo); given(networkInfo.isConnected()).willReturn(DISCONNECTED); boolean connected = merlinsBeard.isConnected(); assertThat(connected).isFalse(); }
@Test public void givenNetworkIsNull_whenCheckingForConnectivity_thenReturnsFalse() { given(connectivityManager.getActiveNetworkInfo()).willReturn(null); boolean connected = merlinsBeard.isConnected(); assertThat(connected).isFalse(); }
@Test public void givenNetworkIsConnected_whenCheckingForConnectivity_thenReturnsTrue() { given(connectivityManager.getActiveNetworkInfo()).willReturn(networkInfo); given(networkInfo.isConnected()).willReturn(CONNECTED); boolean connected = merlinsBeard.isConnected(); assertThat(connected).isTrue(); } |
### Question:
MerlinsBeard { public boolean isConnectedToWifi() { return isConnectedTo(ConnectivityManager.TYPE_WIFI); } MerlinsBeard(ConnectivityManager connectivityManager, AndroidVersion androidVersion, EndpointPinger captivePortalPinger, Ping CaptivePortalPing); @Deprecated static MerlinsBeard from(Context context); boolean isConnected(); boolean isConnectedToMobileNetwork(); boolean isConnectedToWifi(); String getMobileNetworkSubtypeName(); void hasInternetAccess(final InternetAccessCallback callback); @WorkerThread boolean hasInternetAccess(); }### Answer:
@Test public void givenNetworkIsConnectedViaWifi_andAndroidVersionIsBelowLollipop_whenCheckingIfConnectedToWifi_thenReturnsTrue() { givenNetworkStateForBelowLollipop(CONNECTED, ConnectivityManager.TYPE_WIFI); boolean connectedToWifi = merlinsBeard.isConnectedToWifi(); assertThat(connectedToWifi).isTrue(); }
@Test public void givenNetworkIsDisconnected_andAndroidVersionIsBelowLollipop_whenCheckingIfConnectedToWifi_thenReturnsFalse() { givenNetworkStateForBelowLollipop(DISCONNECTED, ConnectivityManager.TYPE_WIFI); boolean connectedToWifi = merlinsBeard.isConnectedToWifi(); assertThat(connectedToWifi).isFalse(); }
@TargetApi(Build.VERSION_CODES.LOLLIPOP) @Test public void givenNetworkIsConnectedViaWifi_andAndroidVersionIsLollipopOrAbove_whenCheckingIfConnectedToWifi_thenReturnsTrue() { givenNetworkStateForLollipopOrAbove(CONNECTED, ConnectivityManager.TYPE_WIFI); boolean connectedToWifi = merlinsBeard.isConnectedToWifi(); assertThat(connectedToWifi).isTrue(); }
@TargetApi(Build.VERSION_CODES.LOLLIPOP) @Test public void givenNetworkIsDisconnected_andAndroidVersionIsLollipopOrAbove_whenCheckingIfConnectedToWifi_thenReturnsFalse() { givenNetworkStateForLollipopOrAbove(DISCONNECTED, ConnectivityManager.TYPE_WIFI); boolean connectedToWifi = merlinsBeard.isConnectedToWifi(); assertThat(connectedToWifi).isFalse(); }
@Test public void givenNetworkConnectivityInfoIsUnavailable_andAndroidVersionIsBelowLollipop_whenCheckingIfConnectedToWifi_thenReturnsFalse() { given(androidVersion.isLollipopOrHigher()).willReturn(BELOW_LOLLIPOP); given(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)).willReturn(null); boolean connectedToWifi = merlinsBeard.isConnectedToWifi(); assertThat(connectedToWifi).isFalse(); }
@TargetApi(Build.VERSION_CODES.LOLLIPOP) @Test public void givenNetworkConnectivityInfoIsUnavailable_andAndroidVersionIsLollipopOrAbove_whenCheckingIfConnectedToWifi_thenReturnsFalse() { given(androidVersion.isLollipopOrHigher()).willReturn(LOLLIPOP_OR_ABOVE); given(connectivityManager.getAllNetworks()).willReturn(new Network[]{}); boolean connectedToWifi = merlinsBeard.isConnectedToWifi(); assertThat(connectedToWifi).isFalse(); } |
### Question:
MerlinsBeard { public boolean isConnectedToMobileNetwork() { return isConnectedTo(ConnectivityManager.TYPE_MOBILE); } MerlinsBeard(ConnectivityManager connectivityManager, AndroidVersion androidVersion, EndpointPinger captivePortalPinger, Ping CaptivePortalPing); @Deprecated static MerlinsBeard from(Context context); boolean isConnected(); boolean isConnectedToMobileNetwork(); boolean isConnectedToWifi(); String getMobileNetworkSubtypeName(); void hasInternetAccess(final InternetAccessCallback callback); @WorkerThread boolean hasInternetAccess(); }### Answer:
@Test public void givenNetworkIsConnectedViaMobile_andAndroidVersionIsBelowLollipop_whenCheckingIfConnectedToMobile_thenReturnsTrue() { givenNetworkStateForBelowLollipop(CONNECTED, ConnectivityManager.TYPE_MOBILE); boolean connectedToMobileNetwork = merlinsBeard.isConnectedToMobileNetwork(); assertThat(connectedToMobileNetwork).isTrue(); }
@Test public void givenNetworkIsDisconnected_andAndroidVersionIsBelowLollipop_whenCheckingIfConnectedToMobile_thenReturnsFalse() { givenNetworkStateForBelowLollipop(DISCONNECTED, ConnectivityManager.TYPE_WIFI); boolean connectedToMobileNetwork = merlinsBeard.isConnectedToMobileNetwork(); assertThat(connectedToMobileNetwork).isFalse(); }
@TargetApi(Build.VERSION_CODES.LOLLIPOP) @Test public void givenNetworkIsConnectedViaMobile_andAndroidVersionIsLollipopOrAbove_whenCheckingIfConnectedToMobile_thenReturnsTrue() { givenNetworkStateForLollipopOrAbove(CONNECTED, ConnectivityManager.TYPE_MOBILE); boolean connectedToMobileNetwork = merlinsBeard.isConnectedToMobileNetwork(); assertThat(connectedToMobileNetwork).isTrue(); }
@TargetApi(Build.VERSION_CODES.LOLLIPOP) @Test public void givenNetworkIsDisconnected_andAndroidVersionIsLollipopOrAbove_whenCheckingIfConnectedToMobile_thenReturnsFalse() { givenNetworkStateForLollipopOrAbove(DISCONNECTED, ConnectivityManager.TYPE_MOBILE); boolean connectedToMobileNetwork = merlinsBeard.isConnectedToMobileNetwork(); assertThat(connectedToMobileNetwork).isFalse(); }
@Test public void givenNetworkConnectivityInfoIsUnavailable_andAndroidVersionIsLollipopOrAbove_whenCheckingIfConnectedToMobile_thenReturnsFalse() { given(androidVersion.isLollipopOrHigher()).willReturn(false); given(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE)).willReturn(null); boolean connectedToWifi = merlinsBeard.isConnectedToMobileNetwork(); assertThat(connectedToWifi).isFalse(); }
@TargetApi(Build.VERSION_CODES.LOLLIPOP) @Test public void givenNoAvailableNetworks_andAndroidVersionIsLollipopOrAbove_whenCheckingIfConnectedToMobile_thenReturnsFalse() { given(androidVersion.isLollipopOrHigher()).willReturn(true); given(connectivityManager.getAllNetworks()).willReturn(new Network[]{}); boolean connectedToWifi = merlinsBeard.isConnectedToMobileNetwork(); assertThat(connectedToWifi).isFalse(); }
@TargetApi(Build.VERSION_CODES.LOLLIPOP) @Test public void givenNetworkWithoutNetworkInfo_andAndroidVersionIsLollipopOrAbove_whenCheckingIfConnectedToMobile_thenReturnsFalse() { givenNetworkStateWithoutNetworkInfoForLollipopOrAbove(); boolean connectedToMobileNetwork = merlinsBeard.isConnectedToMobileNetwork(); assertThat(connectedToMobileNetwork).isFalse(); } |
### Question:
MerlinsBeard { public void hasInternetAccess(final InternetAccessCallback callback) { captivePortalPinger.ping(new EndpointPinger.PingerCallback() { @Override public void onSuccess() { callback.onResult(true); } @Override public void onFailure() { callback.onResult(false); } }); } MerlinsBeard(ConnectivityManager connectivityManager, AndroidVersion androidVersion, EndpointPinger captivePortalPinger, Ping CaptivePortalPing); @Deprecated static MerlinsBeard from(Context context); boolean isConnected(); boolean isConnectedToMobileNetwork(); boolean isConnectedToWifi(); String getMobileNetworkSubtypeName(); void hasInternetAccess(final InternetAccessCallback callback); @WorkerThread boolean hasInternetAccess(); }### Answer:
@Test public void givenSuccessfulPing_whenCheckingCaptivePortal_thenCallsOnResultWithTrue() { willAnswer(new Answer<EndpointPinger.PingerCallback>() { @Override public EndpointPinger.PingerCallback answer(InvocationOnMock invocation) { EndpointPinger.PingerCallback cb = invocation.getArgument(0); cb.onSuccess(); return cb; } }).given(endpointPinger).ping(any(EndpointPinger.PingerCallback.class)); merlinsBeard.hasInternetAccess(mockCaptivePortalCallback); then(mockCaptivePortalCallback).should().onResult(true); }
@Test public void givenFailurePing_whenCheckingCaptivePortal_thenCallsOnResultWithFalse() { willAnswer(new Answer<EndpointPinger.PingerCallback>() { @Override public EndpointPinger.PingerCallback answer(InvocationOnMock invocation) { EndpointPinger.PingerCallback cb = invocation.getArgument(0); cb.onFailure(); return cb; } }).given(endpointPinger).ping(any(EndpointPinger.PingerCallback.class)); merlinsBeard.hasInternetAccess(mockCaptivePortalCallback); then(mockCaptivePortalCallback).should().onResult(false); }
@Test public void givenSuccessfulPing_whenCheckingHasInternetAccessSync_thenReturnsTrue() { given(mockPing.doSynchronousPing()).willReturn(true); boolean result = merlinsBeard.hasInternetAccess(); assertThat(result).isTrue(); }
@Test public void givenFailedPing_whenCheckingHasInternetAccessSync_thenReturnsFalse() { given(mockPing.doSynchronousPing()).willReturn(false); boolean result = merlinsBeard.hasInternetAccess(); assertThat(result).isFalse(); } |
### Question:
DisconnectCallbackManager extends MerlinCallbackManager<Disconnectable> implements Disconnectable { @Override public void onDisconnect() { Logger.d("onDisconnect"); for (Disconnectable disconnectable : registerables()) { disconnectable.onDisconnect(); } } DisconnectCallbackManager(Register<Disconnectable> register); @Override void onDisconnect(); }### Answer:
@Test public void givenRegisteredDisconnectable_whenCallingOnDisconect_thenCallsDisconnectForDisconnectable() { Disconnectable disconnectable = givenRegisteredDisconnectable(); disconnectCallbackManager.onDisconnect(); verify(disconnectable).onDisconnect(); }
@Test public void givenMultipleRegisteredDisconnectables_whenCallingOnConnect_thenCallsConnectForAllDisconnectables() { List<Disconnectable> disconnectables = givenMultipleRegisteredDisconnectables(); disconnectCallbackManager.onDisconnect(); for (Disconnectable disconnectable : disconnectables) { verify(disconnectable).onDisconnect(); } } |
### Question:
ConnectivityChangeEventCreator { ConnectivityChangeEvent createFrom(Intent intent, MerlinsBeard merlinsBeard) { boolean isConnected = extractIsConnectedFrom(intent, merlinsBeard); String info = intent.getStringExtra(ConnectivityManager.EXTRA_EXTRA_INFO); String reason = intent.getStringExtra(ConnectivityManager.EXTRA_REASON); return ConnectivityChangeEvent.createWithNetworkInfoChangeEvent(isConnected, info, reason); } }### Answer:
@Test public void givenIntentWithNoConnectivityOfConnected_whenCreatingAConnectivityChangeEvent_thenReturnsConnectedConnectivityChangeEvent() { givenIntentWithNoConnectivityExtraOf(CONNECTED); ConnectivityChangeEvent connectivityChangeEvent = creator.createFrom(intent, merlinsBeard); ConnectivityChangeEvent expectedConnectivityChangeEvent = ConnectivityChangeEvent.createWithNetworkInfoChangeEvent( CONNECTED, ANY_INFO, ANY_REASON ); assertThat(connectivityChangeEvent).isEqualTo(expectedConnectivityChangeEvent); }
@Test public void givenIntentWithNoConnectivityOfDisconnected_whenCreatingAConnectivityChangeEvent_thenReturnsDisconnectedConnectivityChangeEvent() { givenIntentWithNoConnectivityExtraOf(DISCONNECTED); ConnectivityChangeEvent connectivityChangeEvent = creator.createFrom(intent, merlinsBeard); ConnectivityChangeEvent expectedConnectivityChangeEvent = ConnectivityChangeEvent.createWithNetworkInfoChangeEvent( DISCONNECTED, ANY_INFO, ANY_REASON ); assertThat(connectivityChangeEvent).isEqualTo(expectedConnectivityChangeEvent); }
@Test public void givenMerlinsBeardIsConnected_whenCreatingAConnectivityChangeEvent_thenReturnsConnectedConnectivityChangeEvent() { givenMerlinsBeardIs(CONNECTED); ConnectivityChangeEvent connectivityChangeEvent = creator.createFrom(intent, merlinsBeard); ConnectivityChangeEvent expectedConnectivityChangeEvent = ConnectivityChangeEvent.createWithNetworkInfoChangeEvent( CONNECTED, ANY_INFO, ANY_REASON ); assertThat(connectivityChangeEvent).isEqualTo(expectedConnectivityChangeEvent); }
@Test public void givenMerlinsBeardIsDisconnected_whenCreatingAConnectivityChangeEvent_thenReturnsDisconnectedConnectivityChangeEvent() { givenMerlinsBeardIs(DISCONNECTED); ConnectivityChangeEvent connectivityChangeEvent = creator.createFrom(intent, merlinsBeard); ConnectivityChangeEvent expectedConnectivityChangeEvent = ConnectivityChangeEvent.createWithNetworkInfoChangeEvent( DISCONNECTED, ANY_INFO, ANY_REASON ); assertThat(connectivityChangeEvent).isEqualTo(expectedConnectivityChangeEvent); } |
### Question:
ConnectCallbackManager extends MerlinCallbackManager<Connectable> { void onConnect() { Logger.d("onConnect"); for (Connectable connectable : registerables()) { connectable.onConnect(); } } ConnectCallbackManager(Register<Connectable> register); }### Answer:
@Test public void givenRegisteredConnectable_whenCallingOnConnect_thenCallsConnectForConnectable() { Connectable connectable = givenRegisteredConnectable(); connectCallbackManager.onConnect(); verify(connectable).onConnect(); }
@Test public void givenMultipleRegisteredConnectables_whenCallingOnConnect_thenCallsConnectForAllConnectables() { List<Connectable> connectables = givenMultipleRegisteredConnectables(); connectCallbackManager.onConnect(); for (Connectable connectable : connectables) { verify(connectable).onConnect(); } }
@Test public void givenRegisteredConnectable_whenCallingOnConnectAndAddingConnectable_thenCallsConnectForConnectable() { Connectable connectable = givenRegisteredConnectableModifyingConnectables(); connectCallbackManager.onConnect(); verify(connectable).onConnect(); } |
### Question:
MerlinService extends Service { public static boolean isBound() { return isBound; } static boolean isBound(); @Override IBinder onBind(Intent intent); @Override boolean onUnbind(Intent intent); }### Answer:
@Test public void givenOnBindHasBeenCalled_whenCheckingIsBound_thenReturnsTrue() { givenBoundMerlinService(); boolean bound = MerlinService.isBound(); assertThat(bound).isTrue(); } |
### Question:
MerlinService extends Service { @Override public boolean onUnbind(Intent intent) { isBound = false; if (connectivityChangesRegister != null) { connectivityChangesRegister.unregister(); connectivityChangesRegister = null; } if (connectivityChangesForwarder != null) { connectivityChangesForwarder = null; } binder = null; return super.onUnbind(intent); } static boolean isBound(); @Override IBinder onBind(Intent intent); @Override boolean onUnbind(Intent intent); }### Answer:
@Test public void givenBoundMerlinService_whenCallingOnUnbind_thenUnregistersConnectivityChangesRegister() { givenBoundMerlinService(); merlinService.onUnbind(intent); verify(connectivityChangesRegister).unregister(); }
@Test public void givenUnboundService_whenNotifying_thenDoesNotForwardEvent() { MerlinService.LocalBinder localBinder = givenBoundMerlinService(); merlinService.onUnbind(null); localBinder.notify(ANY_CONNECTIVITY_CHANGE_EVENT); verifyZeroInteractions(connectivityChangesForwarder); } |
### Question:
MerlinService extends Service { @Override public IBinder onBind(Intent intent) { isBound = true; return binder; } static boolean isBound(); @Override IBinder onBind(Intent intent); @Override boolean onUnbind(Intent intent); }### Answer:
@Test public void givenConnectivityChangesRegisterIsNotBound_whenBindCompletes_thenThrowsException_andStopsWorkOnService() { thrown.expect(MerlinServiceDependencyMissingExceptionMatcher.from(ConnectivityChangesRegister.class)); MerlinService.LocalBinder binder = (MerlinService.LocalBinder) merlinService.onBind(intent); binder.setConnectivityChangesForwarder(connectivityChangesForwarder); binder.onBindComplete(); verifyZeroInteractions(connectivityChangesRegister); verifyZeroInteractions(connectivityChangesForwarder); }
@Test public void givenConnectivityChangesForwarderIsNotBound_whenBindCompletes_thenThrowsException_andStopsWorkOnService() { thrown.expect(MerlinServiceDependencyMissingExceptionMatcher.from(ConnectivityChangesForwarder.class)); MerlinService.LocalBinder binder = (MerlinService.LocalBinder) merlinService.onBind(intent); binder.setConnectivityChangesRegister(connectivityChangesRegister); binder.onBindComplete(); verifyZeroInteractions(connectivityChangesRegister); verifyZeroInteractions(connectivityChangesForwarder); } |
### Question:
ConnectivityCallbacks extends ConnectivityManager.NetworkCallback { @Override public void onAvailable(Network network) { notifyMerlinService(network); } ConnectivityCallbacks(MerlinService.ConnectivityChangesNotifier connectivityChangesNotifier,
ConnectivityChangeEventExtractor connectivityChangeEventExtractor); @Override void onAvailable(Network network); @Override void onLosing(Network network, int maxMsToLive); @Override void onLost(Network network); }### Answer:
@Test public void givenConnectedNetworkInfo_whenNetworkIsAvailable_thenNotifiesOfConnectedNetwork() { NetworkInfo networkInfo = givenNetworkInfoWith(CONNECTED, ANY_REASON, ANY_EXTRA_INFO); networkCallbacks.onAvailable(network); verify(connectivityChangesNotifier).notify(ConnectivityChangeEvent.createWithNetworkInfoChangeEvent( networkInfo.isConnected(), networkInfo.getExtraInfo(), networkInfo.getReason() )); }
@Test public void givenNoNetworkInfo_whenNetworkIsAvailable_thenNotifiesOfConnectedNetwork() { networkCallbacks.onAvailable(network); verify(connectivityChangesNotifier).notify(ConnectivityChangeEvent.createWithoutConnection()); }
@Test public void givenCannotNotify_whenNetworkIsAvailable_thenNeverNotifiesConnectivityChangeEvent() { given(connectivityChangesNotifier.canNotify()).willReturn(CANNOT_NOTIFY); networkCallbacks.onAvailable(MISSING_NETWORK); InOrder inOrder = inOrder(connectivityChangesNotifier); inOrder.verify(connectivityChangesNotifier).canNotify(); inOrder.verifyNoMoreInteractions(); } |
### Question:
ConnectivityCallbacks extends ConnectivityManager.NetworkCallback { @Override public void onLosing(Network network, int maxMsToLive) { notifyMerlinService(network); } ConnectivityCallbacks(MerlinService.ConnectivityChangesNotifier connectivityChangesNotifier,
ConnectivityChangeEventExtractor connectivityChangeEventExtractor); @Override void onAvailable(Network network); @Override void onLosing(Network network, int maxMsToLive); @Override void onLost(Network network); }### Answer:
@Test public void givenDisconnectedNetworkInfo_whenLosingNetwork_thenNotifiesOfDisconnectedNetwork() { NetworkInfo networkInfo = givenNetworkInfoWith(DISCONNECTED, ANY_REASON, ANY_EXTRA_INFO); networkCallbacks.onLosing(network, MAX_MS_TO_LIVE); verify(connectivityChangesNotifier).notify(ConnectivityChangeEvent.createWithNetworkInfoChangeEvent( networkInfo.isConnected(), networkInfo.getExtraInfo(), networkInfo.getReason() )); }
@Test public void givenNoNetworkInfo_whenLosingNetwork_thenNotifiesOfDisconnectedNetwork() { networkCallbacks.onLosing(network, MAX_MS_TO_LIVE); verify(connectivityChangesNotifier).notify(ConnectivityChangeEvent.createWithoutConnection()); }
@Test public void givenCannotNotify_whenLosingNetwork_thenNeverNotifiesConnectivityChangeEvent() { given(connectivityChangesNotifier.canNotify()).willReturn(CANNOT_NOTIFY); networkCallbacks.onLosing(MISSING_NETWORK, MAX_MS_TO_LIVE); InOrder inOrder = inOrder(connectivityChangesNotifier); inOrder.verify(connectivityChangesNotifier).canNotify(); inOrder.verifyNoMoreInteractions(); } |
### Question:
ConnectivityCallbacks extends ConnectivityManager.NetworkCallback { @Override public void onLost(Network network) { notifyMerlinService(network); } ConnectivityCallbacks(MerlinService.ConnectivityChangesNotifier connectivityChangesNotifier,
ConnectivityChangeEventExtractor connectivityChangeEventExtractor); @Override void onAvailable(Network network); @Override void onLosing(Network network, int maxMsToLive); @Override void onLost(Network network); }### Answer:
@Test public void givenDisconnectedNetworkInfo_whenNetworkIsLost_thenNotifiesOfLostNetwork() { NetworkInfo networkInfo = givenNetworkInfoWith(DISCONNECTED, ANY_REASON, ANY_EXTRA_INFO); networkCallbacks.onLost(network); verify(connectivityChangesNotifier).notify(ConnectivityChangeEvent.createWithNetworkInfoChangeEvent( networkInfo.isConnected(), networkInfo.getExtraInfo(), networkInfo.getReason() )); }
@Test public void givenNoNetworkInfo_whenNetworkIsLost_thenNotifiesOfLostNetwork() { networkCallbacks.onLost(network); verify(connectivityChangesNotifier).notify(ConnectivityChangeEvent.createWithoutConnection()); }
@Test public void givenCannotNotify_whenNetworkIsLost_thenNeverNotifiesConnectivityChangeEvent() { given(connectivityChangesNotifier.canNotify()).willReturn(CANNOT_NOTIFY); networkCallbacks.onLost(MISSING_NETWORK); InOrder inOrder = inOrder(connectivityChangesNotifier); inOrder.verify(connectivityChangesNotifier).canNotify(); inOrder.verifyNoMoreInteractions(); } |
### Question:
MerlinObservable { public static Observable<NetworkStatus> from(Context context) { return from(context, new Merlin.Builder()); } static Observable<NetworkStatus> from(Context context); static Observable<NetworkStatus> from(Context context, MerlinBuilder merlinBuilder); static Observable<NetworkStatus> from(Merlin merlin); }### Answer:
@Test public void unbindWhenUnsubscribed() { Subscription subscription = MerlinObservable.from(merlin) .subscribe(); subscription.unsubscribe(); verify(merlin).unbind(); }
@Test public void notCrashWhenCreatingWithAMerlinBuilderWithoutCallbacks() { Context context = mock(Context.class); Merlin.Builder merlinBuilder = new Merlin.Builder(); MerlinObservable.from(context, merlinBuilder).subscribe(); } |
### Question:
OktaManagementActivity extends Activity { static PendingIntent createStartIntent( Context context, PendingIntent completeIntent, PendingIntent cancelIntent) { Intent tokenExchangeIntent = new Intent(context, OktaManagementActivity.class); tokenExchangeIntent.putExtra(KEY_COMPLETE_INTENT, completeIntent); tokenExchangeIntent.putExtra(KEY_CANCEL_INTENT, cancelIntent); return PendingIntent.getActivity(context, 0, tokenExchangeIntent, PendingIntent.FLAG_UPDATE_CURRENT); } }### Answer:
@Test public void testOnCreateShouldExtractStateFromIntent() throws JSONException { OktaManagementActivity activity = Robolectric.buildActivity( OktaManagementActivity.class, createStartIntent() ).create().get(); assertThat(activity.mCompleteIntent).isEqualTo(this.mCompleteIntent); assertThat(activity.mCancelIntent).isEqualTo(this.mCancelIntent); }
@Test public void testOnStartShouldSignOutIfConfigurationHasChanged() throws CanceledException, JSONException { Context context = RuntimeEnvironment.application.getApplicationContext(); new OAuthClientConfiguration( context, context.getSharedPreferences(OAuthClientConfiguration.PREFS_NAME, MODE_PRIVATE), ConfigurationStreams.getOtherConfiguration() ); doNothing().when(mCancelIntent).send(); OktaManagementActivity activity = Robolectric.buildActivity( OktaManagementActivity.class ).newIntent(createStartIntent()).create().start().get(); assertThat(activity.isFinishing()).isTrue(); }
@Test public void testOnStartShouldCompleteIfStateIsAuthorized() throws CanceledException, JSONException { Context context = RuntimeEnvironment.application.getApplicationContext(); AuthStateManager stateManager = AuthStateManager.getInstance(context); stateManager.replace(mAuthState); when(mAuthState.isAuthorized()).thenReturn(true); doNothing().when(mCompleteIntent).send(); OktaManagementActivity activity = Robolectric.buildActivity( OktaManagementActivity.class, createStartIntent() ).create().start().get(); assertThat(activity.isFinishing()).isTrue(); } |
### Question:
AuthStateManager { @AnyThread @NonNull @VisibleForTesting AuthState readState() { mPrefsLock.lock(); try { String currentState = mPrefs.getString(KEY_STATE, null); if (currentState == null) { return new AuthState(); } try { return AuthState.jsonDeserialize(currentState); } catch (JSONException ex) { Log.w(TAG, "Failed to deserialize stored auth state - discarding"); return new AuthState(); } } finally { mPrefsLock.unlock(); } } @VisibleForTesting AuthStateManager(SharedPreferences prefs, ReentrantLock prefsLock); @AnyThread static AuthStateManager getInstance(@NonNull Context context); @AnyThread @NonNull AuthState getCurrent(); @AnyThread @NonNull AuthState replace(@NonNull AuthState state); @AnyThread @NonNull AuthState updateAfterAuthorization(
@Nullable AuthorizationResponse response,
@Nullable AuthorizationException ex); @AnyThread @NonNull AuthState updateAfterTokenResponse(
@Nullable TokenResponse response,
@Nullable AuthorizationException ex); }### Answer:
@Test public void testReadStateLocksPreferencesBeforeActing() { assertThat(mPrefs.contains(KEY_STATE)).isFalse(); mPrefsLock.lock(); try { sut.readState(); fail("Expected " + IllegalStateException.class.getSimpleName() + " to be thrown"); } catch (IllegalStateException e) { assertThat(mPrefsLock.getHoldCount()).isEqualTo(1); } mPrefsLock.unlock(); assertThat(sut.readState()).isNotNull(); assertThat(mPrefsLock.getHoldCount()).isEqualTo(0); assertThat(mPrefs.contains(KEY_STATE)).isFalse(); } |
### Question:
AuthStateManager { @AnyThread @VisibleForTesting void writeState(@Nullable AuthState state) { mPrefsLock.lock(); try { SharedPreferences.Editor editor = mPrefs.edit(); if (state == null) { editor.remove(KEY_STATE); } else { editor.putString(KEY_STATE, state.jsonSerializeString()); } if (!editor.commit()) { throw new IllegalStateException("Failed to write state to shared prefs"); } } finally { mPrefsLock.unlock(); } } @VisibleForTesting AuthStateManager(SharedPreferences prefs, ReentrantLock prefsLock); @AnyThread static AuthStateManager getInstance(@NonNull Context context); @AnyThread @NonNull AuthState getCurrent(); @AnyThread @NonNull AuthState replace(@NonNull AuthState state); @AnyThread @NonNull AuthState updateAfterAuthorization(
@Nullable AuthorizationResponse response,
@Nullable AuthorizationException ex); @AnyThread @NonNull AuthState updateAfterTokenResponse(
@Nullable TokenResponse response,
@Nullable AuthorizationException ex); }### Answer:
@Test public void testWriteStateLocksPreferencesBeforeActing() { assertThat(mPrefs.contains(KEY_STATE)).isFalse(); mPrefsLock.lock(); try { sut.writeState(new AuthState()); fail("Expected " + IllegalStateException.class.getSimpleName() + " to be thrown"); } catch (IllegalStateException e) { assertThat(mPrefsLock.getHoldCount()).isEqualTo(1); assertThat(mPrefs.contains(KEY_STATE)).isFalse(); } mPrefsLock.unlock(); sut.writeState(new AuthState()); assertThat(mPrefsLock.getHoldCount()).isEqualTo(0); assertThat(mPrefs.getString(KEY_STATE, null)).isNotNull(); }
@Test public void testWriteStateRemovesKeyWhenWritingNull() { sut.writeState(new AuthState()); assertThat(mPrefs.getString(KEY_STATE, null)).isNotNull(); sut.writeState(null); assertThat(mPrefs.contains(KEY_STATE)).isFalse(); } |
### Question:
OktaAppAuth { public void refreshAccessToken(final OktaAuthListener listener) { if (!hasRefreshToken()) { Log.d(TAG, "Calling refreshAccessToken without a refresh token"); listener.onTokenFailure(AuthorizationException.TokenRequestErrors.INVALID_REQUEST); return; } ClientAuthentication clientAuthentication; try { clientAuthentication = mAuthStateManager.getCurrent().getClientAuthentication(); } catch (UnsupportedAuthenticationMethod ex) { Log.e(TAG, "Token request cannot be made; client authentication for the token " + "endpoint could not be constructed (%s)", ex); listener.onTokenFailure(AuthorizationException.TokenRequestErrors.INVALID_REQUEST); return; } createAuthorizationServiceIfNeeded().performTokenRequest( mAuthStateManager.getCurrent().createTokenRefreshRequest(), clientAuthentication, new AuthorizationService.TokenResponseCallback() { @Override public void onTokenRequestCompleted(@Nullable TokenResponse tokenResponse, @Nullable AuthorizationException authException) { handleAccessTokenResponse( tokenResponse, authException, listener); } }); } @AnyThread protected OktaAppAuth(Context context); @AnyThread static OktaAppAuth getInstance(@NonNull Context context); @AnyThread void init(
final Context context,
final OktaAuthListener listener); @AnyThread void init(
final Context context,
final OktaAuthListener listener,
@ColorInt int customTabColor); @AnyThread void init(
final Context context,
final OktaAuthListener listener,
@ColorInt int customTabColor,
final OktaConnectionBuilder oktaConnectionBuilder); void revoke(final String token, @NonNull final OktaRevokeListener listener); void revoke(@NonNull final OktaRevokeListener listener); void login(
final Context context,
final PendingIntent completionIntent,
final PendingIntent cancelIntent); void login(
final Context context,
final PendingIntent completionIntent,
final PendingIntent cancelIntent,
final AuthenticationPayload payload); void authenticate(
final String sessionToken,
@Nullable final OktaNativeAuthListener listener); void signOutFromOkta(
final Context context,
final PendingIntent completionIntent,
final PendingIntent cancelIntent
); void clearSession(); void dispose(); @AnyThread boolean isUserLoggedIn(); boolean hasRefreshToken(); boolean hasAccessToken(); Long getAccessTokenExpirationTime(); void refreshAccessToken(final OktaAuthListener listener); boolean hasIdToken(); void getUserInfo(final OktaAuthActionCallback<JSONObject> callback); void performAuthorizedRequest(final BearerAuthRequest action); Tokens getTokens(); }### Answer:
@Test public void testRefreshWithoutTokenCallsListener() { FakeOktaAuthListener listener = new FakeOktaAuthListener(); sut.refreshAccessToken(listener); assertThat(listener.hasCalledOnTokenFailure()).isTrue(); assertThat(listener.getTokenExceptions().get(0)) .isEqualTo(AuthorizationException.TokenRequestErrors.INVALID_REQUEST); }
@Test public void testRefreshFailsClientAuthenticationCallsListener() throws ClientAuthentication.UnsupportedAuthenticationMethod { when(mAuthState.getRefreshToken()).thenReturn("refreshTokenHere"); when(mAuthState.getClientAuthentication()) .thenThrow(new ClientAuthentication. UnsupportedAuthenticationMethod("tokenEndpointAuthMethod")); FakeOktaAuthListener listener = new FakeOktaAuthListener(); sut.refreshAccessToken(listener); verify(mAuthState, times(1)).getClientAuthentication(); assertThat(listener.hasCalledOnTokenFailure()).isTrue(); assertThat(listener.getTokenExceptions().get(0)) .isEqualTo(AuthorizationException.TokenRequestErrors.INVALID_REQUEST); }
@Test public void testRefreshCallsIntoAppAuth() throws ClientAuthentication.UnsupportedAuthenticationMethod { TokenRequest tokenRequest = mock(TokenRequest.class); FakeOktaAuthListener listener = new FakeOktaAuthListener(); when(mAuthState.getRefreshToken()).thenReturn("refreshTokenHere"); when(mAuthState.getClientAuthentication()).thenReturn(mClientAuthentication); when(mAuthState.createTokenRefreshRequest()).thenReturn(tokenRequest); sut.refreshAccessToken(listener); verify(mAuthService, times(1)) .performTokenRequest( any(TokenRequest.class), any(ClientAuthentication.class), any(AuthorizationService.TokenResponseCallback.class)); } |
### Question:
OktaAppAuth { public void signOutFromOkta( final Context context, final PendingIntent completionIntent, final PendingIntent cancelIntent ) { if (!isUserLoggedIn()) { throw new IllegalStateException("No logged in user found"); } mExecutor.submit(new Runnable() { @Override public void run() { doEndSession( OktaManagementActivity.createStartIntent( context, completionIntent, cancelIntent), cancelIntent); } }); } @AnyThread protected OktaAppAuth(Context context); @AnyThread static OktaAppAuth getInstance(@NonNull Context context); @AnyThread void init(
final Context context,
final OktaAuthListener listener); @AnyThread void init(
final Context context,
final OktaAuthListener listener,
@ColorInt int customTabColor); @AnyThread void init(
final Context context,
final OktaAuthListener listener,
@ColorInt int customTabColor,
final OktaConnectionBuilder oktaConnectionBuilder); void revoke(final String token, @NonNull final OktaRevokeListener listener); void revoke(@NonNull final OktaRevokeListener listener); void login(
final Context context,
final PendingIntent completionIntent,
final PendingIntent cancelIntent); void login(
final Context context,
final PendingIntent completionIntent,
final PendingIntent cancelIntent,
final AuthenticationPayload payload); void authenticate(
final String sessionToken,
@Nullable final OktaNativeAuthListener listener); void signOutFromOkta(
final Context context,
final PendingIntent completionIntent,
final PendingIntent cancelIntent
); void clearSession(); void dispose(); @AnyThread boolean isUserLoggedIn(); boolean hasRefreshToken(); boolean hasAccessToken(); Long getAccessTokenExpirationTime(); void refreshAccessToken(final OktaAuthListener listener); boolean hasIdToken(); void getUserInfo(final OktaAuthActionCallback<JSONObject> callback); void performAuthorizedRequest(final BearerAuthRequest action); Tokens getTokens(); }### Answer:
@Test public void testSignOutFromOkta() { PendingIntent success = mock(PendingIntent.class); PendingIntent failure = mock(PendingIntent.class); AuthState authState = mock(AuthState.class); String idToken = TestUtils.getUnsignedIdToken(); when(mAuthService.createCustomTabsIntentBuilder(any(Uri.class))) .thenReturn(new CustomTabsIntent.Builder()); when(mAuthStateManager.getCurrent()).thenReturn(authState); when(authState.getAuthorizationServiceConfiguration()) .thenReturn(TestUtils.getTestServiceConfig()); when(authState.isAuthorized()).thenReturn(true); when(authState.getIdToken()).thenReturn(idToken); when(mConfiguration.getEndSessionRedirectUri()) .thenReturn(TestUtils.TEST_APP_REDIRECT_URI); when(mConfiguration.hasConfigurationChanged()).thenReturn(false); ArgumentCaptor<EndSessionRequest> argument = ArgumentCaptor.forClass(EndSessionRequest.class); sut.signOutFromOkta(mContext, success, failure); verify(mAuthService, times(1)) .performEndOfSessionRequest( argument.capture() ,any(PendingIntent.class) ,any(PendingIntent.class) ,any(CustomTabsIntent.class) ); assertThat(argument.getValue().idToken) .isEqualTo(idToken); assertThat(argument.getValue().configuration.toJsonString()) .isEqualTo(TestUtils.getTestServiceConfig().toJsonString()); assertThat(argument.getValue().redirectUri) .isEqualTo(TestUtils.TEST_APP_REDIRECT_URI); }
@Test(expected = IllegalStateException.class) public void testLogoutNoLogedinUserFoundException(){ PendingIntent success = mock(PendingIntent.class); PendingIntent failure = mock(PendingIntent.class); AuthState authState = mock(AuthState.class); when(mAuthStateManager.getCurrent()).thenReturn(authState); when(authState.isAuthorized()).thenReturn(false); when(mConfiguration.hasConfigurationChanged()).thenReturn(false); when(authState.getAuthorizationServiceConfiguration()) .thenReturn(TestUtils.getTestServiceConfig()); sut.signOutFromOkta(mContext, success, failure); } |
### Question:
OktaAppAuth { public Tokens getTokens() { return Tokens.fromAuthState(mAuthStateManager.getCurrent()); } @AnyThread protected OktaAppAuth(Context context); @AnyThread static OktaAppAuth getInstance(@NonNull Context context); @AnyThread void init(
final Context context,
final OktaAuthListener listener); @AnyThread void init(
final Context context,
final OktaAuthListener listener,
@ColorInt int customTabColor); @AnyThread void init(
final Context context,
final OktaAuthListener listener,
@ColorInt int customTabColor,
final OktaConnectionBuilder oktaConnectionBuilder); void revoke(final String token, @NonNull final OktaRevokeListener listener); void revoke(@NonNull final OktaRevokeListener listener); void login(
final Context context,
final PendingIntent completionIntent,
final PendingIntent cancelIntent); void login(
final Context context,
final PendingIntent completionIntent,
final PendingIntent cancelIntent,
final AuthenticationPayload payload); void authenticate(
final String sessionToken,
@Nullable final OktaNativeAuthListener listener); void signOutFromOkta(
final Context context,
final PendingIntent completionIntent,
final PendingIntent cancelIntent
); void clearSession(); void dispose(); @AnyThread boolean isUserLoggedIn(); boolean hasRefreshToken(); boolean hasAccessToken(); Long getAccessTokenExpirationTime(); void refreshAccessToken(final OktaAuthListener listener); boolean hasIdToken(); void getUserInfo(final OktaAuthActionCallback<JSONObject> callback); void performAuthorizedRequest(final BearerAuthRequest action); Tokens getTokens(); }### Answer:
@Test public void testGetTokenSuccess() { String testIdToken = "testIdToken"; String testAccessToken = "testAccessToken"; String testRefreshToken = "testRefreshToken"; when(mAuthStateManager.getCurrent()).thenReturn(mAuthState); when(mAuthState.getIdToken()).thenReturn(testIdToken); when(mAuthState.getRefreshToken()).thenReturn(testRefreshToken); when(mAuthState.getAccessToken()).thenReturn(testAccessToken); Tokens tokens = sut.getTokens(); assertThat(tokens.getAccessToken()).isEqualTo(testAccessToken); assertThat(tokens.getIdToken()).isEqualTo(testIdToken); assertThat(tokens.getRefreshToken()).isEqualTo(testRefreshToken); } |
### Question:
SessionAuthenticationService { void performAuthorizationRequest( AuthorizationRequest request, String sessionToken, @Nullable OktaAppAuth.OktaNativeAuthListener listener) { if (sessionToken == null) { if (listener != null) { listener.onTokenFailure(AuthenticationError.createAuthenticationError( AuthenticationError.INVALID_SESSION_TOKEN, 0)); } return; } Map<String, String> additionalParameters = new HashMap<String, String>(); if (request.additionalParameters != null && !request.additionalParameters.isEmpty()) { additionalParameters.putAll(request.additionalParameters); } additionalParameters.put(SESSION_TOKEN_PARAMETER, sessionToken); AuthorizationRequest.Builder authRequestBuilder = new AuthorizationRequest.Builder( request.configuration, request.clientId, request.responseType, request.redirectUri) .setNonce(request.nonce) .setScopes(request.getScopeSet()) .setAdditionalParameters(additionalParameters); AuthenticationResult<AuthorizationResponse> authorizationResult = getAuthorizationCode( authRequestBuilder.build()); if (authorizationResult.getResponse() == null || authorizationResult.getResponse().authorizationCode == null) { if (listener != null) { listener.onTokenFailure(authorizationResult.getException()); } return; } AuthenticationResult<TokenResponse> tokenResponse = exchangeCodeForTokens( authorizationResult.getResponse()); if (!mStateManager.getCurrent().isAuthorized()) { if (listener != null) { listener.onTokenFailure(tokenResponse.getException()); } } else { if (listener != null) { listener.onSuccess(); } } } SessionAuthenticationService(
AuthStateManager manager,
AuthorizationService authorizationService,
ConnectionBuilder connectionBuilder); }### Answer:
@Test public void testInValidCredentialsPerformAuthorizationRequest() { FakeNativeOktaAuthListener listener = new FakeNativeOktaAuthListener(); sessionAuthenticationService.performAuthorizationRequest(request, null, listener); assertTrue(listener.hasCalledOnTokenFailure()); }
@Test public void testNullListenerPerformAuthorizationRequest() { sessionAuthenticationService.performAuthorizationRequest(request, VALID_SESSION, null); sessionAuthenticationService.performAuthorizationRequest(request, null, null); } |
### Question:
OAuthClientConfiguration { public String getClientId() { return mClientId; } @VisibleForTesting OAuthClientConfiguration(
final Context context,
final SharedPreferences prefs,
final InputStream configurationStream); @AnyThread static OAuthClientConfiguration getInstance(final Context context); boolean hasConfigurationChanged(); void acceptConfiguration(); boolean isValid(); @Nullable String getConfigurationError(); String getClientId(); Uri getRedirectUri(); Uri getEndSessionRedirectUri(); Uri getDiscoveryUri(); Set<String> getScopes(); }### Answer:
@Test public void testGetClientId() { assertThat(sut.getClientId()).isEqualTo("example_client_id"); } |
### Question:
OAuthClientConfiguration { public Uri getRedirectUri() { return mRedirectUri; } @VisibleForTesting OAuthClientConfiguration(
final Context context,
final SharedPreferences prefs,
final InputStream configurationStream); @AnyThread static OAuthClientConfiguration getInstance(final Context context); boolean hasConfigurationChanged(); void acceptConfiguration(); boolean isValid(); @Nullable String getConfigurationError(); String getClientId(); Uri getRedirectUri(); Uri getEndSessionRedirectUri(); Uri getDiscoveryUri(); Set<String> getScopes(); }### Answer:
@Test public void getRedirectUri() { assertThat(sut.getRedirectUri()).isEqualTo( Uri.parse("com.okta.appauth.android.test:/oauth2redirect")); } |
### Question:
OAuthClientConfiguration { public Uri getDiscoveryUri() { return mDiscoveryUri; } @VisibleForTesting OAuthClientConfiguration(
final Context context,
final SharedPreferences prefs,
final InputStream configurationStream); @AnyThread static OAuthClientConfiguration getInstance(final Context context); boolean hasConfigurationChanged(); void acceptConfiguration(); boolean isValid(); @Nullable String getConfigurationError(); String getClientId(); Uri getRedirectUri(); Uri getEndSessionRedirectUri(); Uri getDiscoveryUri(); Set<String> getScopes(); }### Answer:
@Test public void testGetDiscoveryUriAppendsWellKnownDiscovery() { assertThat(sut.getDiscoveryUri()).isEqualTo( Uri.parse("https: ); } |
### Question:
OAuthClientConfiguration { public Set<String> getScopes() { return mScopes; } @VisibleForTesting OAuthClientConfiguration(
final Context context,
final SharedPreferences prefs,
final InputStream configurationStream); @AnyThread static OAuthClientConfiguration getInstance(final Context context); boolean hasConfigurationChanged(); void acceptConfiguration(); boolean isValid(); @Nullable String getConfigurationError(); String getClientId(); Uri getRedirectUri(); Uri getEndSessionRedirectUri(); Uri getDiscoveryUri(); Set<String> getScopes(); }### Answer:
@Test public void testGetScopes() { assertThat(sut.getScopes()).contains("openid", "foo"); } |
### Question:
AuthStateManager { @AnyThread @NonNull public AuthState getCurrent() { if (mCurrentAuthState.get() != null) { return mCurrentAuthState.get(); } AuthState state = readState(); if (mCurrentAuthState.compareAndSet(null, state)) { return state; } else { return mCurrentAuthState.get(); } } @VisibleForTesting AuthStateManager(SharedPreferences prefs, ReentrantLock prefsLock); @AnyThread static AuthStateManager getInstance(@NonNull Context context); @AnyThread @NonNull AuthState getCurrent(); @AnyThread @NonNull AuthState replace(@NonNull AuthState state); @AnyThread @NonNull AuthState updateAfterAuthorization(
@Nullable AuthorizationResponse response,
@Nullable AuthorizationException ex); @AnyThread @NonNull AuthState updateAfterTokenResponse(
@Nullable TokenResponse response,
@Nullable AuthorizationException ex); }### Answer:
@Test public void testGetCurrentCachesState() { AuthState state = sut.getCurrent(); assertThat(sut.getCurrent()).isSameAs(state); assertThat(mPrefs.contains(KEY_STATE)).isFalse(); } |
### Question:
GesturePane extends Control implements GesturePaneOps { public void setScrollBarPolicy(ScrollBarPolicy policy) { setHbarPolicy(policy); setVbarPolicy(policy); } GesturePane(Transformable target); GesturePane(Node target); GesturePane(); @Override String getUserAgentStylesheet(); Point2D viewportCentre(); Point2D targetPointAtViewportCentre(); Optional<Point2D> targetPointAt(Point2D viewportPoint); Point2D viewportPointAt(Point2D targetPoint); @Override void translateBy(Dimension2D targetAmount); @Override void centreOn(Point2D pointOnTarget); @Override void centreOnX(double pointOnTarget); @Override void centreOnY(double pointOnTarget); @Override void zoomTo(double scaleX,double scaleY, Point2D pivotOnTarget); @Override void zoomToX(double scaleX, Point2D pivotOnTarget); @Override void zoomToY(double scaleY, Point2D pivotOnTarget); @Override void zoomBy(double amountX,double amountY, Point2D pivotOnTarget); @Override void zoomByX(double amountX, Point2D pivotOnTarget); @Override void zoomByY(double amountY, Point2D pivotOnTarget); AnimationInterpolatorBuilder animate(Duration duration); final void reset(); void cover(); double getTargetWidth(); double getTargetHeight(); double getViewportWidth(); double getViewportHeight(); Bounds getViewportBound(); ReadOnlyObjectProperty<Bounds> viewportBoundProperty(); Transformable getTarget(); ObjectProperty<Transformable> targetProperty(); void setTarget(Transformable target); Node getContent(); ObjectProperty<Node> contentProperty(); void setContent(Node content); ScrollBarPolicy getVbarPolicy(); ObjectProperty<ScrollBarPolicy> vbarPolicyProperty(); void setVbarPolicy(ScrollBarPolicy policy); ScrollBarPolicy getHbarPolicy(); ObjectProperty<ScrollBarPolicy> hbarPolicyProperty(); void setHbarPolicy(ScrollBarPolicy policy); void setScrollBarPolicy(ScrollBarPolicy policy); boolean isChanging(); ReadOnlyBooleanProperty changingProperty(); boolean isGestureEnabled(); BooleanProperty gestureEnabledProperty(); void setGestureEnabled(boolean enable); boolean isClipEnabled(); BooleanProperty clipEnabledProperty(); void setClipEnabled(boolean enable); boolean isFitWidth(); BooleanProperty fitWidthProperty(); void setFitWidth(boolean fitWidth); boolean isFitHeight(); BooleanProperty fitHeightProperty(); void setFitHeight(boolean fitHeight); FitMode getFitMode(); ObjectProperty<FitMode> fitModeProperty(); void setFitMode(FitMode mode); ScrollMode getScrollMode(); ObjectProperty<ScrollMode> scrollModeProperty(); void setScrollMode(ScrollMode mode); boolean isInvertScrollTranslate(); BooleanProperty invertScrollTranslateProperty(); void setInvertScrollTranslate(boolean invertScrollTranslate); boolean isLockScaleX(); BooleanProperty lockScaleXProperty(); void setLockScaleX(boolean lockScaleX); boolean isLockScaleY(); BooleanProperty lockScaleYProperty(); void setLockScaleY(boolean lockScaleY); double getCurrentScale(); DoubleProperty currentScaleProperty(); boolean isBindScale(); BooleanProperty bindScaleProperty(); void setBindScale(boolean bindScale); double getMinScale(); DoubleProperty minScaleProperty(); void setMinScale(double scale); double getMaxScale(); DoubleProperty maxScaleProperty(); void setMaxScale(double scale); double getCurrentScaleX(); DoubleProperty currentScaleXProperty(); double getCurrentScaleY(); DoubleProperty currentScaleYProperty(); double getCurrentX(); DoubleBinding currentXProperty(); double getCurrentY(); DoubleBinding currentYProperty(); double getScrollZoomFactor(); DoubleProperty scrollZoomFactorProperty(); void setScrollZoomFactor(double factor); Bounds getTargetViewport(); ObjectProperty<Bounds> targetViewportProperty(); Affine getAffine(); @Override Object queryAccessibleAttribute(AccessibleAttribute attribute, Object... parameters); static final double DEFAULT_MIN_SCALE; static final double DEFAULT_MAX_SCALE; static final double DEFAULT_ZOOM_FACTOR; }### Answer:
@Test public void testScrollBarDisabled() { pane.setScrollBarPolicy(ScrollBarPolicy.NEVER); assertThat(pane.lookupAll("*")) .haveExactly(1, createBarCondition(HORIZONTAL, false)) .haveExactly(1, createBarCondition(VERTICAL, false)); } |
### Question:
GesturePane extends Control implements GesturePaneOps { public Point2D viewportCentre() { return new Point2D(getViewportWidth() / 2, getViewportHeight() / 2); } GesturePane(Transformable target); GesturePane(Node target); GesturePane(); @Override String getUserAgentStylesheet(); Point2D viewportCentre(); Point2D targetPointAtViewportCentre(); Optional<Point2D> targetPointAt(Point2D viewportPoint); Point2D viewportPointAt(Point2D targetPoint); @Override void translateBy(Dimension2D targetAmount); @Override void centreOn(Point2D pointOnTarget); @Override void centreOnX(double pointOnTarget); @Override void centreOnY(double pointOnTarget); @Override void zoomTo(double scaleX,double scaleY, Point2D pivotOnTarget); @Override void zoomToX(double scaleX, Point2D pivotOnTarget); @Override void zoomToY(double scaleY, Point2D pivotOnTarget); @Override void zoomBy(double amountX,double amountY, Point2D pivotOnTarget); @Override void zoomByX(double amountX, Point2D pivotOnTarget); @Override void zoomByY(double amountY, Point2D pivotOnTarget); AnimationInterpolatorBuilder animate(Duration duration); final void reset(); void cover(); double getTargetWidth(); double getTargetHeight(); double getViewportWidth(); double getViewportHeight(); Bounds getViewportBound(); ReadOnlyObjectProperty<Bounds> viewportBoundProperty(); Transformable getTarget(); ObjectProperty<Transformable> targetProperty(); void setTarget(Transformable target); Node getContent(); ObjectProperty<Node> contentProperty(); void setContent(Node content); ScrollBarPolicy getVbarPolicy(); ObjectProperty<ScrollBarPolicy> vbarPolicyProperty(); void setVbarPolicy(ScrollBarPolicy policy); ScrollBarPolicy getHbarPolicy(); ObjectProperty<ScrollBarPolicy> hbarPolicyProperty(); void setHbarPolicy(ScrollBarPolicy policy); void setScrollBarPolicy(ScrollBarPolicy policy); boolean isChanging(); ReadOnlyBooleanProperty changingProperty(); boolean isGestureEnabled(); BooleanProperty gestureEnabledProperty(); void setGestureEnabled(boolean enable); boolean isClipEnabled(); BooleanProperty clipEnabledProperty(); void setClipEnabled(boolean enable); boolean isFitWidth(); BooleanProperty fitWidthProperty(); void setFitWidth(boolean fitWidth); boolean isFitHeight(); BooleanProperty fitHeightProperty(); void setFitHeight(boolean fitHeight); FitMode getFitMode(); ObjectProperty<FitMode> fitModeProperty(); void setFitMode(FitMode mode); ScrollMode getScrollMode(); ObjectProperty<ScrollMode> scrollModeProperty(); void setScrollMode(ScrollMode mode); boolean isInvertScrollTranslate(); BooleanProperty invertScrollTranslateProperty(); void setInvertScrollTranslate(boolean invertScrollTranslate); boolean isLockScaleX(); BooleanProperty lockScaleXProperty(); void setLockScaleX(boolean lockScaleX); boolean isLockScaleY(); BooleanProperty lockScaleYProperty(); void setLockScaleY(boolean lockScaleY); double getCurrentScale(); DoubleProperty currentScaleProperty(); boolean isBindScale(); BooleanProperty bindScaleProperty(); void setBindScale(boolean bindScale); double getMinScale(); DoubleProperty minScaleProperty(); void setMinScale(double scale); double getMaxScale(); DoubleProperty maxScaleProperty(); void setMaxScale(double scale); double getCurrentScaleX(); DoubleProperty currentScaleXProperty(); double getCurrentScaleY(); DoubleProperty currentScaleYProperty(); double getCurrentX(); DoubleBinding currentXProperty(); double getCurrentY(); DoubleBinding currentYProperty(); double getScrollZoomFactor(); DoubleProperty scrollZoomFactorProperty(); void setScrollZoomFactor(double factor); Bounds getTargetViewport(); ObjectProperty<Bounds> targetViewportProperty(); Affine getAffine(); @Override Object queryAccessibleAttribute(AccessibleAttribute attribute, Object... parameters); static final double DEFAULT_MIN_SCALE; static final double DEFAULT_MAX_SCALE; static final double DEFAULT_ZOOM_FACTOR; }### Answer:
@Test public void testViewportCentre() { pane.setScrollBarPolicy(ScrollBarPolicy.NEVER); assertThat(pane.viewportCentre()).isEqualTo(new Point2D(256, 256)); } |
### Question:
GesturePane extends Control implements GesturePaneOps { public Point2D targetPointAtViewportCentre() { try { return affine.inverseTransform(viewportCentre()); } catch (NonInvertibleTransformException e) { throw new RuntimeException(e); } } GesturePane(Transformable target); GesturePane(Node target); GesturePane(); @Override String getUserAgentStylesheet(); Point2D viewportCentre(); Point2D targetPointAtViewportCentre(); Optional<Point2D> targetPointAt(Point2D viewportPoint); Point2D viewportPointAt(Point2D targetPoint); @Override void translateBy(Dimension2D targetAmount); @Override void centreOn(Point2D pointOnTarget); @Override void centreOnX(double pointOnTarget); @Override void centreOnY(double pointOnTarget); @Override void zoomTo(double scaleX,double scaleY, Point2D pivotOnTarget); @Override void zoomToX(double scaleX, Point2D pivotOnTarget); @Override void zoomToY(double scaleY, Point2D pivotOnTarget); @Override void zoomBy(double amountX,double amountY, Point2D pivotOnTarget); @Override void zoomByX(double amountX, Point2D pivotOnTarget); @Override void zoomByY(double amountY, Point2D pivotOnTarget); AnimationInterpolatorBuilder animate(Duration duration); final void reset(); void cover(); double getTargetWidth(); double getTargetHeight(); double getViewportWidth(); double getViewportHeight(); Bounds getViewportBound(); ReadOnlyObjectProperty<Bounds> viewportBoundProperty(); Transformable getTarget(); ObjectProperty<Transformable> targetProperty(); void setTarget(Transformable target); Node getContent(); ObjectProperty<Node> contentProperty(); void setContent(Node content); ScrollBarPolicy getVbarPolicy(); ObjectProperty<ScrollBarPolicy> vbarPolicyProperty(); void setVbarPolicy(ScrollBarPolicy policy); ScrollBarPolicy getHbarPolicy(); ObjectProperty<ScrollBarPolicy> hbarPolicyProperty(); void setHbarPolicy(ScrollBarPolicy policy); void setScrollBarPolicy(ScrollBarPolicy policy); boolean isChanging(); ReadOnlyBooleanProperty changingProperty(); boolean isGestureEnabled(); BooleanProperty gestureEnabledProperty(); void setGestureEnabled(boolean enable); boolean isClipEnabled(); BooleanProperty clipEnabledProperty(); void setClipEnabled(boolean enable); boolean isFitWidth(); BooleanProperty fitWidthProperty(); void setFitWidth(boolean fitWidth); boolean isFitHeight(); BooleanProperty fitHeightProperty(); void setFitHeight(boolean fitHeight); FitMode getFitMode(); ObjectProperty<FitMode> fitModeProperty(); void setFitMode(FitMode mode); ScrollMode getScrollMode(); ObjectProperty<ScrollMode> scrollModeProperty(); void setScrollMode(ScrollMode mode); boolean isInvertScrollTranslate(); BooleanProperty invertScrollTranslateProperty(); void setInvertScrollTranslate(boolean invertScrollTranslate); boolean isLockScaleX(); BooleanProperty lockScaleXProperty(); void setLockScaleX(boolean lockScaleX); boolean isLockScaleY(); BooleanProperty lockScaleYProperty(); void setLockScaleY(boolean lockScaleY); double getCurrentScale(); DoubleProperty currentScaleProperty(); boolean isBindScale(); BooleanProperty bindScaleProperty(); void setBindScale(boolean bindScale); double getMinScale(); DoubleProperty minScaleProperty(); void setMinScale(double scale); double getMaxScale(); DoubleProperty maxScaleProperty(); void setMaxScale(double scale); double getCurrentScaleX(); DoubleProperty currentScaleXProperty(); double getCurrentScaleY(); DoubleProperty currentScaleYProperty(); double getCurrentX(); DoubleBinding currentXProperty(); double getCurrentY(); DoubleBinding currentYProperty(); double getScrollZoomFactor(); DoubleProperty scrollZoomFactorProperty(); void setScrollZoomFactor(double factor); Bounds getTargetViewport(); ObjectProperty<Bounds> targetViewportProperty(); Affine getAffine(); @Override Object queryAccessibleAttribute(AccessibleAttribute attribute, Object... parameters); static final double DEFAULT_MIN_SCALE; static final double DEFAULT_MAX_SCALE; static final double DEFAULT_ZOOM_FACTOR; }### Answer:
@Test public void testTargetPointAtViewportCentre() { pane.setScrollBarPolicy(ScrollBarPolicy.NEVER); Point2D expected = pane.targetPointAt(pane.viewportCentre()) .orElseThrow(AssertionError::new); assertThat(pane.targetPointAtViewportCentre()).isEqualTo(expected); } |
### Question:
GesturePane extends Control implements GesturePaneOps { final void scale(double factor, Point2D origin) { scale(factor, factor, origin); } GesturePane(Transformable target); GesturePane(Node target); GesturePane(); @Override String getUserAgentStylesheet(); Point2D viewportCentre(); Point2D targetPointAtViewportCentre(); Optional<Point2D> targetPointAt(Point2D viewportPoint); Point2D viewportPointAt(Point2D targetPoint); @Override void translateBy(Dimension2D targetAmount); @Override void centreOn(Point2D pointOnTarget); @Override void centreOnX(double pointOnTarget); @Override void centreOnY(double pointOnTarget); @Override void zoomTo(double scaleX,double scaleY, Point2D pivotOnTarget); @Override void zoomToX(double scaleX, Point2D pivotOnTarget); @Override void zoomToY(double scaleY, Point2D pivotOnTarget); @Override void zoomBy(double amountX,double amountY, Point2D pivotOnTarget); @Override void zoomByX(double amountX, Point2D pivotOnTarget); @Override void zoomByY(double amountY, Point2D pivotOnTarget); AnimationInterpolatorBuilder animate(Duration duration); final void reset(); void cover(); double getTargetWidth(); double getTargetHeight(); double getViewportWidth(); double getViewportHeight(); Bounds getViewportBound(); ReadOnlyObjectProperty<Bounds> viewportBoundProperty(); Transformable getTarget(); ObjectProperty<Transformable> targetProperty(); void setTarget(Transformable target); Node getContent(); ObjectProperty<Node> contentProperty(); void setContent(Node content); ScrollBarPolicy getVbarPolicy(); ObjectProperty<ScrollBarPolicy> vbarPolicyProperty(); void setVbarPolicy(ScrollBarPolicy policy); ScrollBarPolicy getHbarPolicy(); ObjectProperty<ScrollBarPolicy> hbarPolicyProperty(); void setHbarPolicy(ScrollBarPolicy policy); void setScrollBarPolicy(ScrollBarPolicy policy); boolean isChanging(); ReadOnlyBooleanProperty changingProperty(); boolean isGestureEnabled(); BooleanProperty gestureEnabledProperty(); void setGestureEnabled(boolean enable); boolean isClipEnabled(); BooleanProperty clipEnabledProperty(); void setClipEnabled(boolean enable); boolean isFitWidth(); BooleanProperty fitWidthProperty(); void setFitWidth(boolean fitWidth); boolean isFitHeight(); BooleanProperty fitHeightProperty(); void setFitHeight(boolean fitHeight); FitMode getFitMode(); ObjectProperty<FitMode> fitModeProperty(); void setFitMode(FitMode mode); ScrollMode getScrollMode(); ObjectProperty<ScrollMode> scrollModeProperty(); void setScrollMode(ScrollMode mode); boolean isInvertScrollTranslate(); BooleanProperty invertScrollTranslateProperty(); void setInvertScrollTranslate(boolean invertScrollTranslate); boolean isLockScaleX(); BooleanProperty lockScaleXProperty(); void setLockScaleX(boolean lockScaleX); boolean isLockScaleY(); BooleanProperty lockScaleYProperty(); void setLockScaleY(boolean lockScaleY); double getCurrentScale(); DoubleProperty currentScaleProperty(); boolean isBindScale(); BooleanProperty bindScaleProperty(); void setBindScale(boolean bindScale); double getMinScale(); DoubleProperty minScaleProperty(); void setMinScale(double scale); double getMaxScale(); DoubleProperty maxScaleProperty(); void setMaxScale(double scale); double getCurrentScaleX(); DoubleProperty currentScaleXProperty(); double getCurrentScaleY(); DoubleProperty currentScaleYProperty(); double getCurrentX(); DoubleBinding currentXProperty(); double getCurrentY(); DoubleBinding currentYProperty(); double getScrollZoomFactor(); DoubleProperty scrollZoomFactorProperty(); void setScrollZoomFactor(double factor); Bounds getTargetViewport(); ObjectProperty<Bounds> targetViewportProperty(); Affine getAffine(); @Override Object queryAccessibleAttribute(AccessibleAttribute attribute, Object... parameters); static final double DEFAULT_MIN_SCALE; static final double DEFAULT_MAX_SCALE; static final double DEFAULT_ZOOM_FACTOR; }### Answer:
@Test public void testScale() { pane.zoomTo(2, pane.targetPointAtViewportCentre()); assertThat(pane.getCurrentScale()).isEqualTo(2d); } |
### Question:
GesturePane extends Control implements GesturePaneOps { public double getCurrentScale() { return scaleX.get(); } GesturePane(Transformable target); GesturePane(Node target); GesturePane(); @Override String getUserAgentStylesheet(); Point2D viewportCentre(); Point2D targetPointAtViewportCentre(); Optional<Point2D> targetPointAt(Point2D viewportPoint); Point2D viewportPointAt(Point2D targetPoint); @Override void translateBy(Dimension2D targetAmount); @Override void centreOn(Point2D pointOnTarget); @Override void centreOnX(double pointOnTarget); @Override void centreOnY(double pointOnTarget); @Override void zoomTo(double scaleX,double scaleY, Point2D pivotOnTarget); @Override void zoomToX(double scaleX, Point2D pivotOnTarget); @Override void zoomToY(double scaleY, Point2D pivotOnTarget); @Override void zoomBy(double amountX,double amountY, Point2D pivotOnTarget); @Override void zoomByX(double amountX, Point2D pivotOnTarget); @Override void zoomByY(double amountY, Point2D pivotOnTarget); AnimationInterpolatorBuilder animate(Duration duration); final void reset(); void cover(); double getTargetWidth(); double getTargetHeight(); double getViewportWidth(); double getViewportHeight(); Bounds getViewportBound(); ReadOnlyObjectProperty<Bounds> viewportBoundProperty(); Transformable getTarget(); ObjectProperty<Transformable> targetProperty(); void setTarget(Transformable target); Node getContent(); ObjectProperty<Node> contentProperty(); void setContent(Node content); ScrollBarPolicy getVbarPolicy(); ObjectProperty<ScrollBarPolicy> vbarPolicyProperty(); void setVbarPolicy(ScrollBarPolicy policy); ScrollBarPolicy getHbarPolicy(); ObjectProperty<ScrollBarPolicy> hbarPolicyProperty(); void setHbarPolicy(ScrollBarPolicy policy); void setScrollBarPolicy(ScrollBarPolicy policy); boolean isChanging(); ReadOnlyBooleanProperty changingProperty(); boolean isGestureEnabled(); BooleanProperty gestureEnabledProperty(); void setGestureEnabled(boolean enable); boolean isClipEnabled(); BooleanProperty clipEnabledProperty(); void setClipEnabled(boolean enable); boolean isFitWidth(); BooleanProperty fitWidthProperty(); void setFitWidth(boolean fitWidth); boolean isFitHeight(); BooleanProperty fitHeightProperty(); void setFitHeight(boolean fitHeight); FitMode getFitMode(); ObjectProperty<FitMode> fitModeProperty(); void setFitMode(FitMode mode); ScrollMode getScrollMode(); ObjectProperty<ScrollMode> scrollModeProperty(); void setScrollMode(ScrollMode mode); boolean isInvertScrollTranslate(); BooleanProperty invertScrollTranslateProperty(); void setInvertScrollTranslate(boolean invertScrollTranslate); boolean isLockScaleX(); BooleanProperty lockScaleXProperty(); void setLockScaleX(boolean lockScaleX); boolean isLockScaleY(); BooleanProperty lockScaleYProperty(); void setLockScaleY(boolean lockScaleY); double getCurrentScale(); DoubleProperty currentScaleProperty(); boolean isBindScale(); BooleanProperty bindScaleProperty(); void setBindScale(boolean bindScale); double getMinScale(); DoubleProperty minScaleProperty(); void setMinScale(double scale); double getMaxScale(); DoubleProperty maxScaleProperty(); void setMaxScale(double scale); double getCurrentScaleX(); DoubleProperty currentScaleXProperty(); double getCurrentScaleY(); DoubleProperty currentScaleYProperty(); double getCurrentX(); DoubleBinding currentXProperty(); double getCurrentY(); DoubleBinding currentYProperty(); double getScrollZoomFactor(); DoubleProperty scrollZoomFactorProperty(); void setScrollZoomFactor(double factor); Bounds getTargetViewport(); ObjectProperty<Bounds> targetViewportProperty(); Affine getAffine(); @Override Object queryAccessibleAttribute(AccessibleAttribute attribute, Object... parameters); static final double DEFAULT_MIN_SCALE; static final double DEFAULT_MAX_SCALE; static final double DEFAULT_ZOOM_FACTOR; }### Answer:
@Test public void testScaleByTouch() { double factor = 4.2; pane.fireEvent(new ZoomEvent(ZoomEvent.ZOOM, 0, 0, 0, 0, false, false, false, false, false, false, factor, factor, null)); assertThat(pane.getCurrentScale()).isEqualTo(factor); } |
### Question:
ParentDirectoryAuthorScoreStrategy implements ScoreStrategy<AuthorScore> { @NotNull @Override public AuthorScore score(BookImportContext context) { try { File file = context.getFile(); String dirName = file.getParentFile().getName(); String[] rawTokens = splitAuthorPairTokens(dirName); String[] tokens = trim(rawTokens); List<Author> authors = new ArrayList<>(); for (String token : tokens) { String[] rawNameTokens = splitAuthorNameTokens(token); String[] nameTokens = trim(rawNameTokens); if (nameTokens.length == 2) { Name name = new PersonNameCategorizer().categorize(nameTokens); Author author = new Author(name.getFirstName(), name.getLastName()); authors.add(author); } } return new AuthorScore(authors, ParentDirectoryAuthorScoreStrategy.class); } catch (Exception e) { log.error("Could not determine score for {}", context); return new AuthorScore(Collections.<Author>emptyList(), ParentDirectoryAuthorScoreStrategy.class); } } @NotNull @Override AuthorScore score(BookImportContext context); }### Answer:
@Test public void testExtractAuthorFromDirectoryName() throws Exception { BookImportContext bookImportContext = createMock(BookImportContext.class); File mock = createMock(File.class); File parent = createMock(File.class); expect(mock.getParentFile()).andReturn(parent); expect(parent.getName()).andReturn("Christopher, Matt"); expect(bookImportContext.getFile()).andReturn(mock); replayAll(); Score<List<Author>> authorScores = new ParentDirectoryAuthorScoreStrategy().score(bookImportContext); List<Author> authors = authorScores.getValue(); verifyAll(); assertThat(authors, hasItems(new Author("Matt", "Christopher"))); assertThat(authorScores.getScore(), is(1.0)); }
@Test public void testExtractMultipleAuthorsFromDirectoryName() throws Exception { BookImportContext bookImportContext = createMock(BookImportContext.class); File mock = createMock(File.class); File parent = createMock(File.class); expect(mock.getParentFile()).andReturn(parent); expect(parent.getName()).andReturn("Jacques, Brian & Chalk, Gary"); expect(bookImportContext.getFile()).andReturn(mock); replayAll(); Score<List<Author>> authorScores = new ParentDirectoryAuthorScoreStrategy().score(bookImportContext); List<Author> authors = authorScores.getValue(); double value = authorScores.getScore(); verifyAll(); assertThat(authors, hasItems(new Author("Brian", "Jacques"), new Author("Gary", "Chalk"))); assertThat(authorScores.getScore(), is(1.0)); } |
### Question:
FileNameAuthorScoreStrategy implements ScoreStrategy<AuthorScore> { private Author extractAuthorFromFileName(String fileName) { Assert.isTrue(fileName.contains(SEPARATOR), "Format in " + fileName + " not understood, doesn't contain separator"); String authorIncludingSpecialCharacters = extractAuthorPart(fileName); String[] tokens = splitFirstnameAndLastname(authorIncludingSpecialCharacters); Name name = new PersonNameCategorizer().categorize(tokens); return new Author(name.getFirstName(), name.getLastName()); } @NotNull @Override AuthorScore score(BookImportContext context); static final String SEPARATOR; static final Pattern NAME_PATTERN; }### Answer:
@Test public void testExtractAuthorFromFileName() throws Exception { BookImportContext bookImportContext = createMock(BookImportContext.class); File mock = createMock(File.class); expect(mock.getName()).andReturn("Abbott, Megan - Dare Me.epub"); expect(bookImportContext.getFile()).andReturn(mock); replayAll(); Score<List<Author>> authorScores = new FileNameAuthorScoreStrategy().score(bookImportContext); List<Author> authors = authorScores.getValue(); verifyAll(); assertThat(authors, contains(new Author("Megan", "Abbott"))); assertThat(authorScores.getScore(), is(1.0)); } |
### Question:
FileNameAuthorScoreStrategy implements ScoreStrategy<AuthorScore> { @NotNull @Override public AuthorScore score(BookImportContext context) { return new AuthorScore(getAuthors(context.getFile()), FileNameAuthorScoreStrategy.class); } @NotNull @Override AuthorScore score(BookImportContext context); static final String SEPARATOR; static final Pattern NAME_PATTERN; }### Answer:
@Test public void testExtractAuthorFromOtherFileName() throws Exception { BookImportContext bookImportContext = createMock(BookImportContext.class); File mock = createMock(File.class); expect(mock.getName()).andReturn("P. L. Travers - Mary Poppins From A to Z(epub).epub"); expect(bookImportContext.getFile()).andReturn(mock); replayAll(); Score<List<Author>> authorScores = new FileNameAuthorScoreStrategy().score(bookImportContext); List<Author> authors = authorScores.getValue(); verifyAll(); assertThat(authors, hasItems(new Author("P. L.", "Travers"))); assertThat(authorScores.getScore(), is(1.0)); }
@Test public void testExtractAuthorFromOnlyLastname() throws Exception { BookImportContext bookImportContext = createMock(BookImportContext.class); File mock = createMock(File.class); expect(mock.getName()).andReturn("Travers - Mary Poppins From A to Z(epub).epub"); expect(bookImportContext.getFile()).andReturn(mock); replayAll(); Score<List<Author>> authorScores = new FileNameAuthorScoreStrategy().score(bookImportContext); List<Author> authors = authorScores.getValue(); double value = authorScores.getScore(); verifyAll(); assertThat(authors, hasItems(new Author("", "Travers"))); assertThat(authorScores.getScore(), is(1.0)); } |
### Question:
MetaDataAuthorScoreStrategy implements ScoreStrategy<AuthorScore> { @NotNull @Override public AuthorScore score(BookImportContext context) { try { List<nl.siegmann.epublib.domain.Author> epubAuthors = context.getEpubBook().getMetadata().getAuthors(); AuthorScore categorizerScore = getAuthorScoreUsingCategorizer(epubAuthors); AuthorScore metaDataScore = getAuthorScoreUsingPlainMetaData(epubAuthors); Ordering<AuthorScore> o = new Ordering<AuthorScore>() { @Override public int compare(AuthorScore left, AuthorScore right) { return Doubles.compare(left.getScore(), right.getScore()); } }; return o.max(Arrays.asList(categorizerScore, metaDataScore)); } catch (Exception e) { log.error("Could not determine score for {}", context); return new AuthorScore(Collections.<Author>emptyList(), MetaDataAuthorScoreStrategy.class); } } @NotNull @Override AuthorScore score(BookImportContext context); }### Answer:
@Test public void extractAuthorFromMetaData() { File file = new File("src/test/resources/epubs/Alexandre Dumas - The countess of Charney.epub"); BookImportContext bookImportContext = new BookImportContext(file); Score<List<Author>> authorScores = new MetaDataAuthorScoreStrategy().score(bookImportContext); List<Author> authors = authorScores.getValue(); assertThat(authors, hasItems(new Author("Alexandre", "Dumas"))); assertThat(authorScores.getScore(), is(1.0)); } |
### Question:
MetaDataIsbn13ScoreStrategy implements ScoreStrategy<Isbn13Score> { @NotNull @Override public Isbn13Score score(BookImportContext context) { Book epubBook = context.getEpubBook(); Metadata metadata = epubBook.getMetadata(); Isbn13Score isbn13UsingScheme = getIsbn13(metadata); if(isbn13UsingScheme == null) { return new Isbn13Score("", "", MetaDataIsbn13ScoreStrategy.class); } return isbn13UsingScheme; } @NotNull @Override Isbn13Score score(BookImportContext context); static final int ISBN_LENGTH; }### Answer:
@Test public void testIsbn() { MetaDataIsbn13ScoreStrategy strategy = new MetaDataIsbn13ScoreStrategy(); BookImportContext importContext = new BookBuilder().isbn("1234567890123").buildContext(); Isbn13Score score = strategy.score(importContext); assertThat(score.getValue(), is("1234567890123")); assertThat(score.getScore(), is(1.0)); } |
### Question:
MetaDataIsbn10ScoreStrategy implements ScoreStrategy<Isbn10Score> { @NotNull @Override public Isbn10Score score(BookImportContext context) { Book epubBook = context.getEpubBook(); Metadata metadata = epubBook.getMetadata(); Isbn10Score isbn10UsingScheme = getIsbn10(metadata); if (isbn10UsingScheme == null) { return new Isbn10Score("", "", MetaDataIsbn10ScoreStrategy.class); } return isbn10UsingScheme; } @NotNull @Override Isbn10Score score(BookImportContext context); static final int ISBN_LENGTH; }### Answer:
@Test public void testIsbn() { MetaDataIsbn10ScoreStrategy strategy = new MetaDataIsbn10ScoreStrategy(); BookImportContext importContext = new BookBuilder().isbn("1234567890").buildContext(); Isbn10Score score = strategy.score(importContext); assertThat(score.getValue(), is("1234567890")); assertThat(score.getScore(), is(1.0)); } |
### Question:
BookProducer { public Book produce(BookImportContext context) throws IOException { Book book = new Book(); book.setAuthors(new AuthorScorer().determineBestScore(context).getValue()); book.setSource("import"); book.setTitle(new TitleScorer().determineBestScore(context).getValue()); book.setLanguage((new LanguageScorer().determineBestScore(context).getValue())); book.setIsbn10(new Isbn10Scorer().determineBestScore(context).getValue()); book.setIsbn13(new Isbn13Scorer().determineBestScore(context).getValue()); book.setSummary(new SummaryScorer().determineBestScore(context).getValue()); book.setPublisher(new PublisherScorer().determineBestScore(context).getValue()); book.setPublicationDate(new PublicationDateScorer().determineBestScore(context).getValue()); book.setTags(new TagsScorer().determineBestScore(context).getValue()); Binary epub = getBinaryFromFile(context); book.setEpub(epub); book.setFileSizeInKb(epub.getContents().length / 1024); book.setCover(new CoverScorer().determineBestScore(context).getValue()); book.setContents(getContent(context.getEpubBook().getContents()) ); log.info("Produced book {}", book); return book; } Book produce(BookImportContext context); }### Answer:
@Test public void testEnrichBooks() throws Exception { BookImportContext bookImportContext = new BookImportContext(new File("src/test/resources/epubs/W. H. Davenport Adams - Some heroes of Travel.epub")); Book book = new BookProducer().produce(bookImportContext); assertThat(book.getFirstAuthor(), is(new Author("Davenport", "Adams W. H."))); } |
### Question:
Response { public int getCode() { return code; } int getCode(); Response setCode(int code); InputStream getData(); Response setData(InputStream data); String getDataAsString(); Bitmap getAsBitmap(); }### Answer:
@Test public void getCode() throws Exception { } |
### Question:
BitMapTask extends Task<String, Void, Bitmap> { @Override protected void onPreExecute() { super.onPreExecute(); } BitMapTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<Bitmap> callback); }### Answer:
@Test public void onPreExecute() throws Exception { } |
### Question:
BitMapTask extends Task<String, Void, Bitmap> { @Override protected Bitmap doInBackground(String... urls) { try { Response response = makeRequest(mUrl, method, params, headers); Bitmap bitmap = response.getAsBitmap(); if (this.mCacheManager != null) { if (this.mCacheManager.getDataFromCache(mUrl) == null) this.mCacheManager.addDataToCache(mUrl, bitmap); } return bitmap; } catch (Exception e) { e.printStackTrace(); error = true; } return null; } BitMapTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<Bitmap> callback); }### Answer:
@Test public void doInBackground() throws Exception { } |
### Question:
BitMapTask extends Task<String, Void, Bitmap> { @Override protected void onPostExecute(Bitmap data) { super.onPostExecute(data); if (!error) this.callback.onResponse(data); else this.callback.onError(); } BitMapTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<Bitmap> callback); }### Answer:
@Test public void onPostExecute() throws Exception { } |
### Question:
BitMapTask extends Task<String, Void, Bitmap> { @Override protected void onCancelled() { super.onCancelled(); if (this.mCacheManager != null) { this.mCacheManager.removeDataFromCache(mUrl); } } BitMapTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<Bitmap> callback); }### Answer:
@Test public void onCancelled() throws Exception { } |
### Question:
JsonArrayTask extends Task<String, Void, JSONArray> { @Override protected void onPreExecute() { super.onPreExecute(); } JsonArrayTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<JSONArray> callback); }### Answer:
@Test public void onPreExecute() throws Exception { } |
### Question:
JsonArrayTask extends Task<String, Void, JSONArray> { @Override protected JSONArray doInBackground(String... urls) { try { Response response = makeRequest(mUrl, method, params, headers); JSONArray json = new JSONArray(response.getDataAsString()); if (this.mCacheManager != null) { if (this.mCacheManager.getDataFromCache(mUrl) == null) this.mCacheManager.addDataToCache(mUrl, json); } return json; } catch (Exception e) { e.printStackTrace(); error = true; } return null; } JsonArrayTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<JSONArray> callback); }### Answer:
@Test public void doInBackground() throws Exception { } |
### Question:
JsonArrayTask extends Task<String, Void, JSONArray> { @Override protected void onPostExecute(JSONArray data) { super.onPostExecute(data); if (!error) this.callback.onResponse(data); else this.callback.onError(); } JsonArrayTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<JSONArray> callback); }### Answer:
@Test public void onPostExecute() throws Exception { } |
### Question:
JsonArrayTask extends Task<String, Void, JSONArray> { @Override protected void onCancelled() { super.onCancelled(); if (this.mCacheManager != null) { this.mCacheManager.removeDataFromCache(mUrl); } } JsonArrayTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<JSONArray> callback); }### Answer:
@Test public void onCancelled() throws Exception { } |
### Question:
RequestParams { public String getKey() { return key; } String getKey(); RequestParams setKey(String key); String getValue(); RequestParams setValue(String value); }### Answer:
@Test public void getKey() throws Exception { } |
### Question:
RequestParams { public RequestParams setKey(String key) { this.key = key; return this; } String getKey(); RequestParams setKey(String key); String getValue(); RequestParams setValue(String value); }### Answer:
@Test public void setKey() throws Exception { } |
### Question:
Response { public Response setCode(int code) { this.code = code; return this; } int getCode(); Response setCode(int code); InputStream getData(); Response setData(InputStream data); String getDataAsString(); Bitmap getAsBitmap(); }### Answer:
@Test public void setCode() throws Exception { } |
### Question:
RequestParams { public String getValue() { return value; } String getKey(); RequestParams setKey(String key); String getValue(); RequestParams setValue(String value); }### Answer:
@Test public void getValue() throws Exception { } |
### Question:
RequestParams { public RequestParams setValue(String value) { this.value = value; return this; } String getKey(); RequestParams setKey(String key); String getValue(); RequestParams setValue(String value); }### Answer:
@Test public void setValue() throws Exception { } |
### Question:
HeaderParams { public String getKey() { return key; } String getKey(); HeaderParams setKey(String key); String getValue(); HeaderParams setValue(String value); }### Answer:
@Test public void getKey() throws Exception { } |
### Question:
HeaderParams { public HeaderParams setKey(String key) { this.key = key; return this; } String getKey(); HeaderParams setKey(String key); String getValue(); HeaderParams setValue(String value); }### Answer:
@Test public void setKey() throws Exception { } |
### Question:
HeaderParams { public String getValue() { return value; } String getKey(); HeaderParams setKey(String key); String getValue(); HeaderParams setValue(String value); }### Answer:
@Test public void getValue() throws Exception { } |
### Question:
HeaderParams { public HeaderParams setValue(String value) { this.value = value; return this; } String getKey(); HeaderParams setKey(String key); String getValue(); HeaderParams setValue(String value); }### Answer:
@Test public void setValue() throws Exception { } |
### Question:
CacheManager extends LruCache<String, T> implements CacheManagerInterface<T> { @Override protected int sizeOf(String key, T data) { int bytesCount; if (data instanceof Bitmap) { bytesCount = ((Bitmap) data).getByteCount(); } else if (data instanceof JSONObject) { bytesCount = ((JSONObject) data).toString().getBytes().length; } else { bytesCount = ((JSONArray) data).toString().getBytes().length; } return bytesCount / 1024; } CacheManager(int cacheSize); @Override void addDataToCache(String key, T data); @Override void removeDataFromCache(String key); @Override T getDataFromCache(String key); @Override void evictUnused(); }### Answer:
@Test public void sizeOf() throws Exception { } |
### Question:
CacheManager extends LruCache<String, T> implements CacheManagerInterface<T> { @Override public void addDataToCache(String key, T data) { if (getDataFromCache(key) == null) { synchronized (this) { put(key, data); cacheHitTimestamp.put(key, SystemClock.uptimeMillis()); } } } CacheManager(int cacheSize); @Override void addDataToCache(String key, T data); @Override void removeDataFromCache(String key); @Override T getDataFromCache(String key); @Override void evictUnused(); }### Answer:
@Test public void addDataToCache() throws Exception { } |
### Question:
CacheManager extends LruCache<String, T> implements CacheManagerInterface<T> { @Override public void removeDataFromCache(String key) { if (getDataFromCache(key) != null) { synchronized (this) { remove(key); } } } CacheManager(int cacheSize); @Override void addDataToCache(String key, T data); @Override void removeDataFromCache(String key); @Override T getDataFromCache(String key); @Override void evictUnused(); }### Answer:
@Test public void removeDataFromCache() throws Exception { } |
### Question:
CacheManager extends LruCache<String, T> implements CacheManagerInterface<T> { @Override public T getDataFromCache(String key) { synchronized (this) { cacheHitTimestamp.put(key, SystemClock.uptimeMillis()); evictUnused(); } return get(key); } CacheManager(int cacheSize); @Override void addDataToCache(String key, T data); @Override void removeDataFromCache(String key); @Override T getDataFromCache(String key); @Override void evictUnused(); }### Answer:
@Test public void getDataFromCache() throws Exception { } |
### Question:
Response { public InputStream getData() { return inputStream; } int getCode(); Response setCode(int code); InputStream getData(); Response setData(InputStream data); String getDataAsString(); Bitmap getAsBitmap(); }### Answer:
@Test public void getData() throws Exception { } |
### Question:
CacheManager extends LruCache<String, T> implements CacheManagerInterface<T> { @Override public void evictUnused() { Map<String, T> items = snapshot(); for (String key : items.keySet()) { long cacheTime = cacheHitTimestamp.get(key); if (cacheTime + timeout < SystemClock.uptimeMillis()) { remove(key); } } } CacheManager(int cacheSize); @Override void addDataToCache(String key, T data); @Override void removeDataFromCache(String key); @Override T getDataFromCache(String key); @Override void evictUnused(); }### Answer:
@Test public void evictUnused() throws Exception { } |
### Question:
JsonArray extends Type<JSONArray> { public JsonArray setCallback(HttpListener<JSONArray> listener) { this.mListener = listener; this.mListener.onRequest(); JSONArray data; if (mCacheManager != null) { data = mCacheManager.getDataFromCache(url); if (data != null) { mListener.onResponse(data); return this; } } mTask = new JsonArrayTask(method, url, params, headers, mListener); mTask.setmCachemanager(mCacheManager); mTask.execute(); return this; } JsonArray(DownZ.Method m, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers); JsonArray setCallback(HttpListener<JSONArray> listener); boolean cancel(); JsonArray setCacheManager(CacheManagerInterface<JSONArray> cache); }### Answer:
@Test public void setCallback() throws Exception { } |
### Question:
JsonArray extends Type<JSONArray> { public boolean cancel() { if (mTask != null) { mTask.cancel(true); if (mTask.isCancelled()) { mListener.onCancel(); return true; } else { return false; } } return false; } JsonArray(DownZ.Method m, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers); JsonArray setCallback(HttpListener<JSONArray> listener); boolean cancel(); JsonArray setCacheManager(CacheManagerInterface<JSONArray> cache); }### Answer:
@Test public void cancel() throws Exception { } |
### Question:
JsonArray extends Type<JSONArray> { public JsonArray setCacheManager(CacheManagerInterface<JSONArray> cache) { this.mCacheManager = cache; return this; } JsonArray(DownZ.Method m, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers); JsonArray setCallback(HttpListener<JSONArray> listener); boolean cancel(); JsonArray setCacheManager(CacheManagerInterface<JSONArray> cache); }### Answer:
@Test public void setCacheManager() throws Exception { } |
### Question:
BitMap extends Type<Bitmap> { public BitMap setCallback(HttpListener<Bitmap> listener) { this.listener = listener; this.listener.onRequest(); Bitmap data; if (mCacheManager != null) { data = mCacheManager.getDataFromCache(url); if (data != null) { this.listener.onResponse(data); return this; } } mTask = new BitMapTask(method, url, params, headers, this.listener); mTask.setmCachemanager(mCacheManager); mTask.execute(); return this; } BitMap(DownZ.Method m, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers); BitMap setCallback(HttpListener<Bitmap> listener); boolean cancel(); BitMap setCacheManager(CacheManagerInterface<Bitmap> cache); }### Answer:
@Test public void setCallback() throws Exception { } |
### Question:
BitMap extends Type<Bitmap> { public boolean cancel() { if (mTask != null) { mTask.cancel(true); if (mTask.isCancelled()) { listener.onCancel(); return true; } else { return false; } } return false; } BitMap(DownZ.Method m, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers); BitMap setCallback(HttpListener<Bitmap> listener); boolean cancel(); BitMap setCacheManager(CacheManagerInterface<Bitmap> cache); }### Answer:
@Test public void cancel() throws Exception { } |
### Question:
BitMap extends Type<Bitmap> { public BitMap setCacheManager(CacheManagerInterface<Bitmap> cache) { this.mCacheManager = cache; return this; } BitMap(DownZ.Method m, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers); BitMap setCallback(HttpListener<Bitmap> listener); boolean cancel(); BitMap setCacheManager(CacheManagerInterface<Bitmap> cache); }### Answer:
@Test public void setCacheManager() throws Exception { } |
### Question:
Type { public abstract Type setCacheManager(CacheManagerInterface<T> cacheManager); abstract Type setCacheManager(CacheManagerInterface<T> cacheManager); abstract Type setCallback(HttpListener<T> callback); abstract boolean cancel(); }### Answer:
@Test public void setCacheManager() throws Exception { } |
### Question:
Type { public abstract Type setCallback(HttpListener<T> callback); abstract Type setCacheManager(CacheManagerInterface<T> cacheManager); abstract Type setCallback(HttpListener<T> callback); abstract boolean cancel(); }### Answer:
@Test public void setCallback() throws Exception { } |
### Question:
Type { public abstract boolean cancel(); abstract Type setCacheManager(CacheManagerInterface<T> cacheManager); abstract Type setCallback(HttpListener<T> callback); abstract boolean cancel(); }### Answer:
@Test public void cancel() throws Exception { } |
### Question:
Response { public Response setData(InputStream data) { this.inputStream = data; return this; } int getCode(); Response setCode(int code); InputStream getData(); Response setData(InputStream data); String getDataAsString(); Bitmap getAsBitmap(); }### Answer:
@Test public void setData() throws Exception { } |
### Question:
JsonObject extends Type<JSONObject> { public JsonObject setCallback(HttpListener<JSONObject> listener) { this.mListener = listener; mListener.onRequest(); JSONObject data; if (mCacheManager != null) { data = mCacheManager.getDataFromCache(url); if (data != null) { mListener.onResponse(data); return this; } } mTask = new JsonObjectTask(method, url, params, headers, mListener); mTask.execute(); return this; } JsonObject(DownZ.Method m, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers); JsonObject setCallback(HttpListener<JSONObject> listener); boolean cancel(); JsonObject setCacheManager(CacheManagerInterface<JSONObject> cache); }### Answer:
@Test public void setCallback() throws Exception { } |
### Question:
JsonObject extends Type<JSONObject> { public boolean cancel() { if (mTask != null) { mTask.cancel(true); if (mTask.isCancelled()) { mListener.onCancel(); return true; } else { return false; } } return false; } JsonObject(DownZ.Method m, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers); JsonObject setCallback(HttpListener<JSONObject> listener); boolean cancel(); JsonObject setCacheManager(CacheManagerInterface<JSONObject> cache); }### Answer:
@Test public void cancel() throws Exception { } |
### Question:
JsonObject extends Type<JSONObject> { public JsonObject setCacheManager(CacheManagerInterface<JSONObject> cache) { this.mCacheManager = cache; return this; } JsonObject(DownZ.Method m, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers); JsonObject setCallback(HttpListener<JSONObject> listener); boolean cancel(); JsonObject setCacheManager(CacheManagerInterface<JSONObject> cache); }### Answer:
@Test public void setCacheManager() throws Exception { } |
### Question:
Response { public String getDataAsString() throws IOException { final int bufferSize = 1024; final char[] buffer = new char[bufferSize]; final StringBuilder out = new StringBuilder(); Reader in = new InputStreamReader(inputStream, "UTF-8"); for (; ; ) { int i = in.read(buffer, 0, buffer.length); if (i < 0) break; out.append(buffer, 0, i); } if (inputStream != null) { inputStream.close(); } return out.toString(); } int getCode(); Response setCode(int code); InputStream getData(); Response setData(InputStream data); String getDataAsString(); Bitmap getAsBitmap(); }### Answer:
@Test public void getDataAsString() throws Exception { } |
### Question:
Response { public Bitmap getAsBitmap() { Bitmap bitmap = BitmapFactory.decodeStream(this.inputStream); if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { e.printStackTrace(); } } return bitmap; } int getCode(); Response setCode(int code); InputStream getData(); Response setData(InputStream data); String getDataAsString(); Bitmap getAsBitmap(); }### Answer:
@Test public void getAsBitmap() throws Exception { } |
### Question:
JsonObjectTask extends Task<String, Void, JSONObject> { @Override protected void onPreExecute() { super.onPreExecute(); } JsonObjectTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<JSONObject> callback); }### Answer:
@Test public void onPreExecute() throws Exception { } |
### Question:
JsonObjectTask extends Task<String, Void, JSONObject> { @Override protected JSONObject doInBackground(String... urls) { try { Response response = makeRequest(mUrl, method, params, headers); JSONObject json = new JSONObject(response.getDataAsString()); if (this.mCacheManager != null) { if (this.mCacheManager.getDataFromCache(mUrl) == null) this.mCacheManager.addDataToCache(mUrl, json); } return json; } catch (Exception e) { e.printStackTrace(); error = true; } return null; } JsonObjectTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<JSONObject> callback); }### Answer:
@Test public void doInBackground() throws Exception { } |
### Question:
JsonObjectTask extends Task<String, Void, JSONObject> { @Override protected void onPostExecute(JSONObject data) { super.onPostExecute(data); if (!error) this.callback.onResponse(data); else this.callback.onError(); } JsonObjectTask(DownZ.Method method, String url, ArrayList<RequestParams> params, ArrayList<HeaderParams> headers, HttpListener<JSONObject> callback); }### Answer:
@Test public void onPostExecute() throws Exception { } |