method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
AlertViewAnimatorListener implements Animator.AnimatorListener { @Override public void onAnimationEnd(Animator animation) { hideAlertView(); } AlertViewAnimatorListener(AlertView alertView); @Override void onAnimationStart(Animator animation); @Override void onAnimationEnd(Animator animation); @Override void onAnimationCancel(Animator animation); @Override void onAnimationRepeat(Animator animation); }### Answer:
@Test public void onAnimationEnd_alertViewIsHidden() { AlertView alertView = mock(AlertView.class); AlertViewAnimatorListener listener = new AlertViewAnimatorListener(alertView); listener.onAnimationEnd(mock(Animator.class)); verify(alertView).hide(); } |
### Question:
NavigationCameraTrackingChangedListener implements OnCameraTrackingChangedListener { @Override public void onCameraTrackingDismissed() { camera.updateCameraTrackingMode(NavigationCamera.NAVIGATION_TRACKING_MODE_NONE); } NavigationCameraTrackingChangedListener(NavigationCamera camera); @Override void onCameraTrackingDismissed(); @Override void onCameraTrackingChanged(int currentMode); }### Answer:
@Test public void onCameraTrackingDismissed_cameraSetToTrackingNone() { NavigationCamera camera = mock(NavigationCamera.class); NavigationCameraTrackingChangedListener listener = new NavigationCameraTrackingChangedListener(camera); listener.onCameraTrackingDismissed(); verify(camera).updateCameraTrackingMode(eq(NavigationCamera.NAVIGATION_TRACKING_MODE_NONE)); } |
### Question:
NavigationCameraTrackingChangedListener implements OnCameraTrackingChangedListener { @Override public void onCameraTrackingChanged(int currentMode) { Integer trackingMode = camera.findTrackingModeFor(currentMode); if (trackingMode != null) { camera.updateCameraTrackingMode(trackingMode); } } NavigationCameraTrackingChangedListener(NavigationCamera camera); @Override void onCameraTrackingDismissed(); @Override void onCameraTrackingChanged(int currentMode); }### Answer:
@Test public void onCameraTrackingChanged_navigationCameraTrackingUpdated() { NavigationCamera camera = mock(NavigationCamera.class); when(camera.findTrackingModeFor(CameraMode.TRACKING_GPS)).thenReturn(NavigationCamera.NAVIGATION_TRACKING_MODE_GPS); NavigationCameraTrackingChangedListener listener = new NavigationCameraTrackingChangedListener(camera); listener.onCameraTrackingChanged(CameraMode.TRACKING_GPS); verify(camera).updateCameraTrackingMode(eq(NavigationCamera.NAVIGATION_TRACKING_MODE_GPS)); } |
### Question:
NavigationCameraTransitionListener implements OnLocationCameraTransitionListener { @Override public void onLocationCameraTransitionFinished(int cameraMode) { camera.updateTransitionListenersFinished(cameraMode); } NavigationCameraTransitionListener(NavigationCamera camera); @Override void onLocationCameraTransitionFinished(int cameraMode); @Override void onLocationCameraTransitionCanceled(int cameraMode); }### Answer:
@Test public void onLocationCameraTransitionFinished() { NavigationCamera camera = mock(NavigationCamera.class); NavigationCameraTransitionListener listener = new NavigationCameraTransitionListener(camera); int trackingGps = CameraMode.TRACKING_GPS; listener.onLocationCameraTransitionFinished(trackingGps); verify(camera).updateTransitionListenersFinished(trackingGps); } |
### Question:
NavigationCameraTransitionListener implements OnLocationCameraTransitionListener { @Override public void onLocationCameraTransitionCanceled(int cameraMode) { camera.updateTransitionListenersCancelled(cameraMode); camera.updateIsResetting(false); } NavigationCameraTransitionListener(NavigationCamera camera); @Override void onLocationCameraTransitionFinished(int cameraMode); @Override void onLocationCameraTransitionCanceled(int cameraMode); }### Answer:
@Test public void onLocationCameraTransitionCanceled() { NavigationCamera camera = mock(NavigationCamera.class); NavigationCameraTransitionListener listener = new NavigationCameraTransitionListener(camera); int trackingGpsNorth = CameraMode.TRACKING_GPS_NORTH; listener.onLocationCameraTransitionCanceled(trackingGpsNorth); verify(camera).updateTransitionListenersCancelled(trackingGpsNorth); }
@Test public void onLocationCameraTransitionCanceled_cameraStopsResetting() { NavigationCamera camera = mock(NavigationCamera.class); NavigationCameraTransitionListener listener = new NavigationCameraTransitionListener(camera); int trackingGpsNorth = CameraMode.TRACKING_GPS_NORTH; listener.onLocationCameraTransitionCanceled(trackingGpsNorth); verify(camera).updateIsResetting(eq(false)); } |
### Question:
ResetCancelableCallback implements MapboxMap.CancelableCallback { @Override public void onFinish() { camera.updateIsResetting(false); } ResetCancelableCallback(NavigationCamera camera); @Override void onCancel(); @Override void onFinish(); }### Answer:
@Test public void onFinish_dynamicCameraIsReset() { NavigationCamera camera = mock(NavigationCamera.class); ResetCancelableCallback callback = new ResetCancelableCallback(camera); callback.onFinish(); verify(camera).updateIsResetting(eq(false)); } |
### Question:
ResetCancelableCallback implements MapboxMap.CancelableCallback { @Override public void onCancel() { camera.updateIsResetting(false); } ResetCancelableCallback(NavigationCamera camera); @Override void onCancel(); @Override void onFinish(); }### Answer:
@Test public void onCancel_dynamicCameraIsReset() { NavigationCamera camera = mock(NavigationCamera.class); ResetCancelableCallback callback = new ResetCancelableCallback(camera); callback.onCancel(); verify(camera).updateIsResetting(eq(false)); } |
### Question:
InstructionListPresenter { void update(@NonNull RouteProgress routeProgress, @NonNull InstructionListAdapter adapter) { drivingSide = getDrivingSide(routeProgress); final List<BannerInstructions> routeInstructions = getBannerInstructionsFromRouteProgress(routeProgress); final List<BannerInstructions> filteredRouteInstructions = filterListAfterStep(routeProgress, routeInstructions); final List<BannerInstructions> oldItems = new ArrayList<>(instructions); final DiffUtil.DiffResult result = DiffUtil.calculateDiff(getDiffCallback(oldItems, filteredRouteInstructions)); instructions.clear(); instructions.addAll(filteredRouteInstructions); result.dispatchUpdatesTo(adapter); } InstructionListPresenter(DistanceFormatter distanceFormatter); }### Answer:
@Test public void update_notifyItemRangeInserted() throws Exception { RouteProgress routeProgress = buildRouteProgress(); InstructionListAdapter adapter = mock(InstructionListAdapter.class); DistanceFormatter distanceFormatter = mock(DistanceFormatter.class); InstructionListPresenter presenter = new InstructionListPresenter(distanceFormatter); presenter.update(routeProgress, adapter); verify(adapter).notifyItemRangeInserted(0, 12); }
@Test public void update_notifyItemRangeRemoved() throws Exception { RouteProgress initialRouteProgress = buildRouteProgress(); RouteProgress updatedRouteProgress = buildRouteProgressWithProgress(); InstructionListAdapter adapter = mock(InstructionListAdapter.class); DistanceFormatter distanceFormatter = mock(DistanceFormatter.class); InstructionListPresenter presenter = new InstructionListPresenter(distanceFormatter); presenter.update(initialRouteProgress, adapter); presenter.update(updatedRouteProgress, adapter); verify(adapter).notifyItemRangeRemoved(0, 3); } |
### Question:
NavigationViewModelProgressObserver implements RouteProgressObserver, LocationObserver { @Override public void onRouteProgressChanged(@NotNull RouteProgress routeProgress) { viewModel.updateRouteProgress(routeProgress); } NavigationViewModelProgressObserver(NavigationViewModel viewModel); @Override void onRawLocationChanged(@NotNull Location rawLocation); @Override void onEnhancedLocationChanged(
@NotNull Location enhancedLocation,
@NotNull List<? extends Location> keyPoints
); @Override void onRouteProgressChanged(@NotNull RouteProgress routeProgress); }### Answer:
@Test public void checksNavigationViewModelRouteProgressIsUpdatedWhenOnProgressChange() { NavigationViewModel mockedNavigationViewModel = mock(NavigationViewModel.class); NavigationViewModelProgressObserver theNavigationViewModelProgressObserver = new NavigationViewModelProgressObserver(mockedNavigationViewModel); RouteProgress theRouteProgress = mock(RouteProgress.class); theNavigationViewModelProgressObserver.onRouteProgressChanged(theRouteProgress); verify(mockedNavigationViewModel).updateRouteProgress(eq(theRouteProgress)); } |
### Question:
NavigationViewModelProgressObserver implements RouteProgressObserver, LocationObserver { @Override public void onEnhancedLocationChanged( @NotNull Location enhancedLocation, @NotNull List<? extends Location> keyPoints ) { viewModel.updateLocation(enhancedLocation); } NavigationViewModelProgressObserver(NavigationViewModel viewModel); @Override void onRawLocationChanged(@NotNull Location rawLocation); @Override void onEnhancedLocationChanged(
@NotNull Location enhancedLocation,
@NotNull List<? extends Location> keyPoints
); @Override void onRouteProgressChanged(@NotNull RouteProgress routeProgress); }### Answer:
@Test @SuppressWarnings("unchecked assignment") public void checksNavigationViewModelLocationIsUpdatedWhenOnProgressChange() { NavigationViewModel mockedNavigationViewModel = mock(NavigationViewModel.class); NavigationViewModelProgressObserver theNavigationViewModelProgressChangeListener = new NavigationViewModelProgressObserver(mockedNavigationViewModel); Location theLocation = mock(Location.class); List<? extends Location> keyPoints = mock(List.class); theNavigationViewModelProgressChangeListener.onEnhancedLocationChanged(theLocation, keyPoints); verify(mockedNavigationViewModel).updateLocation(eq(theLocation)); } |
### Question:
NavigationViewEventDispatcher { void initializeListeners( @NonNull NavigationViewOptions navigationViewOptions, @NonNull NavigationViewModel navigationViewModel ) { assignFeedbackListener(navigationViewOptions.feedbackListener()); assignNavigationListener(navigationViewOptions.navigationListener(), navigationViewModel); assignBottomSheetCallback(navigationViewOptions.bottomSheetCallback()); assignInstructionListListener(navigationViewOptions.instructionListListener()); assignSpeechAnnouncementListener(navigationViewOptions.speechAnnouncementListener()); assignBannerInstructionsListener(navigationViewOptions.bannerInstructionsListener()); navigation = navigationViewModel.retrieveNavigation(); if (navigation != null) { assignRouteProgressChangeObserver(navigationViewOptions, navigation); assignLocationObserver(navigationViewOptions, navigation); assignArrivalObserver(navigationViewOptions, navigation); } } }### Answer:
@Test public void onRouteProgressObserverAddedInOptions_isAddedToNavigation() { NavigationViewEventDispatcher eventDispatcher = new NavigationViewEventDispatcher(); NavigationViewOptions options = mock(NavigationViewOptions.class); RouteProgressObserver routeProgressObserver = setupRouteProgressObserver(options); NavigationViewModel navigationViewModel = mock(NavigationViewModel.class); MapboxNavigation navigation = mock(MapboxNavigation.class); when(navigationViewModel.retrieveNavigation()).thenReturn(navigation); eventDispatcher.initializeListeners(options, navigationViewModel); verify(navigation, times(1)).registerRouteProgressObserver(routeProgressObserver); } |
### Question:
InstructionCacheCallback implements Callback<ResponseBody> { @Override public void onResponse(@NonNull Call<ResponseBody> call, @NonNull Response<ResponseBody> response) { if (closeResponseBody(response)) { String url = call.request().url().toString(); loader.addCachedUrl(url); } } InstructionCacheCallback(VoiceInstructionLoader loader); @Override void onResponse(@NonNull Call<ResponseBody> call, @NonNull Response<ResponseBody> response); @Override void onFailure(@NonNull Call<ResponseBody> call, @NonNull Throwable throwable); }### Answer:
@Test public void onResponse_cachedUrlIsAdded() { VoiceInstructionLoader loader = mock(VoiceInstructionLoader.class); Response<ResponseBody> response = mock(Response.class); ResponseBody body = mock(ResponseBody.class); when(response.body()).thenReturn(body); String url = "http: Call call = buildMockCall(url); InstructionCacheCallback callback = new InstructionCacheCallback(loader); callback.onResponse(call, response); verify(loader).addCachedUrl(eq(url)); }
@Test public void onResponse_bodyIsClosed() { VoiceInstructionLoader loader = mock(VoiceInstructionLoader.class); Response<ResponseBody> response = mock(Response.class); ResponseBody body = mock(ResponseBody.class); when(response.body()).thenReturn(body); String url = "http: Call call = buildMockCall(url); InstructionCacheCallback callback = new InstructionCacheCallback(loader); callback.onResponse(call, response); verify(body).close(); }
@Test public void onResponse_nullBodyIsIgnored() { VoiceInstructionLoader loader = mock(VoiceInstructionLoader.class); Response<ResponseBody> response = mock(Response.class); String url = "http: Call call = buildMockCall(url); InstructionCacheCallback callback = new InstructionCacheCallback(loader); callback.onResponse(call, response); verifyZeroInteractions(loader); } |
### Question:
NavigationSpeechPlayer implements SpeechPlayer { @Override public void play(VoiceInstructions voiceInstructions) { voiceInstructionsQueue.offer(voiceInstructions); SpeechPlayer player = speechPlayerProvider.retrieveSpeechPlayer(); if (player != null) { player.play(voiceInstructionsQueue.poll()); } } NavigationSpeechPlayer(SpeechPlayerProvider speechPlayerProvider); @Override void play(VoiceInstructions voiceInstructions); @Override boolean isMuted(); @Override void setMuted(boolean isMuted); @Override void onOffRoute(); @Override void onDestroy(); }### Answer:
@Test public void onPlayAnnouncement_mapboxSpeechPlayerIsGivenAnnouncement() { MapboxSpeechPlayer speechPlayer = mock(MapboxSpeechPlayer.class); NavigationSpeechPlayer navigationSpeechPlayer = buildNavigationSpeechPlayer(speechPlayer); VoiceInstructions announcement = mock(VoiceInstructions.class); navigationSpeechPlayer.play(announcement); verify(speechPlayer).play(announcement); }
@Test public void onPlayAnnouncement_androidSpeechPlayerIsGivenAnnouncement() { AndroidSpeechPlayer speechPlayer = mock(AndroidSpeechPlayer.class); NavigationSpeechPlayer navigationSpeechPlayer = buildNavigationSpeechPlayer(speechPlayer); VoiceInstructions announcement = mock(VoiceInstructions.class); navigationSpeechPlayer.play(announcement); verify(speechPlayer).play(announcement); } |
### Question:
NavigationSpeechPlayer implements SpeechPlayer { @Override public void setMuted(boolean isMuted) { this.isMuted = isMuted; voiceInstructionsQueue.clear(); speechPlayerProvider.setMuted(isMuted); } NavigationSpeechPlayer(SpeechPlayerProvider speechPlayerProvider); @Override void play(VoiceInstructions voiceInstructions); @Override boolean isMuted(); @Override void setMuted(boolean isMuted); @Override void onOffRoute(); @Override void onDestroy(); }### Answer:
@Test public void onSetMuted_providerIsSetMuted() { SpeechPlayerProvider provider = mock(SpeechPlayerProvider.class); NavigationSpeechPlayer navigationSpeechPlayer = new NavigationSpeechPlayer(provider); navigationSpeechPlayer.setMuted(true); verify(provider).setMuted(true); } |
### Question:
NavigationSpeechPlayer implements SpeechPlayer { @Override public void onOffRoute() { voiceInstructionsQueue.clear(); speechPlayerProvider.onOffRoute(); } NavigationSpeechPlayer(SpeechPlayerProvider speechPlayerProvider); @Override void play(VoiceInstructions voiceInstructions); @Override boolean isMuted(); @Override void setMuted(boolean isMuted); @Override void onOffRoute(); @Override void onDestroy(); }### Answer:
@Test public void onOffRoute_providerOnOffRouteIsCalled() { SpeechPlayerProvider provider = mock(SpeechPlayerProvider.class); NavigationSpeechPlayer navigationSpeechPlayer = new NavigationSpeechPlayer(provider); navigationSpeechPlayer.onOffRoute(); verify(provider).onOffRoute(); }
@Test public void onDestroy_providerOnDestroyIsCalled() { SpeechPlayerProvider provider = mock(SpeechPlayerProvider.class); NavigationSpeechPlayer navigationSpeechPlayer = new NavigationSpeechPlayer(provider); navigationSpeechPlayer.onOffRoute(); verify(provider).onOffRoute(); } |
### Question:
NavigationVoiceListener implements VoiceListener { @Override public void onStart(@NonNull SpeechPlayerState state) { speechPlayerProvider.onSpeechPlayerStateChanged(state); audioFocusManager.requestAudioFocus(); } NavigationVoiceListener(SpeechPlayerProvider speechPlayerProvider,
SpeechAudioFocusManager audioFocusManager); @Override void onStart(@NonNull SpeechPlayerState state); @Override void onDone(@NonNull SpeechPlayerState state); @Override void onError(String errorText, VoiceInstructions voiceInstructions); }### Answer:
@Test public void onStart_audioFocusIsRequested() { SpeechAudioFocusManager audioFocusManager = mock(SpeechAudioFocusManager.class); NavigationVoiceListener navigationSpeechListener = buildSpeechListener(audioFocusManager); navigationSpeechListener.onStart(SpeechPlayerState.ONLINE_PLAYING); verify(audioFocusManager).requestAudioFocus(); }
@Test public void onStart_speechPlayerStateChanged() { SpeechPlayerProvider provider = mock(SpeechPlayerProvider.class); NavigationVoiceListener navigationSpeechListener = buildSpeechListener(provider); SpeechPlayerState speechPlayerState = mock(SpeechPlayerState.class); navigationSpeechListener.onStart(speechPlayerState); verify(provider).onSpeechPlayerStateChanged(speechPlayerState); } |
### Question:
NavigationVoiceListener implements VoiceListener { @Override public void onDone(@NonNull SpeechPlayerState state) { speechPlayerProvider.onSpeechPlayerStateChanged(state); if (state == SpeechPlayerState.IDLE) { audioFocusManager.abandonAudioFocus(); } } NavigationVoiceListener(SpeechPlayerProvider speechPlayerProvider,
SpeechAudioFocusManager audioFocusManager); @Override void onStart(@NonNull SpeechPlayerState state); @Override void onDone(@NonNull SpeechPlayerState state); @Override void onError(String errorText, VoiceInstructions voiceInstructions); }### Answer:
@Test public void onDone_audioFocusIsAbandoned() { SpeechAudioFocusManager audioFocusManager = mock(SpeechAudioFocusManager.class); NavigationVoiceListener navigationSpeechListener = buildSpeechListener(audioFocusManager); navigationSpeechListener.onDone(SpeechPlayerState.IDLE); verify(audioFocusManager).abandonAudioFocus(); }
@Test public void onDone_speechPlayerStateChangedToIdle() { SpeechPlayerProvider provider = mock(SpeechPlayerProvider.class); NavigationVoiceListener navigationSpeechListener = buildSpeechListener(provider); navigationSpeechListener.onDone(SpeechPlayerState.IDLE); verify(provider).onSpeechPlayerStateChanged(SpeechPlayerState.IDLE); navigationSpeechListener.onDone(SpeechPlayerState.OFFLINE_PLAYER_INITIALIZED); verify(provider).onSpeechPlayerStateChanged(SpeechPlayerState.IDLE); } |
### Question:
NavigationVoiceListener implements VoiceListener { @Override public void onError(String errorText, VoiceInstructions voiceInstructions) { Timber.e(errorText); speechPlayerProvider.onSpeechPlayerStateChanged(SpeechPlayerState.IDLE); speechPlayerProvider.retrieveAndroidSpeechPlayer().play(voiceInstructions); } NavigationVoiceListener(SpeechPlayerProvider speechPlayerProvider,
SpeechAudioFocusManager audioFocusManager); @Override void onStart(@NonNull SpeechPlayerState state); @Override void onDone(@NonNull SpeechPlayerState state); @Override void onError(String errorText, VoiceInstructions voiceInstructions); }### Answer:
@Test public void onError_fallbackGoesToAndroidSpeechPlayer() { SpeechPlayerProvider provider = mock(SpeechPlayerProvider.class); AndroidSpeechPlayer androidSpeechPlayer = mock(AndroidSpeechPlayer.class); when(provider.retrieveAndroidSpeechPlayer()).thenReturn(androidSpeechPlayer); NavigationVoiceListener navigationSpeechListener = buildSpeechListener(provider); VoiceInstructions announcement = buildAnnouncement(); navigationSpeechListener.onError("Error text", announcement); verify(androidSpeechPlayer).play(announcement); }
@Test public void onError_speechPlayerStateChangedToIdle() { SpeechPlayerProvider provider = mock(SpeechPlayerProvider.class); AndroidSpeechPlayer androidSpeechPlayer = mock(AndroidSpeechPlayer.class); when(provider.retrieveAndroidSpeechPlayer()).thenReturn(androidSpeechPlayer); NavigationVoiceListener navigationSpeechListener = buildSpeechListener(provider); VoiceInstructions announcement = buildAnnouncement(); navigationSpeechListener.onError(anyString(), announcement); verify(provider).onSpeechPlayerStateChanged(SpeechPlayerState.IDLE); } |
### Question:
SpeechPlayerProvider { AndroidSpeechPlayer retrieveAndroidSpeechPlayer() { return androidSpeechPlayer; } SpeechPlayerProvider(@NonNull Context context, String language,
boolean voiceLanguageSupported, @NonNull VoiceInstructionLoader voiceInstructionLoader); SpeechPlayerProvider(@NonNull Context context, String language,
boolean voiceLanguageSupported, @NonNull VoiceInstructionLoader voiceInstructionLoader,
ConnectivityStatusProvider connectivityStatus); void setIsFallbackAlwaysEnabled(boolean isFallbackAlwaysEnabled); }### Answer:
@Test public void retrieveAndroidSpeechPlayer_alwaysReturnsAndroidSpeechPlayer() { SpeechPlayerProvider provider = buildSpeechPlayerProvider(true); AndroidSpeechPlayer speechPlayer = provider.retrieveAndroidSpeechPlayer(); assertNotNull(speechPlayer); } |
### Question:
RouteCallStatus { boolean isRouting(@NonNull Date currentDate) { if (responseReceived) { return false; } return diffInMilliseconds(callDate, currentDate) < FIVE_SECONDS_IN_MILLISECONDS; } RouteCallStatus(Date callDate); }### Answer:
@Test public void isRouting_returnsTrueUnderTwoSeconds() { Date callDate = mock(Date.class); when(callDate.getTime()).thenReturn(0L); Date currentDate = mock(Date.class); when((currentDate.getTime())).thenReturn(1000L); RouteCallStatus callStatus = new RouteCallStatus(callDate); boolean isRouting = callStatus.isRouting(currentDate); assertTrue(isRouting); }
@Test public void isRouting_returnsFalseOverFiveSeconds() { Date callDate = mock(Date.class); when(callDate.getTime()).thenReturn(0L); Date currentDate = mock(Date.class); when((currentDate.getTime())).thenReturn(5100L); RouteCallStatus callStatus = new RouteCallStatus(callDate); boolean isRouting = callStatus.isRouting(currentDate); assertFalse(isRouting); } |
### Question:
NavigationViewWayNameListener implements OnWayNameChangedListener { @Override public void onWayNameChanged(@NonNull String wayName) { presenter.onWayNameChanged(wayName); } NavigationViewWayNameListener(NavigationPresenter presenter); @Override void onWayNameChanged(@NonNull String wayName); }### Answer:
@Test public void onWayNameChanged_presenterReceivesNewWayName() { NavigationPresenter presenter = mock(NavigationPresenter.class); String newWayName = "New way name"; OnWayNameChangedListener listener = new NavigationViewWayNameListener(presenter); listener.onWayNameChanged(newWayName); verify(presenter).onWayNameChanged(newWayName); } |
### Question:
SymbolOnStyleLoadedListener implements MapView.OnDidFinishLoadingStyleListener { @Override public void onDidFinishLoadingStyle() { mapboxMap.getStyle().addImage(MAPBOX_NAVIGATION_MARKER_NAME, markerBitmap); } SymbolOnStyleLoadedListener(MapboxMap mapboxMap, Bitmap markerBitmap); @Override void onDidFinishLoadingStyle(); }### Answer:
@Test public void onDidFinishLoadingStyle_markerIsAdded() { MapboxMap mapboxMap = mock(MapboxMap.class); Style style = mock(Style.class); when(mapboxMap.getStyle()).thenReturn(style); Bitmap markerBitmap = mock(Bitmap.class); SymbolOnStyleLoadedListener listener = new SymbolOnStyleLoadedListener(mapboxMap, markerBitmap); listener.onDidFinishLoadingStyle(); verify(style).addImage(eq(MAPBOX_NAVIGATION_MARKER_NAME), eq(markerBitmap)); } |
### Question:
MapFpsDelegate implements OnTrackingModeChangedListener, OnTrackingModeTransitionListener { void addProgressChangeListener(@NonNull MapboxNavigation navigation) { this.navigation = navigation; navigation.registerRouteProgressObserver(fpsProgressListener); } MapFpsDelegate(MapView mapView, MapBatteryMonitor batteryMonitor); @Override void onTrackingModeChanged(int trackingMode); @Override void onTransitionFinished(int trackingMode); @Override void onTransitionCancelled(int trackingMode); }### Answer:
@Test public void addProgressChangeListener_navigationReceivesListener() { MapboxNavigation navigation = mock(MapboxNavigation.class); MapFpsDelegate delegate = new MapFpsDelegate(mock(MapView.class), mock(MapBatteryMonitor.class)); delegate.addProgressChangeListener(navigation); verify(navigation).registerRouteProgressObserver(any(FpsDelegateProgressChangeListener.class)); } |
### Question:
Maybe { public abstract <B> Maybe<B> map(Function<A, B> func); private Maybe(); abstract Maybe<B> map(Function<A, B> func); abstract Maybe<B> bind(Function<A, Maybe<B>> func); abstract Maybe<A> filter(Predicate<A> predicate); abstract A getOrElse(A def); abstract boolean isDefined(); abstract Maybe<C> lift2(BiFunction<A, B, C> func, Maybe<B> maybe); static Just<A> just(A value); static Nothing<A> nothing(); static Maybe<A> fromNullable(A value); static Maybe<List<A>> sequence(List<Maybe<A>> list); }### Answer:
@Test public void testMap() { Map<String, String> param = new HashMap<>(); param.put("a", "5"); param.put("b", "true"); param.put("c", "-3"); assertEquals(5, readPositiveIntParam(param, "a")); assertEquals(0, readPositiveIntParam(param, "b")); assertEquals(0, readPositiveIntParam(param, "c")); assertEquals(0, readPositiveIntParam(param, "d")); } |
### Question:
CashMachine { public static Maybe<Integer> unitsLeft(List<Tuple<Integer, Integer>> currencySupply, Integer value, Integer unitsWanted) { return lookup(currencySupply, value) .bind(numUnits -> (unitsWanted < 0 || numUnits - unitsWanted < 0) ? Maybe.<Integer>nothing() : just(numUnits - unitsWanted)); } static Maybe<V> lookup(List<Tuple<K, V>> tupleList, K key); static Maybe<Integer> unitsLeft(List<Tuple<Integer, Integer>> currencySupply, Integer value, Integer unitsWanted); static List<String> listNotes(List<A> amounts, List<String> currencies); static Maybe<List<Integer>> checkAmountServiceable(List<Tuple<Integer, Integer>> currencySupply, List<Tuple<Integer, Integer>> combination); static List<Tuple<Integer, Integer>> createValueUnitTuplesForValue(Integer amount, Integer currencyValue); static List<List<Tuple<Integer, Integer>>> findCombinationSearchSpaceForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findCombinationsForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findServiceableCombinations(Integer amount, List<Tuple<Integer, Integer>> machineSupply); }### Answer:
@Test public void testUnitsLeftAfterTakeThreeTwenties() { Maybe<Integer> result = CashMachine.unitsLeft(currencySupply, 20, 3); assert (result.equals(just(2))); }
@Test public void testUnitsLeftAfterTakeOneHundred() { Maybe<Integer> result = CashMachine.unitsLeft(currencySupply, 100, 1); assert (result.equals(nothing())); } |
### Question:
CashMachine { public static <A> List<String> listNotes(List<A> amounts, List<String> currencies) { return amounts.bind(amount -> (List<String>) currencies.bind(currency -> List.itemList(currency + amount.toString()))); } static Maybe<V> lookup(List<Tuple<K, V>> tupleList, K key); static Maybe<Integer> unitsLeft(List<Tuple<Integer, Integer>> currencySupply, Integer value, Integer unitsWanted); static List<String> listNotes(List<A> amounts, List<String> currencies); static Maybe<List<Integer>> checkAmountServiceable(List<Tuple<Integer, Integer>> currencySupply, List<Tuple<Integer, Integer>> combination); static List<Tuple<Integer, Integer>> createValueUnitTuplesForValue(Integer amount, Integer currencyValue); static List<List<Tuple<Integer, Integer>>> findCombinationSearchSpaceForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findCombinationsForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findServiceableCombinations(Integer amount, List<Tuple<Integer, Integer>> machineSupply); }### Answer:
@Test public void testListMachineNotes() { List<String> currencies = itemList("$AU", "$NZ"); List<String> result = CashMachine.listNotes(itemList(20, 50, 100), currencies); assert (result.equals(itemList("$AU20", "$NZ20", "$AU50", "$NZ50", "$AU100", "$NZ100"))); } |
### Question:
CashMachine { public static Maybe<List<Integer>> checkAmountServiceable(List<Tuple<Integer, Integer>> currencySupply, List<Tuple<Integer, Integer>> combination) { return sequence(combination.foldRight((tuple, acc) -> List.cons(unitsLeft(currencySupply, tuple.first(), tuple.second()), acc), (List<Maybe<Integer>>) List.<Maybe<Integer>>emptyList())); } static Maybe<V> lookup(List<Tuple<K, V>> tupleList, K key); static Maybe<Integer> unitsLeft(List<Tuple<Integer, Integer>> currencySupply, Integer value, Integer unitsWanted); static List<String> listNotes(List<A> amounts, List<String> currencies); static Maybe<List<Integer>> checkAmountServiceable(List<Tuple<Integer, Integer>> currencySupply, List<Tuple<Integer, Integer>> combination); static List<Tuple<Integer, Integer>> createValueUnitTuplesForValue(Integer amount, Integer currencyValue); static List<List<Tuple<Integer, Integer>>> findCombinationSearchSpaceForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findCombinationsForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findServiceableCombinations(Integer amount, List<Tuple<Integer, Integer>> machineSupply); }### Answer:
@Test public void testSeventyComboServiceable() { List<Tuple<Integer, Integer>> combination = itemList(tuple(20, 1), tuple(50, 1)); Maybe<List<Integer>> result = CashMachine.checkAmountServiceable(currencySupply, combination); assert (result.equals(just(List.itemList(4, 9)))); }
@Test public void testOneHundredAndSeventyComboNotServiceable() { List<Tuple<Integer, Integer>> combination = itemList(tuple(20, 6), tuple(50, 1)); Maybe<List<Integer>> result = CashMachine.checkAmountServiceable(currencySupply, combination); assert (result.equals(nothing())); } |
### Question:
CashMachine { public static List<Tuple<Integer, Integer>> createValueUnitTuplesForValue(Integer amount, Integer currencyValue) { List<Tuple<Integer, Integer>> result = List.emptyList(); for (int i = amount/currencyValue; i >= 0; i--) { result = List.cons(Tuple.tuple(currencyValue, i), result); } return result; } static Maybe<V> lookup(List<Tuple<K, V>> tupleList, K key); static Maybe<Integer> unitsLeft(List<Tuple<Integer, Integer>> currencySupply, Integer value, Integer unitsWanted); static List<String> listNotes(List<A> amounts, List<String> currencies); static Maybe<List<Integer>> checkAmountServiceable(List<Tuple<Integer, Integer>> currencySupply, List<Tuple<Integer, Integer>> combination); static List<Tuple<Integer, Integer>> createValueUnitTuplesForValue(Integer amount, Integer currencyValue); static List<List<Tuple<Integer, Integer>>> findCombinationSearchSpaceForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findCombinationsForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findServiceableCombinations(Integer amount, List<Tuple<Integer, Integer>> machineSupply); }### Answer:
@Test public void testCreateValueUnitTuples() { List<Tuple<Integer, Integer>> result = CashMachine.createValueUnitTuplesForValue(100, 50); assert (result.equals(List.itemList(tuple(50, 0), tuple(50, 1), tuple(50, 2)))); } |
### Question:
CashMachine { public static List<List<Tuple<Integer, Integer>>> findCombinationsForAmount(Integer amount, List<Integer> machineCurrencies) { return findCombinationSearchSpaceForAmount(amount, machineCurrencies).filter(list -> (list.foldRight((tuple, acc) -> acc + (tuple.first() * tuple.second()), 0)).equals(amount)); } static Maybe<V> lookup(List<Tuple<K, V>> tupleList, K key); static Maybe<Integer> unitsLeft(List<Tuple<Integer, Integer>> currencySupply, Integer value, Integer unitsWanted); static List<String> listNotes(List<A> amounts, List<String> currencies); static Maybe<List<Integer>> checkAmountServiceable(List<Tuple<Integer, Integer>> currencySupply, List<Tuple<Integer, Integer>> combination); static List<Tuple<Integer, Integer>> createValueUnitTuplesForValue(Integer amount, Integer currencyValue); static List<List<Tuple<Integer, Integer>>> findCombinationSearchSpaceForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findCombinationsForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findServiceableCombinations(Integer amount, List<Tuple<Integer, Integer>> machineSupply); }### Answer:
@Test public void testFindCombosForAmount() { List<List<Tuple<Integer, Integer>>> result = CashMachine.findCombinationsForAmount(100, itemList(20, 50, 100)); assert (result.equals(itemList(itemList(tuple(20, 0), tuple(50, 0), tuple(100, 1)), itemList(tuple(20, 0), tuple(50, 2), tuple(100, 0)), itemList(tuple(20, 5), tuple(50, 0), tuple(100, 0))))); } |
### Question:
CashMachine { public static List<List<Tuple<Integer, Integer>>> findServiceableCombinations(Integer amount, List<Tuple<Integer, Integer>> machineSupply) { List<Integer> machineCurrencies = machineSupply.foldRight((tuple, acc) -> List.cons(tuple.first(), acc), (List<Integer>) List.<Integer>emptyList()); return findCombinationsForAmount(amount, machineCurrencies).filter(combo -> checkAmountServiceable(machineSupply, combo).isDefined()); } static Maybe<V> lookup(List<Tuple<K, V>> tupleList, K key); static Maybe<Integer> unitsLeft(List<Tuple<Integer, Integer>> currencySupply, Integer value, Integer unitsWanted); static List<String> listNotes(List<A> amounts, List<String> currencies); static Maybe<List<Integer>> checkAmountServiceable(List<Tuple<Integer, Integer>> currencySupply, List<Tuple<Integer, Integer>> combination); static List<Tuple<Integer, Integer>> createValueUnitTuplesForValue(Integer amount, Integer currencyValue); static List<List<Tuple<Integer, Integer>>> findCombinationSearchSpaceForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findCombinationsForAmount(Integer amount, List<Integer> machineCurrencies); static List<List<Tuple<Integer, Integer>>> findServiceableCombinations(Integer amount, List<Tuple<Integer, Integer>> machineSupply); }### Answer:
@Test public void testFindServiceableCombos() { List<List<Tuple<Integer, Integer>>> result = CashMachine.findServiceableCombinations(100, currencySupply); assert (result.equals(itemList(itemList(tuple(20, 0), tuple(50, 2), tuple(100, 0)), itemList(tuple(20, 5), tuple(50, 0), tuple(100, 0))))); } |
### Question:
Maybe { public abstract <B, C> Maybe<C> lift2(BiFunction<A, B, C> func, Maybe<B> maybe); private Maybe(); abstract Maybe<B> map(Function<A, B> func); abstract Maybe<B> bind(Function<A, Maybe<B>> func); abstract Maybe<A> filter(Predicate<A> predicate); abstract A getOrElse(A def); abstract boolean isDefined(); abstract Maybe<C> lift2(BiFunction<A, B, C> func, Maybe<B> maybe); static Just<A> just(A value); static Nothing<A> nothing(); static Maybe<A> fromNullable(A value); static Maybe<List<A>> sequence(List<Maybe<A>> list); }### Answer:
@Test public void testLift2() { BiFunction<Integer, Integer, Integer> function = (a, b) -> a + b; Maybe<Integer> maybe = just(1); Maybe<Integer> maybe2 = just(2); Maybe<Integer> result = maybe.lift2(function, maybe2); assert (result.equals(just(3))); } |
### Question:
Maybe { public static <A> Maybe<List<A>> sequence(List<Maybe<A>> list) { return list.foldRight((o, a) -> o.lift2(List::cons, a), (Maybe<List<A>>) Maybe.<List<A>>just(List.<A>emptyList())); } private Maybe(); abstract Maybe<B> map(Function<A, B> func); abstract Maybe<B> bind(Function<A, Maybe<B>> func); abstract Maybe<A> filter(Predicate<A> predicate); abstract A getOrElse(A def); abstract boolean isDefined(); abstract Maybe<C> lift2(BiFunction<A, B, C> func, Maybe<B> maybe); static Just<A> just(A value); static Nothing<A> nothing(); static Maybe<A> fromNullable(A value); static Maybe<List<A>> sequence(List<Maybe<A>> list); }### Answer:
@Test public void testSequence() { List<Maybe<Integer>> list = itemList(fromNullable(1), fromNullable(2), fromNullable(3)); Maybe<List<Integer>> result = Maybe.sequence(list); assert (result.equals(just(itemList(1, 2, 3)))); } |
### Question:
List { public abstract List<A> append(List<A> list); private List(); abstract List<B> map(Function<A, B> func); abstract List<B> bind(Function<A, List<B>> func); abstract List<A> filter(Predicate<A> predicate); abstract boolean isEmpty(); abstract B foldRight(BiFunction<A, B, B> function, B accumulator); abstract List<A> append(List<A> list); abstract List<C> lift2(BiFunction<A, B, C> function, List<B> list); static EmptyList<A> emptyList(); @SafeVarargs static List<A> itemList(A... values); static List<A> cons(A value, List<A> list); static List<List<A>> sequence(List<List<A>> list); }### Answer:
@Test public void testAppend() { List<Integer> list = itemList(1, 2, 3); List<Integer> list2 = itemList(4, 5); List<Integer> result = list.append(list2); assert(result.equals(itemList(1, 2, 3, 4, 5))); } |
### Question:
List { public abstract <B> B foldRight(BiFunction<A, B, B> function, B accumulator); private List(); abstract List<B> map(Function<A, B> func); abstract List<B> bind(Function<A, List<B>> func); abstract List<A> filter(Predicate<A> predicate); abstract boolean isEmpty(); abstract B foldRight(BiFunction<A, B, B> function, B accumulator); abstract List<A> append(List<A> list); abstract List<C> lift2(BiFunction<A, B, C> function, List<B> list); static EmptyList<A> emptyList(); @SafeVarargs static List<A> itemList(A... values); static List<A> cons(A value, List<A> list); static List<List<A>> sequence(List<List<A>> list); }### Answer:
@Test public void testFoldRight() { List<Integer> list = itemList(1, 2, 3); List<Integer> acc = List.emptyList(); List<Integer> result = list.foldRight((integer, accumulator) -> cons(integer + 1, accumulator), acc); assert(result.equals(itemList(2, 3, 4))); } |
### Question:
List { public abstract List<A> filter(Predicate<A> predicate); private List(); abstract List<B> map(Function<A, B> func); abstract List<B> bind(Function<A, List<B>> func); abstract List<A> filter(Predicate<A> predicate); abstract boolean isEmpty(); abstract B foldRight(BiFunction<A, B, B> function, B accumulator); abstract List<A> append(List<A> list); abstract List<C> lift2(BiFunction<A, B, C> function, List<B> list); static EmptyList<A> emptyList(); @SafeVarargs static List<A> itemList(A... values); static List<A> cons(A value, List<A> list); static List<List<A>> sequence(List<List<A>> list); }### Answer:
@Test public void testFilter() { List<Integer> list = itemList(1, 2, 3); List<Integer> result = list.filter(i -> i % 2 == 0); assert(result.equals(itemList(2))); } |
### Question:
List { public abstract <B> List<B> map(Function<A, B> func); private List(); abstract List<B> map(Function<A, B> func); abstract List<B> bind(Function<A, List<B>> func); abstract List<A> filter(Predicate<A> predicate); abstract boolean isEmpty(); abstract B foldRight(BiFunction<A, B, B> function, B accumulator); abstract List<A> append(List<A> list); abstract List<C> lift2(BiFunction<A, B, C> function, List<B> list); static EmptyList<A> emptyList(); @SafeVarargs static List<A> itemList(A... values); static List<A> cons(A value, List<A> list); static List<List<A>> sequence(List<List<A>> list); }### Answer:
@Test public void testMap() { List<Integer> list = itemList(1, 2, 3); List<Integer> result = list.map(i -> i + 1); assert(result.equals(itemList(2, 3, 4))); } |
### Question:
List { public abstract <B> List<B> bind(Function<A, List<B>> func); private List(); abstract List<B> map(Function<A, B> func); abstract List<B> bind(Function<A, List<B>> func); abstract List<A> filter(Predicate<A> predicate); abstract boolean isEmpty(); abstract B foldRight(BiFunction<A, B, B> function, B accumulator); abstract List<A> append(List<A> list); abstract List<C> lift2(BiFunction<A, B, C> function, List<B> list); static EmptyList<A> emptyList(); @SafeVarargs static List<A> itemList(A... values); static List<A> cons(A value, List<A> list); static List<List<A>> sequence(List<List<A>> list); }### Answer:
@Test public void testBind() { List<Integer> list = itemList(1, 2, 3); List<Integer> result = list.bind(integer -> itemList(integer * 2)); assert(result.equals(itemList(2, 4, 6))); } |
### Question:
List { public abstract <B, C> List<C> lift2(BiFunction<A, B, C> function, List<B> list); private List(); abstract List<B> map(Function<A, B> func); abstract List<B> bind(Function<A, List<B>> func); abstract List<A> filter(Predicate<A> predicate); abstract boolean isEmpty(); abstract B foldRight(BiFunction<A, B, B> function, B accumulator); abstract List<A> append(List<A> list); abstract List<C> lift2(BiFunction<A, B, C> function, List<B> list); static EmptyList<A> emptyList(); @SafeVarargs static List<A> itemList(A... values); static List<A> cons(A value, List<A> list); static List<List<A>> sequence(List<List<A>> list); }### Answer:
@Test public void testLift2() { BiFunction<Integer, Integer, Integer> function = (a, b) -> a + b; List<Integer> list = itemList(1, 2, 3); List<Integer> list2 = itemList(4, 5, 6); List<Integer> result = list.lift2(function, list2); assert(result.equals(itemList(5, 6, 7, 6, 7, 8, 7, 8, 9))); } |
### Question:
List { public static <A> List<List<A>> sequence(List<List<A>> list) { return list.foldRight((l, a) -> l.lift2(List::cons, a), itemList((List<A>) List.<A>emptyList())); } private List(); abstract List<B> map(Function<A, B> func); abstract List<B> bind(Function<A, List<B>> func); abstract List<A> filter(Predicate<A> predicate); abstract boolean isEmpty(); abstract B foldRight(BiFunction<A, B, B> function, B accumulator); abstract List<A> append(List<A> list); abstract List<C> lift2(BiFunction<A, B, C> function, List<B> list); static EmptyList<A> emptyList(); @SafeVarargs static List<A> itemList(A... values); static List<A> cons(A value, List<A> list); static List<List<A>> sequence(List<List<A>> list); }### Answer:
@Test public void testSequence() { List<List<Integer>> list = itemList(itemList(1, 2), itemList(3, 4)); List<List<Integer>> result = List.sequence(list); assert(result.equals(itemList(itemList(1, 3), itemList(1, 4), itemList(2, 3), itemList(2, 4)))); } |
### Question:
JbpmRestClient { public void newProcessInstance(String processId) throws URISyntaxException, IOException { URI startProcessUrl = new URL(jbpmUrl + "/rs/process/definition/" + processId + "/new_instance").toURI(); HttpPost newInstance = new HttpPost(startProcessUrl); httpclient.execute(newInstance); } JbpmRestClient(HttpClient httpclient, String jbpmUrl); void logon(String username, String password); void newProcessInstanceAndCompleteFirstTask(String processId, Map<String,Object> params); void newProcessInstance(String processId); }### Answer:
@Test @Ignore public void testNewProcessInstance() throws Exception { HttpClient httpclient = new DefaultHttpClient(); JbpmRestClient jbpmClient = new JbpmRestClient(httpclient, "http: try { jbpmClient.logon("admin", "admin"); Map<String,Object> parameters = new HashMap<String,Object>(); parameters.put("DevDeploymentUrl", "http: parameters.put("DevDeploymentUrlMethod", "POST"); parameters.put("ArtifactUuid", "e67e1b09-1de7-4945-a47f-45646752437a"); jbpmClient.newProcessInstanceAndCompleteFirstTask("overlord.demo.SimpleReleaseProcess",parameters); } catch (IOException e) { e.printStackTrace(); } finally { httpclient.getConnectionManager().shutdown(); } } |
### Question:
WorkflowFactory { public static BpmManager newInstance() { BpmManager bpmManager = ServiceRegistryUtil.getSingleService(BpmManager.class); if (bpmManager == null) throw new RuntimeException(Messages.i18n.format("WorkflowFactory.MissingBPMProvider")); return bpmManager; } static BpmManager newInstance(); }### Answer:
@Test public void testPersistenceFactory() throws Exception { BpmManager bpmManager = WorkflowFactory.newInstance(); Assert.assertEquals(EmbeddedJbpmManager.class, bpmManager.getClass()); }
@Test @Ignore public void testNewProcessInstance() throws Exception { BpmManager bpmManager = WorkflowFactory.newInstance(); String processId = "com.sample.evaluation"; Map<String,Object> parameters = new HashMap<String,Object>(); parameters.put("employee", "krisv"); parameters.put("reason", "just bc"); parameters.put("uuid", "some-uuid-" + new Date()); bpmManager.newProcessInstance(null, processId, parameters); } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public void destroy() throws ImplementationException { killWorkflowSubprocess(); removeFromShutdownHooks(); deleteWorkingDirectory(); deleteSecurityManagerDirectory(); core.deleteLocalResources(); } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test public void testDestroy1() throws Exception { lw.destroy(); assertEquals(l(), events); } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public RemoteListener makeListener(String type, String configuration) throws RemoteException { throw new RemoteException("listener manufacturing unsupported"); } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test public void testMakeListener() { Throwable t = null; try { lw.makeListener("?", "?"); } catch (Throwable caught) { t = caught; } assertNotNull(t); assertSame(RemoteException.class, t.getClass()); assertNotNull(t.getMessage()); assertEquals("listener manufacturing unsupported", t.getMessage()); } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public void addListener(RemoteListener listener) throws RemoteException, ImplementationException { throw new ImplementationException("not implemented"); } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test public void testAddListener() { Throwable t = null; try { lw.addListener(null); } catch (Throwable caught) { t = caught; } assertNotNull(t); assertSame(ImplementationException.class, t.getClass()); assertNotNull(t.getMessage()); assertEquals("not implemented", t.getMessage()); } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public void setOutputBaclavaFile(String filename) throws RemoteException { if (status != Initialized) throw new IllegalStateException("not initializing"); if (filename != null) outputBaclavaFile = validateFilename(filename); else outputBaclavaFile = null; outputBaclava = filename; } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSetOutputBaclavaFile2() throws Exception { lw.setOutputBaclavaFile("/foobar"); }
@Test(expected = IllegalArgumentException.class) public void testSetOutputBaclavaFile3() throws Exception { lw.setOutputBaclavaFile("foo/../bar"); } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public String getInputBaclavaFile() { return inputBaclava; } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test public void testGetInputBaclavaFile() throws Exception { assertNull(lw.getInputBaclavaFile()); lw.setInputBaclavaFile("IBaclava"); assertNotNull(lw.getInputBaclavaFile()); assertEquals("IBaclava", lw.getInputBaclavaFile()); lw.makeInput("FOO").setValue("BAR"); assertNull(lw.getInputBaclavaFile()); } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public List<String> getListenerTypes() { return emptyList(); } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test public void testGetListenerTypes() { assertEquals("[]", lw.getListenerTypes().toString()); } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public List<RemoteListener> getListeners() { return singletonList(core.getDefaultListener()); } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test public void testGetListeners() throws Exception { assertEquals(1, lw.getListeners().size()); RemoteListener rl = lw.getListeners().get(0); assertEquals("RLNAME", rl.getName()); assertEquals("RLCONFIG", rl.getConfiguration()); assertEquals("RLTYPE", rl.getType()); assertEquals("[RLP1, RLP2]", Arrays.asList(rl.listProperties()) .toString()); assertEquals("RLPROP[RLP1]", rl.getProperty("RLP1")); assertEquals("RLPROP[RLP2]", rl.getProperty("RLP2")); rl.setProperty("FOOBAR", "BARFOO"); assertEquals(l("setProperty[", "FOOBAR", "BARFOO", "]"), events); } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public String getOutputBaclavaFile() { return outputBaclava; } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test public void testGetOutputBaclavaFile() throws Exception { assertNull(lw.getOutputBaclavaFile()); lw.setOutputBaclavaFile("notnull"); assertEquals("notnull", lw.getOutputBaclavaFile()); lw.setOutputBaclavaFile(null); assertNull(lw.getOutputBaclavaFile()); } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public RemoteSecurityContext getSecurityContext() throws RemoteException, ImplementationException { try { return new SecurityDelegate(masterToken); } catch (RemoteException e) { if (e.getCause() != null) throw new ImplementationException( "problem initializing security context", e.getCause()); throw e; } catch (IOException e) { throw new ImplementationException( "problem initializing security context", e); } } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test public void testGetSecurityContext() throws Exception { boolean md = DO_MKDIR; LocalWorker.DO_MKDIR = false; try { assertNotNull(lw.getSecurityContext()); } finally { LocalWorker.DO_MKDIR = md; } } |
### Question:
LocalWorker extends UnicastRemoteObject implements RemoteSingleRun { @Override public RemoteDirectory getWorkingDirectory() { return baseDir; } protected LocalWorker(String executeWorkflowCommand, String workflow,
UsageRecordReceiver urReceiver, UUID id,
Map<String, String> seedEnvironment, List<String> javaParams,
WorkerFactory workerFactory); @Override void destroy(); @Override void addListener(RemoteListener listener); @Override String getInputBaclavaFile(); @Override List<RemoteInput> getInputs(); @Override List<String> getListenerTypes(); @Override List<RemoteListener> getListeners(); @Override String getOutputBaclavaFile(); @Override RemoteSecurityContext getSecurityContext(); @Override RemoteStatus getStatus(); @Override RemoteDirectory getWorkingDirectory(); @Override RemoteInput makeInput(String name); @Override RemoteListener makeListener(String type, String configuration); @Override void setInputBaclavaFile(String filename); @Override void setOutputBaclavaFile(String filename); @Override void setGenerateProvenance(boolean prov); @Override void setStatus(RemoteStatus newStatus); @Override Date getFinishTimestamp(); @Override Date getStartTimestamp(); @Override void setInteractionServiceDetails(URL feed, URL webdav, URL publish); @Override void ping(); }### Answer:
@Test public void testGetWorkingDirectory() throws Exception { RemoteDirectory rd = lw.getWorkingDirectory(); assertNotNull(rd); assertNotNull(rd.getContents()); assertNull(rd.getContainingDirectory()); assertNotNull(rd.getName()); assertEquals(-1, rd.getName().indexOf('/')); assertFalse("..".equals(rd.getName())); assertEquals("", rd.getName()); } |
### Question:
Generate { public static void main(final String[] args) { final File baseDirectory = new File(args.length == 0 ? "." : args[0]); if (!baseDirectory.isDirectory()) { LOGGER.log(Level.SEVERE, baseDirectory.getAbsolutePath() + " is not a directory."); } else { new Generate().handleDirectory(baseDirectory); } } static void main(final String[] args); }### Answer:
@Test public void test() throws IOException { createFile("base/withinfo/ClassA.java", "package base.withinfo;\n\npublic ClassA {\n}\n"); createFile("base/withinfo/package-info.java", "base withinfo.second;\n"); createFile("base/noinfo/ClassA.java", "package base.noinfo;\n\npublic ClassA {\n}\n"); Generate.main(new String[] { baseDirectory.getAbsolutePath() }); String contents = readFile("base/noinfo/package-info.java"); Assert.assertEquals("package base.noinfo;\n", contents); }
@Test public void testNotADirectory() throws IOException { File file = createFile("base/withinfo/ClassA.java", "package base.withinfo;\n\npublic ClassA {\n}\n"); Generate.main(new String[] { file.getAbsolutePath() }); } |
### Question:
MissingPackageInfoRule extends AbstractPackageAnalyzerRule implements PackageAnalyzerRule { @Override public void scanModel(final SensorContext context, final ActiveRule rule, final Model<Location> model) { for (final Package<Location> packageToCheck : model.getPackages()) { LOGGER.debug("Package {}: extenal={}", packageToCheck.getExternal()); if (packageToCheck.getExternal() == null) { for (final Class<Location> classToReport : packageToCheck.getClasses()) { registerIssue(context, rule, classToReport, "Add a package-info.java to the package."); } } } } MissingPackageInfoRule(); @Override void define(final NewRepository repository); @Override boolean supportsLanguage(final String language); @Override void scanModel(final SensorContext context, final ActiveRule rule, final Model<Location> model); }### Answer:
@Test public void test() { final Model<Location> model = new Model<>(); model.addPackage("packageA", location("packageA/package-info.java")); model.addClass(Name.of("packageA.ClassA"), true, location("packageA/ClassA.java")); model.addClass(Name.of("packageA.ClassB"), true, location("packageA/ClassB.java")); model.addPackage("packageB", null); model.addClass(Name.of("packageB.ClassA"), true, location("packageB/ClassA.java")); model.addClass(Name.of("packageB.ClassB"), true, null); model.addClass(Name.of("packageB.ClassC"), true, location("packageB/ClassC.java")); subject.scanModel(sensorContext, activeRule, model); Assert.assertEquals(2, sensorContext.allIssues().size()); final List<String> keys = sensorContext.allIssues().stream() .map(issue -> issue.primaryLocation().inputComponent().key()).collect(Collectors.toList()); Assert.assertTrue(keys.contains(BaseRuleTest.PROJECT_KEY + ":packageB/ClassA.java")); Assert.assertTrue(keys.contains(BaseRuleTest.PROJECT_KEY + ":packageB/ClassC.java")); } |
### Question:
AbstractPackageAnalyzerRule implements PackageAnalyzerRule { @Override public final void scanModel(final SensorContext context, final String language, final Model<Location> model) { final ActiveRule rule = context.activeRules().find(RuleKey.of(BaseRules.getRepositoryKey(language), ruleKey)); if (rule == null) { LOGGER.debug("Rule {}:{} is not active", BaseRules.getRepositoryKey(language), ruleKey); return; } scanModel(context, rule, model); } protected AbstractPackageAnalyzerRule(final String ruleKey); @Override final void scanModel(final SensorContext context, final String language, final Model<Location> model); }### Answer:
@Test public void active() { final ActiveRules activeRules = Mockito.mock(ActiveRules.class); sensorContext.setActiveRules(activeRules); Mockito.when(activeRules.find(RuleKey.of("package-analyzer-test-no", "test"))).thenReturn(null); Mockito.when(activeRules.find(RuleKey.of("package-analyzer-test-yes", "test"))).thenReturn(activeRule); final Model<Location> model = new Model<>(); model.addPackage("packageA", location("packageA/package-info.java")); subject.scanModel(sensorContext, "test-no", model); Assert.assertEquals(0, sensorContext.allIssues().size()); subject.scanModel(sensorContext, "test-yes", model); Assert.assertEquals(1, sensorContext.allIssues().size()); }
@Test public void noLocation() { final Model<Location> model = new Model<>(); model.addPackage("packageA", null); model.addPackage("packageB", location("packageB/package-info.java")); subject.scanModel(sensorContext, activeRule, model); Assert.assertEquals(1, sensorContext.allIssues().size()); } |
### Question:
PackageAnalyzerPlugin implements Plugin { @Override public void define(final Context context) { LOGGER.debug("Defining plugin ..."); context.addExtensions(AbstractnessRule.class, AfferentCouplingRule.class, EfferentCouplingRule.class, InstabilityRule.class, MissingPackageInfoRule.class, NumberOfClassesAndInterfacesRule.class, PackageDependencyCyclesRule.class); context.addExtensions(PackageAnalyzerMetrics.class, PackageAnalyzerComputer.class); context.addExtensions(PackageAnalyzerProperties.definitions()); context.addExtensions(JavaRules.class, JavaSensor.class); LOGGER.debug("Plugin defined"); } @Override void define(final Context context); static final String KEY; }### Answer:
@Test public void test() { final PackageAnalyzerPlugin subject = new PackageAnalyzerPlugin(); final Plugin.Context context = new Plugin.Context(SonarRuntimeImpl.forSonarQube(Version.create(5, 6), SonarQubeSide.SERVER)); Assert.assertEquals(0, context.getExtensions().size()); subject.define(context); Assert.assertTrue(context.getExtensions().contains(AbstractnessRule.class)); Assert.assertTrue(context.getExtensions().contains(AfferentCouplingRule.class)); Assert.assertTrue(context.getExtensions().contains(EfferentCouplingRule.class)); Assert.assertTrue(context.getExtensions().contains(InstabilityRule.class)); Assert.assertTrue(context.getExtensions().contains(MissingPackageInfoRule.class)); Assert.assertTrue(context.getExtensions().contains(NumberOfClassesAndInterfacesRule.class)); Assert.assertTrue(context.getExtensions().contains(PackageDependencyCyclesRule.class)); Assert.assertTrue(context.getExtensions().contains(JavaRules.class)); Assert.assertTrue(context.getExtensions().contains(JavaSensor.class)); } |
### Question:
AbstractSensor implements Sensor { @Override public final void describe(final SensorDescriptor descriptor) { descriptor.name("Package Analyzer Sensor (" + language + ")"); descriptor.onlyOnLanguage(language); descriptor.createIssuesForRuleRepository(BaseRules.getRepositoryKey(language)); } AbstractSensor(final String language, final PackageAnalyzerRule... rules); @Override final void describe(final SensorDescriptor descriptor); @Override final void execute(final SensorContext context); }### Answer:
@Test public void describe() { DefaultSensorDescriptor descriptor = new DefaultSensorDescriptor(); sensor.describe(descriptor); Assert.assertEquals("Package Analyzer Sensor (TEST)", descriptor.name()); Assert.assertEquals(Arrays.asList("TEST"), descriptor.languages()); } |
### Question:
Tarjan { public synchronized List<List<T>> getStronglyConnectedComponents() { if (stronglyConnectedComponents == null) { calculate(); } return stronglyConnectedComponents; } Tarjan(final Map<T, Set<T>> edges); synchronized List<List<T>> getStronglyConnectedComponents(); }### Answer:
@Test public void testWikipediaExample() { final Map<String, Set<String>> input = new HashMap<>(); input.put("Node 1", new HashSet<>(Arrays.asList("Node 2"))); input.put("Node 2", new HashSet<>(Arrays.asList("Node 3"))); input.put("Node 3", new HashSet<>(Arrays.asList("Node 1"))); input.put("Node 4", new HashSet<>(Arrays.asList("Node 3", "Node 5"))); input.put("Node 5", new HashSet<>(Arrays.asList("Node 4", "Node 6"))); input.put("Node 6", new HashSet<>(Arrays.asList("Node 3", "Node 7"))); input.put("Node 7", new HashSet<>(Arrays.asList("Node 6"))); input.put("Node 8", new HashSet<>(Arrays.asList("Node 5", "Node 7", "Node 8"))); final List<List<String>> components = new Tarjan<>(input).getStronglyConnectedComponents(); printResult(components); }
@Test public void test() { final Map<String, Set<String>> input = new HashMap<>(); input.put("Node 1", new HashSet<>(Arrays.asList("Node 2"))); input.put("Node 2", new HashSet<>(Arrays.asList("Node 3", "Node 4"))); input.put("Node 3", new HashSet<>(Arrays.asList("Node 4"))); input.put("Node 4", new HashSet<>(Arrays.asList("Node 1"))); input.put("Node 5", Collections.emptySet()); Tarjan<String> tarjan = new Tarjan<>(input); tarjan.getStronglyConnectedComponents(); final List<List<String>> components = tarjan.getStronglyConnectedComponents(); printResult(components); } |
### Question:
AbstractSensor implements Sensor { @Override public final void execute(final SensorContext context) { LOGGER.info("Build package model ..."); final Model<Location> model = buildModel(context); LOGGER.info("Package model built, analyzing model for issues ..."); for (final PackageAnalyzerRule rule : rules) { if (rule.supportsLanguage(language)) { LOGGER.debug("Executing rule: {}", rule); rule.scanModel(context, language, model); } } LOGGER.info("Analysis done"); } AbstractSensor(final String language, final PackageAnalyzerRule... rules); @Override final void describe(final SensorDescriptor descriptor); @Override final void execute(final SensorContext context); }### Answer:
@Test public void execute() { Assert.assertFalse(sensor.called); Assert.assertFalse(rule1.called); Assert.assertFalse(rule2.called); sensor.execute(null); Assert.assertTrue(sensor.called); Assert.assertTrue(rule1.called); Assert.assertTrue(rule2.called); } |
### Question:
PackageAnalyzerMetrics implements Metrics { @Override @SuppressWarnings("rawtypes") public List<Metric> getMetrics() { return asList(PACKAGE_DEPENDENCY_CYCLES, PACKAGE_DEPENDENCY_CYCLES_IDENTIFIER, PACKAGE_DEPENDENCY_CYCLES_IDENTIFIERS); } @Override @SuppressWarnings("rawtypes") List<Metric> getMetrics(); static final Metric<Integer> PACKAGE_DEPENDENCY_CYCLES; static final Metric<String> PACKAGE_DEPENDENCY_CYCLES_IDENTIFIER; static final Metric<String> PACKAGE_DEPENDENCY_CYCLES_IDENTIFIERS; }### Answer:
@Test public void test() { Assert.assertEquals(3, new PackageAnalyzerMetrics().getMetrics().size()); } |
### Question:
PackageAnalyzerComputer implements MeasureComputer { @Override public MeasureComputerDefinition define(final MeasureComputerDefinitionContext definitionContext) { return definitionContext.newDefinitionBuilder() .setInputMetrics(PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES_IDENTIFIER.key(), PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES_IDENTIFIERS.key(), PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES.key()) .setOutputMetrics(PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES_IDENTIFIERS.key(), PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES.key()) .build(); } @Override MeasureComputerDefinition define(final MeasureComputerDefinitionContext definitionContext); @Override void compute(final MeasureComputerContext context); }### Answer:
@Test public void testDefinition() { final TestMeasureComputerDefinitionContext definitionContext = new TestMeasureComputerDefinitionContext(); final MeasureComputerDefinition definition = subject.define(definitionContext); Assert.assertNotNull(definition); Assert.assertEquals(3, definition.getInputMetrics().size()); Assert.assertTrue(definition.getInputMetrics().contains(PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES_IDENTIFIER.key())); Assert.assertTrue(definition.getOutputMetrics().contains(PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES_IDENTIFIERS.key())); Assert.assertTrue(definition.getInputMetrics().contains(PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES.key())); Assert.assertEquals(2, definition.getOutputMetrics().size()); Assert.assertTrue(definition.getOutputMetrics().contains(PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES_IDENTIFIERS.key())); Assert.assertTrue(definition.getOutputMetrics().contains(PackageAnalyzerMetrics.PACKAGE_DEPENDENCY_CYCLES.key())); } |
### Question:
DAStringUtil { public static String normalizeWhiteSpaceFromString(String content) { if (content == null) { return null; } final Matcher matcher = pattern.matcher(content); final String s = matcher.replaceAll(" ").trim(); if (s.isEmpty()) { return null; } return s; } static String normalizeWhiteSpaceFromString(String content); static String normalizeWhiteSpaceFromStringOld(String content); static final Predicate<String> STRING_IS_BLANK; }### Answer:
@Test public void testNormalizeWhiteSpaceFromString() throws Exception { assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(null)); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(" \r\n ")); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(" \r ")); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString("")); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(" ")); assertEquals(null, DAStringUtil.normalizeWhiteSpaceFromString(" \n ")); assertEquals("a a", DAStringUtil.normalizeWhiteSpaceFromString(" a \n \n a ")); assertEquals("a a", DAStringUtil.normalizeWhiteSpaceFromString(" \t a \n \n \t a \t ")); } |
### Question:
SimpleDataSchema implements CatoDataSchema { @Override public Map<String, String> getMappedFields() { return this.mappedFields; } SimpleDataSchema(); SimpleDataSchema(Map<String, String> mappedFields); @Override Set<String> getFields(); @Override SimpleDataObject createDataObject(); @Override Map<String, String> getMappedFields(); }### Answer:
@Test public void testConstructor() { Assert.assertEquals(0, this.schema.getMappedFields().size()); Map<String, String> mappedFields = new HashMap<String, String>(); mappedFields.put("Test1", "Test1 Ref"); mappedFields.put("Test2", "Test2 Ref"); this.schema = new SimpleDataSchema(mappedFields); Assert.assertEquals(2, this.schema.getMappedFields().size()); } |
### Question:
SimpleDataSchema implements CatoDataSchema { @Override public SimpleDataObject createDataObject() { return new SimpleDataObject(this); } SimpleDataSchema(); SimpleDataSchema(Map<String, String> mappedFields); @Override Set<String> getFields(); @Override SimpleDataObject createDataObject(); @Override Map<String, String> getMappedFields(); }### Answer:
@Test public void testCreateDataObject() { SimpleDataObject obj = this.schema.createDataObject(); Assert.assertNotNull(obj); Assert.assertSame(this.schema, obj.getSchema()); } |
### Question:
SimpleDataObject implements CatoDataObject { @Override public CatoDataSchema getSchema() { return this.schema; } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); }### Answer:
@Test public void getSchemaTest() { Assert.assertSame(schema, obj.getSchema()); Assert.assertSame(schema, obj2.getSchema()); } |
### Question:
SimpleDataObject implements CatoDataObject { @Override public void setValue(String field, Object value) { int index = this.schema.getOrCreateFieldIndex(field); if (this.data.length <= index) { this.data = this.copy(this.data, index + 1); } this.data[index] = value; } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); }### Answer:
@Test public void setValueTest() { Assert.assertEquals(7, obj.getFields().size()); Assert.assertEquals(7, obj2.getFields().size()); Assert.assertNull(obj.getValue("x")); Assert.assertNull(obj.getValue("axax")); Assert.assertNull(obj2.getValue("a")); Assert.assertNull(obj2.getValue("b")); Assert.assertNull(obj2.getValue("e")); } |
### Question:
SimpleDataObject implements CatoDataObject { @Override public Set<String> getFields() { return this.schema.getFields(); } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); }### Answer:
@Test public void containsFieldTest() { Assert.assertTrue(obj.getFields().contains("a")); Assert.assertTrue(obj.getFields().contains("d")); Assert.assertFalse(obj.getFields().contains("f")); } |
### Question:
SimpleDataObject implements CatoDataObject { @Override public Object getValue(String field) { Integer index = this.schema.getFieldIndex(field); if (index == null || this.data.length <= index) { return null; } return this.data[index]; } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); }### Answer:
@Test public void getValueTest() { Assert.assertEquals(123, obj.getValue("a")); Assert.assertEquals(true, obj.getValue("b")); Assert.assertEquals("test string", obj.getValue("c")); Assert.assertNull(obj.getValue("d")); Assert.assertEquals(Arrays.asList(1, 2, 3), obj.getValue("e")); Assert.assertNull(obj.getValue("f")); } |
### Question:
SimpleDataObject implements CatoDataObject { @Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append(this.getClass().getSimpleName()).append(" {"); if (this.getFields().isEmpty()) { return builder.append("}").toString(); } for (String field : this.getFields()) { builder.append(field).append("=").append(this.getValue(field)).append(this.getClass(field)).append(", "); } return builder.substring(0, builder.length() - 2) + "}"; } SimpleDataObject(SimpleDataSchema schema); @Override Object getValue(String field); @Override void setValue(String field, Object value); @Override Set<String> getFields(); @Override CatoDataSchema getSchema(); @Override String toString(); }### Answer:
@Test public void toStringTest() { try { Assert.assertEquals( "SimpleDataObject {}", TestUtil.createDataObjectWithKeys().toString()); Assert.assertEquals( "SimpleDataObject {Key 1=A [String], Key 2=4 [Integer], Val 1=1.4 [Double], Val 2=str [String], Val 3=[1, 2, 3] [ArrayList]}", TestUtil.createDataObject("A", 4, 1.4, "str", Arrays.asList(1, 2, 3)).toString()); Assert.assertEquals( "SimpleDataObject {Key 1=A [String], Key 2=null, Val 1=1.4 [Double], Val 2=null, Val 3=[1, null, 3] [ArrayList]}", TestUtil.createDataObject("A", null, 1.4, null, Arrays.asList(1, null, 3)).toString()); Assert.assertEquals( "SimpleDataObject {Key 1=null, Key 2=null, Val 1=null, Val 2=null, Val 3=[null, null, 3] [ArrayList]}", TestUtil.createDataObject(null, null, null, null, Arrays.asList(null, null, 3)).toString()); } catch (Exception ex) { Assert.fail(); } } |
### Question:
CatoFieldSelector implements Function<CatoDataObject, Object> { @Override public Object valueOf(CatoDataObject obj) { return obj.getValue(this.field); } CatoFieldSelector(String field); @Override Object valueOf(CatoDataObject obj); }### Answer:
@Test public void testSelector() { CatoDataObject obj = TestUtil.createDataObjectWithKeys("Val1", 123, "Val2", 555.5, "Val 3", "abc"); Assert.assertEquals(123, new CatoFieldSelector("Val1").valueOf(obj)); org.junit.Assert.assertEquals(555.5, new CatoFieldSelector("Val2").valueOf(obj)); org.junit.Assert.assertEquals("abc", new CatoFieldSelector("Val 3").valueOf(obj)); assertNull(new CatoFieldSelector("Not a val").valueOf(obj)); assertNull(new CatoFieldSelector(null).valueOf(obj)); } |
### Question:
MemoryMonitor extends Thread { private MemoryMonitor() { this(2000, true); } private MemoryMonitor(); MemoryMonitor(long pollFrequency, boolean logMemoryUsage); void run(); double getCurrentMemory(); double getMaxMemory(); void terminate(); }### Answer:
@Test public void testMemoryMonitor() { MemoryMonitor monitor = new MemoryMonitor(10, true); Assert.assertEquals(0.0, monitor.getCurrentMemory(), 0.01); Assert.assertEquals(0.0, monitor.getMaxMemory(), 0.01); Assert.assertTrue(monitor.isDaemon()); monitor.start(); this.sleep(100); Assert.assertTrue(monitor.isAlive()); Assert.assertTrue(monitor.getCurrentMemory() > 0); Assert.assertTrue(monitor.getMaxMemory() > 0); monitor.terminate(); this.sleep(50); Assert.assertFalse(monitor.isAlive()); org.junit.Assert.assertTrue(monitor.getCurrentMemory() > 0); org.junit.Assert.assertTrue(monitor.getMaxMemory() > 0); } |
### Question:
CatoResources { public CatoResources(InputStream is) throws CatoResourcesException { this.initialize(is); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); }### Answer:
@Test public void testCatoResources() { try { new CatoResources(this.getClass().getClassLoader() .getResourceAsStream("TestResources.xml")); LOG.info("Cato resources created."); } catch (CatoResourcesException e) { LOG.error("Unable to read the resources - {}", e.getMessage()); fail("Unable to read the resources - " + e.getMessage()); } } |
### Question:
CatoResources { public DataSourceConfig getDataSource(String name) { for (DataSourceConfig dsc : this.dataSources.values()) { if (dsc.getName().equals(name)) { return dsc; } } return null; } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); }### Answer:
@Test public void testGetDataSource() { DataSourceConfig dsc = this.catoResources.getDataSource("ds0"); if (dsc == null) { fail("Could not find data source ds0."); } } |
### Question:
CatoResources { public ReconConfig getRecon(String name) { for (ReconConfig rc : this.recons.values()) { if (rc.getReconName().equals(name)) { return rc; } } return null; } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); }### Answer:
@Test public void testGetRecon() { ReconConfig rc = this.catoResources.getRecon("recon0"); if (rc == null) { fail("Could not find recon recon0"); } } |
### Question:
CatoResources { public void addDataSource(DataSourceConfig ds) { this.dataSources.put(ds.getName(), ds); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); }### Answer:
@Test public void testAddDataSource() { DatabaseConfig dbconfig = new DatabaseConfig("ds2", "user2", "password2", "url2", "query2"); this.catoResources.addDataSource(dbconfig); if (this.catoResources.getDataSource("ds2") == null) { fail("Could not add data source ds2."); } } |
### Question:
CatoResources { public DataSourceConfig removeDataSource(DataSourceConfig ds) { return this.dataSources.remove(ds.getName()); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); }### Answer:
@Test public void testRemoveDataSource() { DataSourceConfig dsc = this.catoResources.getDataSource("ds0"); this.catoResources.removeDataSource(dsc); dsc = this.catoResources.getDataSource("ds0"); if (dsc != null) { fail("Could not remove data source ds2."); } } |
### Question:
CatoResources { public void addRecon(ReconConfig r) { this.recons.put(r.getReconName(), r); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); }### Answer:
@Test public void testAddRecon() { ReconConfig rc = new ReconConfig(); rc.setReconName("recon1"); this.catoResources.addRecon(rc); rc = this.catoResources.getRecon("recon1"); if (rc == null) { fail("Unable to add recon recon1."); } } |
### Question:
CatoResources { public ReconConfig removeRecon(ReconConfig r) { return this.recons.remove(r.getReconName()); } CatoResources(InputStream is); private CatoResources(String resfile); private CatoResources(File resFile); DataSourceConfig getDataSource(String name); ReconConfig getRecon(String name); void addDataSource(DataSourceConfig ds); DataSourceConfig removeDataSource(DataSourceConfig ds); void addRecon(ReconConfig r); ReconConfig removeRecon(ReconConfig r); Collection<DataSourceConfig> getDataSources(); Collection<ReconConfig> getRecons(); void saveResources(); }### Answer:
@Test public void testRemoveRecon() { ReconConfig rc = this.catoResources.getRecon("recon0"); this.catoResources.removeRecon(rc); rc = this.catoResources.getRecon("recon0"); if (rc != null) { fail("Unable to remove recon - recon0"); } } |
### Question:
QueryDataSource extends AbstractCatoDataSource { public QueryDataSource(String name, String url, String user, String password, String query) throws SQLException { this(name, DriverManager.getConnection(url, user, password), query); } QueryDataSource(String name, String url, String user, String password, String query); QueryDataSource(String name, Connection connection, String query); QueryDataSource(String name, Connection connection, QueryExecutor queryExecutor); Connection getConnection(); }### Answer:
@Test public void queryDataSourceTest() throws Exception { QueryDataSource dataSource = new QueryDataSource("test", DB_URL, "test", "", "select * from Test"); Assert.assertFalse(dataSource.getConnection().isClosed()); List<CatoDataObject> data = TestUtil.getData(dataSource); Assert.assertTrue(dataSource.getConnection().isClosed()); Assert.assertEquals(4, data.size()); CatoDataObject obj = data.get(0); Assert.assertEquals(5, obj.getFields().size()); Assert.assertEquals(1, obj.getValue("KEY")); Assert.assertEquals("abc", obj.getValue("STR_VAL")); Assert.assertEquals("def", obj.getValue("STR_VAL2")); Assert.assertEquals(5.25, ((BigDecimal) obj.getValue("DOUBLE_VAL")).doubleValue(), 0.00001); Assert.assertEquals(new SimpleDateFormat("yyyy-MM-dd").parse("2010-05-12"), obj.getValue("DATE_VAL")); Assert.assertEquals(4, TestUtil.getData( new QueryDataSource("test", DB_URL, "test", "", "select * from Test")).size()); } |
### Question:
DelimitedStreamDataSource extends AbstractStreamDataSource { public String getDelimiter() { return this.delimiter; } DelimitedStreamDataSource(String name, Reader reader, String delimiter); DelimitedStreamDataSource(String name, Reader reader, List<String> fields, String delimiter); String getDelimiter(); }### Answer:
@Test public void testDelim() { TestUtil.clearLogged(); DelimitedStreamDataSource dataSource = new DelimitedStreamDataSource("Test", new StringReader(TEST_FILE), "|"); Assert.assertEquals("|", dataSource.getDelimiter()); }
@Test public void testFetchData() { try { DelimitedStreamDataSource dataSource = new DelimitedStreamDataSource( "Test", new StringReader(TEST_FILE), ","); dataSource.setTypeConverter(null); Assert.assertEquals(",", dataSource.getDelimiter()); List<CatoDataObject> data = TestUtil.getData(dataSource); Assert.assertEquals(3, data.size()); CatoDataObject obj1 = data.get(0); CatoDataObject obj2 = data.get(1); CatoDataObject obj3 = data.get(2); Assert.assertEquals("123", obj1.getValue("Num")); Assert.assertEquals("456", obj2.getValue("Num")); Assert.assertEquals("2", obj3.getValue("Num")); Assert.assertEquals("Test", obj1.getValue("String")); Assert.assertEquals("Test2", obj2.getValue("String")); Assert.assertEquals("Test3 ", obj3.getValue("String")); Assert.assertEquals("Hello", obj1.getValue("Other")); Assert.assertEquals("This is a long string", obj2.getValue("Other")); Assert.assertEquals("Other Test", obj3.getValue("Other")); } catch (Exception ex) { ex.printStackTrace(); Assert.fail(); } } |
### Question:
AliasField extends AbstractDerivedField<Object> { protected Object getValue(Object sourceValue) { return sourceValue; } AliasField(String sourceField, String targetField); }### Answer:
@Test public void testGetValue() throws Exception { Assert.assertEquals("New Field", this.field.getName()); Assert.assertEquals("abc", this.field.getValue("abc")); org.junit.Assert.assertEquals(123, this.field.getValue(123)); org.junit.Assert.assertEquals(new Integer(100), new Integer(100)); } |
### Question:
UpperCaseField extends AbstractDerivedField<String> { protected Object getValue(String sourceValue) { return sourceValue.toUpperCase(); } UpperCaseField(String field); UpperCaseField(String sourceField, String targetField); }### Answer:
@Test public void testGetValue() throws Exception { Assert.assertEquals("ABC", this.field.getValue("abc")); org.junit.Assert.assertEquals("ABC", this.field.getValue("aBc")); org.junit.Assert.assertEquals("ABC123!@#$%^&*()-+`EFG=", this.field.getValue("Abc123!@#$%^&*()-+`efG=")); } |
### Question:
DoubleField extends AbstractDerivedField<String> { public DoubleField(String field) { this(field, true); } DoubleField(String field); DoubleField(String field, boolean allowBlanks); DoubleField(String sourceField, String targetField); DoubleField(String sourceField, String targetField, boolean allowBlanks); }### Answer:
@Test public void doubleFieldTest() { DoubleField field1 = new DoubleField("Field", true); Assert.assertEquals("Field", field1.getName()); assertNull(field1.getValue("")); assertNull(field1.getValue(" ")); Assert.assertEquals(5.0, field1.getValue("5")); Assert.assertEquals(3.14, field1.getValue("3.14")); Assert.assertEquals(500.0, field1.getValue("5E2")); try { field1.getValue("abc"); Assert.fail(); } catch (Exception ex) { } DoubleField field2 = new DoubleField("Field", false); try { field2.getValue(" "); org.junit.Assert.fail(); } catch (Exception ex) { } } |
### Question:
DelimitedField extends AbstractDerivedField<String> { protected Object getValue(String sourceValue) { StringTokenizer tokenizer = new StringTokenizer(sourceValue, this.delim); List<String> tokens = new ArrayList<String>(); while (tokenizer.hasMoreTokens()) { tokens.add(tokenizer.nextToken().trim()); } Collections.sort(tokens); StringBuilder value = new StringBuilder(); for (String token : tokens) { value.append(token).append(this.delim); } return tokens.size() > 0 ? value.substring(0, value.length() - this.delim.length()) : value.toString(); } DelimitedField(String field, String delim); private DelimitedField(String sourceField, String targetField, String delim); }### Answer:
@Test public void testGetValue() throws Exception { Assert.assertEquals("a,b,cde", this.field1.getValue("cde,b,a")); org.junit.Assert.assertEquals("a,b,c", this.field1.getValue(" c , b , a ")); org.junit.Assert.assertEquals("abc", this.field1.getValue("abc")); org.junit.Assert.assertEquals("", this.field1.getValue("")); org.junit.Assert.assertEquals("a|b|c", this.field2.getValue("c|b|a")); org.junit.Assert.assertEquals("a|b|c", this.field2.getValue(" c | b | a ")); org.junit.Assert.assertEquals("a", this.field2.getValue("a")); } |
### Question:
DateField extends AbstractDerivedField<String> { protected Object getValue(String sourceValue) { try { return this.dateFormat.parse(sourceValue); } catch (ParseException ex) { LOG.error("Failed to parse date '{}'", sourceValue); return sourceValue; } } DateField(String field, String format); DateField(String sourceField, String targetField, String format); }### Answer:
@Test public void testGetValue() throws Exception { Assert.assertEquals("not a date", this.field.getValue("not a date")); org.junit.Assert.assertEquals(Date.class, this.field.getValue("05-12-2010").getClass()); org.junit.Assert.assertEquals(new SimpleDateFormat("MM-dd-yyyy").parse("05-12-2010"), this.field.getValue("05-12-2010")); } |
### Question:
AbstractDerivedField implements CatoDerivedField { AbstractDerivedField(String field, Class<T> clazz) { this(field, field, clazz); } AbstractDerivedField(String field, Class<T> clazz); AbstractDerivedField(String sourceField, String targetField, Class<T> clazz); final String getName(); final Object getValue(CatoDataObject obj); }### Answer:
@Test public void testAbstractDerivedField() { Assert.assertEquals("New Test", field1.getName()); CatoDataObject obj1 = TestUtil.createDataObject("A", "B", 1, 2, 3); Assert.assertEquals("A decorated", field1.getValue(obj1)); CatoDataObject obj2 = TestUtil.createDataObject(null, "B", 1, 2, 3); assertNull(field1.getValue(obj2)); CatoDataObject obj3 = TestUtil.createDataObject("A", "B", 1, 2, 3); org.junit.Assert.assertEquals(1, field2.getValue(obj3)); CatoDataObject obj4 = TestUtil.createDataObject("A", "B", new Date(), 2, 3); org.junit.Assert.assertEquals(String.class, field2.getValue(obj4).getClass()); CatoDataObject obj5 = TestUtil.createDataObject("A", "B", new Timestamp(1000), 2, 3); org.junit.Assert.assertEquals(String.class, field2.getValue(obj5).getClass()); CatoDataObject obj6 = TestUtil.createDataObject("A", "B", true, 2, 3); org.junit.Assert.assertEquals(true, field2.getValue(obj6)); CatoDataObject obj7 = TestUtil.createDataObject("A", "B", new Object(), 2, 3); org.junit.Assert.assertEquals(Object.class, field2.getValue(obj7).getClass()); } |
### Question:
AbstractCatoDataSource implements CatoDataSource { public final CatoDataObject next() { if (!this.open || this.closed) { throw new UnsupportedOperationException( "Cannot iterate over a DataSource before calling open() or after calling close()"); } try { CatoDataObject current = this.nextObj; if (this.typeConverter != null) { for (String field : current.getFields()) { current.setValue(field, this.typeConverter.convert(current.getValue(field))); } } for (CatoDerivedField field : this.derivedFields) { current.setValue(field.getName(), field.getValue(current)); } this.nextObj = this.nextDataObject(); this.count++; return current; } catch (Exception ex) { throw new RuntimeException("Failed to get next DataObject at row # " + this.count + " in the source", ex); } } protected AbstractCatoDataSource(String name, CatoTypeConverter typeConverter); AbstractCatoDataSource(String name, String shortName, CatoTypeConverter typeConverter); @Deprecated protected AbstractCatoDataSource(String name); final CatoDataObject next(); final boolean hasNext(); void remove(); @Override final void open(); final void close(); @Override String getName(); @Override String getShortName(); void setName(String name); @Override void addDerivedField(CatoDerivedField derivedField); @Override boolean isSorted(); @Override void setSorted(boolean sorted); @Override void setTypeConverter(CatoTypeConverter typeConverter); void setDataSchema(CatoDataSchema dataSchema); @Override void setCatoConfiguration(CatoConfiguration configuration); }### Answer:
@Test public void testNextBeforeOpen() { try { this.source.next(); Assert.fail(); } catch (Exception ex) { TestUtil.assertException("Cannot iterate over a DataSource", UnsupportedOperationException.class, ex); } } |
### Question:
AbstractCatoDataSource implements CatoDataSource { public final void close() { try { if (!this.open) { throw new UnsupportedOperationException("DataSource is not open"); } if (this.closed) { throw new UnsupportedOperationException("DataSource is already closed"); } LOG.info("Closing DataSource {}", this.name); this.closeSource(); this.closed = true; this.open = false; } catch (Exception ex) { throw new RuntimeException("Could not close DataSource '" + this.name + "'", ex); } } protected AbstractCatoDataSource(String name, CatoTypeConverter typeConverter); AbstractCatoDataSource(String name, String shortName, CatoTypeConverter typeConverter); @Deprecated protected AbstractCatoDataSource(String name); final CatoDataObject next(); final boolean hasNext(); void remove(); @Override final void open(); final void close(); @Override String getName(); @Override String getShortName(); void setName(String name); @Override void addDerivedField(CatoDerivedField derivedField); @Override boolean isSorted(); @Override void setSorted(boolean sorted); @Override void setTypeConverter(CatoTypeConverter typeConverter); void setDataSchema(CatoDataSchema dataSchema); @Override void setCatoConfiguration(CatoConfiguration configuration); }### Answer:
@Test public void testCloseBeforeOpen() { try { this.source.close(); org.junit.Assert.fail(); } catch (Exception ex) { TestUtil.assertException("is not open", UnsupportedOperationException.class, ex.getCause()); } } |
### Question:
AbstractCatoDataSource implements CatoDataSource { @Override public final void open() { try { if (this.open) { throw new UnsupportedOperationException("DataSource is already open"); } if (this.closed) { throw new UnsupportedOperationException("DataSource is already closed"); } LOG.info("Opening DataSource {}", this.name); this.openSource(); this.open = true; this.nextObj = this.nextDataObject(); } catch (Exception ex) { throw new RuntimeException("Could not open DataSource '" + this.name + "'", ex); } } protected AbstractCatoDataSource(String name, CatoTypeConverter typeConverter); AbstractCatoDataSource(String name, String shortName, CatoTypeConverter typeConverter); @Deprecated protected AbstractCatoDataSource(String name); final CatoDataObject next(); final boolean hasNext(); void remove(); @Override final void open(); final void close(); @Override String getName(); @Override String getShortName(); void setName(String name); @Override void addDerivedField(CatoDerivedField derivedField); @Override boolean isSorted(); @Override void setSorted(boolean sorted); @Override void setTypeConverter(CatoTypeConverter typeConverter); void setDataSchema(CatoDataSchema dataSchema); @Override void setCatoConfiguration(CatoConfiguration configuration); }### Answer:
@Test public void testOpenAfterOpen() { this.source.open(); try { this.source.open(); org.junit.Assert.fail(); } catch (Exception ex) { TestUtil.assertException("is already open", UnsupportedOperationException.class, ex.getCause()); } } |
### Question:
CatoTypeConverters { public static CatoTypeConverter newCustomTypeConverter(final Function<Object, Object> customConvertor) { return new CatoTypeConverter() { @Override public Object convert(Object data) { return customConvertor.valueOf(data); } }; } static CatoTypeConverter newStringType(); static CatoTypeConverter newStringType(String... dateFormats); static CatoTypeConverter newStringType(int precision, String... dateFormats); static CatoTypeConverter newPreciseDoubleStringType(int precision, String... dateFormats); static CatoTypeConverter newCustomTypeConverter(final Function<Object, Object> customConvertor); }### Answer:
@Test public void testCustomConversion() { Function converter = new Function() { @Override public Object valueOf(Object arg0) { return (String) arg0 + "-custom"; } }; org.junit.Assert.assertEquals("string-custom", CatoTypeConverters.newCustomTypeConverter(converter).convert("string")); } |
### Question:
StringTypeConverter extends SimpleTypeConverter { public Object convert(Object value) { if (value == null) { return value; } if (!(value instanceof String)) { return value; } Object str = this.handleString(value); return str; } StringTypeConverter(int precision, String... dateFormats); StringTypeConverter(String... dateFormats); Object convert(Object value); void sethPrecision(int precision); }### Answer:
@Test public void trivialConvertTest() { assertNull(this.converter.convert(null)); this.assertConvert(Boolean.class, true, true); Object obj = new Object(); this.assertConvert(Object.class, obj, obj); this.assertConvert(String.class, "abc", "abc"); this.assertConvert(String.class, "true2", "true2"); assertNull(this.converter.convert("")); assertNull(this.converter.convert(" ")); assertNull(this.converter.convert(" ")); } |
### Question:
TextComparisonWriter extends AbstractComparisonWriter { @Override public void close() throws IOException { this.contentWriter.closeWriter(); } TextComparisonWriter(String fileName); TextComparisonWriter(File file); private TextComparisonWriter(File file, boolean writeBreaks); @Override void close(); }### Answer:
@Test public void testWriter() throws Exception { CatoDataSource dataSource1 = CatoBaseUtil.createDelimitedStreamDataSource("test1", new FileReader("src/test/resources/testdata1.txt"), TestUtil.ALL_FIELDS, ","); CatoDataSource dataSource2 = CatoBaseUtil.createDelimitedStreamDataSource("test2", new FileReader("src/test/resources/testdata2.txt"), TestUtil.ALL_FIELDS, ","); CatoComparison comparison = CatoBaseUtil.compare("Test Comp", dataSource1, dataSource2, TestUtil.KEY_FIELDS, TestUtil.EXCLUDE_FIELDS); TextComparisonWriter writer = new TextComparisonWriter("target/comparisons/text-test.txt"); writer.writeComparison(comparison); writer.close(); Assert.assertTrue(new File("target/comparisons/text-test.txt").canRead()); } |
### Question:
HTMLComparisonWriter extends AbstractMultiComparisonWriter { public void close() throws IOException { if (this.contentFileName != null) { Writer cwriter = new OutputStreamWriter( IoUtil.getOutputStream(new File(this.contentFileName))); cwriter.write(this.contentWriter.getHtmlString().toString()); cwriter.close(); } if (this.summaryContentFileName != null) { Writer swriter = new OutputStreamWriter( IoUtil.getOutputStream(this.summaryContentFileName)); swriter.write(this.summaryContentWriter.getHtmlString().toString()); swriter.close(); } } HTMLComparisonWriter(String contentfile, String summaryContentFile); private HTMLComparisonWriter(String contentfile, String summaryContentFile,
boolean writeSummary, boolean writeLegend, boolean writeBreaks,
boolean writeDataSets); HTMLComparisonWriter(); private HTMLComparisonWriter(boolean writeSummary, boolean writeLegend,
boolean writeBreaks, boolean writeDataSets); void close(); String getContent(); String getSummaryContent(); }### Answer:
@Test public void testWriter() throws Exception { CatoDataSource dataSource1 = CatoBaseUtil.createDelimitedStreamDataSource( "test1", new FileReader("src/test/resources/testdata1.txt"), TestUtil.ALL_FIELDS, ","); CatoDataSource dataSource2 = CatoBaseUtil.createDelimitedStreamDataSource( "test2", new FileReader("src/test/resources/testdata2.txt"), TestUtil.ALL_FIELDS, ","); CatoComparison comparison = CatoBaseUtil.compare("HTML Comp", dataSource1, dataSource2, TestUtil.KEY_FIELDS, TestUtil.EXCLUDE_FIELDS); HTMLComparisonWriter writer = new HTMLComparisonWriter( "target/comparisons/html-test-content.html", "target/comparisons/html-test-summary.html"); writer.writeComparison(comparison); writer.close(); Assert.assertTrue(new File("target/comparisons/html-test-content.html") .canRead()); org.junit.Assert.assertTrue(new File("target/comparisons/html-test-summary.html") .canRead()); } |
### Question:
TableSyncher { private void syncSchemaTables(DbPlatform dbPlatform, RichIterable<TableSyncSide> syncSides, File outputDir) { for (TableSyncSide syncSide : syncSides) { syncSide.enrichTables(dbPlatform); } RichIterable<DaTable> idealTables = this.createIdealTables(syncSides); MapIterable<String, DaTable> idealTablesMap = idealTables.groupByUniqueKey(DaNamedObject.TO_NAME); System.out.println("Starting the alters"); for (TableSyncSide syncSide : syncSides) { for (DaTable table : syncSide.getTables()) { File outputFile = new File(new File(outputDir, syncSide.getSchema().getPhysicalName()), table.getName() + ".sql"); this.generateDiffsToTable(table, idealTablesMap.get(table.getName()), outputFile); } } } static void main(String[] argsArr); void execute(DbFileMergerArgs args); }### Answer:
@Test public void testSyncSchemaTables() throws Exception { TableSyncher.main(("-dbMergeConfigFile " + "src/test/resources/scenariotests/reveng-merge/merge-config-with-correction.txt " + "-outputDir ./target/merge/unittest").split(" ")); } |
### Question:
AquaRevengMain { static String extractName(String objectName, String nameCombinePattern) { if (nameCombinePattern != null) { String patternStr = nameCombinePattern.replace("{}", "(.*)"); Pattern namePattern = Pattern.compile(patternStr); Matcher nameMatcher = namePattern.matcher(objectName); if (nameMatcher.matches()) { return nameMatcher.group(1); } } return objectName; } void execute(AquaRevengArgs args); }### Answer:
@Test public void testExtractName() { assertEquals("TABLE", AquaRevengMain.extractName("TABLE", null)); assertEquals("TABLE", AquaRevengMain.extractName("TABLE", "abca")); assertEquals("TABLE", AquaRevengMain.extractName("TABLE", "abc{}a")); assertEquals("TABLE", AquaRevengMain.extractName("abcTABLEa", "abc{}a")); assertEquals("TABLE", AquaRevengMain.extractName("TABLEaaa", "{}aaa")); assertEquals("TABLE", AquaRevengMain.extractName("aaaTABLE", "aaa{}")); } |
### Question:
DateFormatterPostParsedSqlTranslator implements PostParsedSqlTranslator { @Override public String handleAnySqlPostTranslation(String string, ChangeInput change) { Matcher matcher = this.datetimeConstantPattern.matcher(string); while (matcher.find()) { String dateConstant = matcher.group(1); for (ThreadLocal<DateFormat> inputFormat : this.dateFormats) { try { Date date = inputFormat.get().parse(dateConstant); if (date == null) { continue; } string = string.replace(dateConstant, COMMON_OUTPUT_DATE_FORMAT.get().format(date)); break; } catch (ParseException e) { continue; } } } return string; } DateFormatterPostParsedSqlTranslator(ImmutableList<String> dateFormatStrings); @Override String handleAnySqlPostTranslation(String string, ChangeInput change); }### Answer:
@Test public void testDateConversion() { String translated = this.translator.handleAnySqlPostTranslation("start default '9999-12-01-23.12.01.123' end", null); assertEquals("start default '9999-12-01 23:12:01.123' end", translated); translated = this.translator.handleAnySqlPostTranslation("start default '9999-12-01-23.12.01.000000' end", null); assertEquals("start default '9999-12-01 23:12:01.000' end", translated); } |
### Question:
RemoveWithPreParsedSqlTranslator implements PreParsedSqlTranslator { @Override public String preprocessSql(String sql) { Matcher withMatcher = this.withPattern.matcher(sql); if (withMatcher.find()) { sql = withMatcher.replaceAll(""); } return sql; } @Override String preprocessSql(String sql); }### Answer:
@Test public void testPreprocessSql() throws Exception { assertEquals( "\tPRIMARY KEY (idField)\n" + "\n" + ") LOCK DATAROWS\n", this.translator.preprocessSql( "\tPRIMARY KEY (idField)\n" + "\tWITH max_rows_per_page = 0, reservepagegap = 0\n" + ") LOCK DATAROWS\n" )); assertEquals( "\tPRIMARY KEY (idField)\n" + "\tSOMETHINGBEFORE_DONTREMOVE WITH max_rows_per_page = 0, reservepagegap = 0\n" + ") LOCK DATAROWS\n" , this.translator.preprocessSql( "\tPRIMARY KEY (idField)\n" + "\tSOMETHINGBEFORE_DONTREMOVE WITH max_rows_per_page = 0, reservepagegap = 0\n" + ") LOCK DATAROWS\n" )); } |
### Question:
DbFileMerger { public static void main(String[] argsArr) { DbFileMergerArgs args = new ArgsParser().parse(argsArr, new DbFileMergerArgs()); new DbFileMerger().execute(args); } static void main(String[] argsArr); void execute(DbFileMergerArgs args); }### Answer:
@Test public void basicMergeTest() { FileUtils.deleteQuietly(new File("./target/merge/unittest")); DbFileMerger.main(("-dbMergeConfigFile src/test/resources/scenariotests/reveng-merge/merge-config.txt " + "-outputDir ./target/merge/unittest").split(" ")); DirectoryAssert.assertDirectoriesEqual( new File("./src/test/resources/scenariotests/reveng-merge/expected") , new File("./target/merge/unittest") ); }
@Test public void inputValidationTest() { thrown.expectCause(hasMessage(containsString("db1.inputDir file (use forward-slash"))); thrown.expectCause(hasMessage(containsString("db2.inputDir file"))); FileUtils.deleteQuietly(new File("./target/merge/unittest")); DbFileMerger.main(("-dbMergeConfigFile src/test/resources/scenariotests/reveng-merge/merge-config-inputerror.txt " + "-outputDir ./target/merge/unittest").split(" ")); } |
### Question:
LookupIndex implements Index { @Override public boolean accept(String each) { return values.contains(each); } LookupIndex(ImmutableSet<String> values); @Override boolean accept(String each); @Override String toString(); }### Answer:
@Test public void lookupTest() { LookupIndex lookupIndex = new LookupIndex(Sets.immutable.with("ABC", "123")); Assert.assertTrue(lookupIndex.accept("ABC")); Assert.assertTrue(lookupIndex.accept("123")); Assert.assertFalse(lookupIndex.accept("blah")); Assert.assertFalse(lookupIndex.accept("ABc")); } |
### Question:
WildcardPatternIndex implements Index { @Override public boolean accept(String each) { return pattern.matcher(each).matches(); } private WildcardPatternIndex(Pattern pattern); WildcardPatternIndex(String patternString); @Override boolean accept(String each); @Override String toString(); }### Answer:
@Test public void testBasic() { WildcardPatternIndex wildcardPatternIndex = new WildcardPatternIndex("abc%def"); Assert.assertTrue(wildcardPatternIndex.accept("abcdef")); Assert.assertTrue(wildcardPatternIndex.accept("abcFDASFDSdef")); Assert.assertFalse(wildcardPatternIndex.accept("a1bcFDASFDSdef")); } |
### Question:
RegexUtil { public static String convertWildcardPatternToRegex(String wildcardPattern) { return wildcardPattern .replace(".", "\\.") .replace("*", ".*") .replace("%", ".*") ; } static String convertWildcardPatternToRegex(String wildcardPattern); static final String WORD_REGEX; static final Pattern SPACE_PATTERN; }### Answer:
@Test public void testFilter() { Assert.assertTrue(Pattern.compile(RegexUtil.convertWildcardPatternToRegex("dev0*")).matcher("dev0A1") .matches()); Assert.assertTrue(Pattern.compile(RegexUtil.convertWildcardPatternToRegex("dev0%")).matcher("dev0A1") .matches()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.