method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
LocationEngineProxy implements LocationEngine { @VisibleForTesting T removeListener(@NonNull LocationEngineCallback<LocationEngineResult> callback) { return listeners != null ? listeners.remove(callback) : null; } LocationEngineProxy(LocationEngineImpl<T> locationEngineImpl); @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationEngineCallback<LocationEngineResult> callback,
@Nullable Looper looper); @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
PendingIntent pendingIntent); @Override void removeLocationUpdates(@NonNull LocationEngineCallback<LocationEngineResult> callback); @Override void removeLocationUpdates(PendingIntent pendingIntent); }### Answer:
@Test public void testRemoveListener() { AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport transport = new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(callback); when(engineImpl.createListener(callback)).thenReturn(transport); locationEngineProxy.getListener(callback); locationEngineProxy.removeListener(callback); assertThat(locationEngineProxy.getListenersCount()).isEqualTo(0); } |
### Question:
MapboxTelemetry implements FullQueueCallback, ServiceTaskCallback { @VisibleForTesting TelemetryClientFactory getTelemetryClientFactory(String accessToken, String userAgent) { String fullUserAgent = TelemetryUtils.createFullUserAgent(userAgent, applicationContext); return new TelemetryClientFactory(accessToken, fullUserAgent, new Logger(), certificateBlacklist); } MapboxTelemetry(Context context, String accessToken, String userAgent); MapboxTelemetry(Context context, String accessToken, String userAgent, EventsQueue queue,
TelemetryClient telemetryClient, Callback httpCallback, SchedulerFlusher schedulerFlusher,
Clock clock, TelemetryEnabler telemetryEnabler, ExecutorService executorService); @Override // Callback is dispatched on background thread void onFullQueue(List<Event> fullQueue); @Override void onTaskRemoved(); boolean push(Event event); boolean enable(); boolean disable(); boolean updateSessionIdRotationInterval(SessionInterval interval); void updateDebugLoggingEnabled(boolean isDebugLoggingEnabled); void updateUserAgent(String userAgent); boolean updateAccessToken(String accessToken); boolean addTelemetryListener(TelemetryListener listener); boolean removeTelemetryListener(TelemetryListener listener); boolean addAttachmentListener(AttachmentListener listener); boolean removeAttachmentListener(AttachmentListener listener); @SuppressWarnings("WeakerAccess") @Deprecated synchronized boolean setBaseUrl(String eventsHost); boolean isCnRegion(); synchronized void setCnRegion(boolean setCnRegion); }### Answer:
@Test public void checkTelemetryClientFactory() { String anyToken = "anyToken"; String anyUserAgent = "anyUserAgent"; Context mockedContext = mock(Context.class, RETURNS_DEEP_STUBS); TelemetryClient mockedTelemetryClient = mock(TelemetryClient.class); Callback mockedHttpCallback = mock(Callback.class); MapboxTelemetry theMapboxTelemetry = obtainMapboxTelemetryWith(mockedContext, mockedTelemetryClient, mockedHttpCallback); TelemetryClientFactory factory = theMapboxTelemetry.getTelemetryClientFactory(anyToken, anyUserAgent); assertNotNull(factory); } |
### Question:
AbstractCompositeMetrics { @Nullable public Metrics getMetrics(@NonNull String name) { Deque<Metrics> metrics = metricsMap.get(name.trim()); synchronized (this) { return metrics != null && !metrics.isEmpty() ? metrics.pop() : null; } } AbstractCompositeMetrics(long maxLength); void add(String name, long delta); @Nullable Metrics getMetrics(@NonNull String name); }### Answer:
@Test public void getEmptyMetric() { assertThat(metrics.getMetrics("test")).isNull(); }
@Test public void getMetricsEmptyString() { assertThat(metrics.getMetrics("")).isNull(); } |
### Question:
MetricsImpl implements Metrics { @Override public void add(long delta) { value.addAndGet(delta); } MetricsImpl(long start, long end, long initialValue); MetricsImpl(long start, long end); @Override void add(long delta); @Override long getValue(); @Override long getStart(); @Override long getEnd(); }### Answer:
@Test public void add() { Metrics metrics = getMetrics(); metrics.add(100L); assertThat(metrics.getValue()).isEqualTo(100L); } |
### Question:
MetricsImpl implements Metrics { @Override public long getValue() { return value.get(); } MetricsImpl(long start, long end, long initialValue); MetricsImpl(long start, long end); @Override void add(long delta); @Override long getValue(); @Override long getStart(); @Override long getEnd(); }### Answer:
@Test public void getValue() { Metrics metrics = getMetrics(); assertThat(metrics.getValue()).isEqualTo(0L); } |
### Question:
MetricsImpl implements Metrics { @Override public long getStart() { return start; } MetricsImpl(long start, long end, long initialValue); MetricsImpl(long start, long end); @Override void add(long delta); @Override long getValue(); @Override long getStart(); @Override long getEnd(); }### Answer:
@Test public void getStart() { long startTime = SystemClock.elapsedRealtime(); Metrics metrics = new MetricsImpl(startTime, startTime + TimeUnit.HOURS.toMillis(24)); assertThat(metrics.getStart()).isEqualTo(startTime); } |
### Question:
MetricsImpl implements Metrics { @Override public long getEnd() { return end; } MetricsImpl(long start, long end, long initialValue); MetricsImpl(long start, long end); @Override void add(long delta); @Override long getValue(); @Override long getStart(); @Override long getEnd(); }### Answer:
@Test public void getEnd() { long endTime = SystemClock.elapsedRealtime(); Metrics metrics = new MetricsImpl(0, endTime); assertThat(metrics.getStart()).isEqualTo(endTime); } |
### Question:
AndroidLocationEngineImpl implements LocationEngineImpl<LocationListener> { @Override public void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback) throws SecurityException { Location lastLocation = getLastLocationFor(currentProvider); if (lastLocation != null) { callback.onSuccess(LocationEngineResult.create(lastLocation)); return; } for (String provider : locationManager.getAllProviders()) { lastLocation = getLastLocationFor(provider); if (lastLocation != null) { callback.onSuccess(LocationEngineResult.create(lastLocation)); return; } } callback.onFailure(new Exception("Last location unavailable")); } AndroidLocationEngineImpl(@NonNull Context context); @NonNull @Override LocationListener createListener(LocationEngineCallback<LocationEngineResult> callback); @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationListener listener,
@Nullable Looper looper); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull PendingIntent pendingIntent); @SuppressLint("MissingPermission") @Override void removeLocationUpdates(@NonNull LocationListener listener); @Override void removeLocationUpdates(PendingIntent pendingIntent); }### Answer:
@Test public void getLastLocation() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); final AtomicReference<LocationEngineResult> resultRef = new AtomicReference<>(); LocationEngineCallback<LocationEngineResult> callback = getCallback(resultRef, latch); final Location location = getMockLocation(LATITUDE, LONGITUDE); final LocationEngineResult expectedResult = getMockEngineResult(location); when(locationManagerMock.getLastKnownLocation(anyString())).thenReturn(location); engine.getLastLocation(callback); assertTrue(latch.await(5, SECONDS)); LocationEngineResult result = resultRef.get(); assertThat(result.getLastLocation()).isEqualTo(expectedResult.getLastLocation()); }
@Test(expected = NullPointerException.class) public void getLastLocationNullCallback() { engine.getLastLocation(null); } |
### Question:
MapboxUncaughtExceptionHanlder implements Thread.UncaughtExceptionHandler,
SharedPreferences.OnSharedPreferenceChangeListener { @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { if (!MAPBOX_PREF_ENABLE_CRASH_REPORTER.equals(key)) { return; } try { isEnabled.set(sharedPreferences.getBoolean(MAPBOX_PREF_ENABLE_CRASH_REPORTER, false)); } catch (Exception ex) { Log.e(TAG, ex.toString()); } } @VisibleForTesting MapboxUncaughtExceptionHanlder(@NonNull Context applicationContext,
@NonNull SharedPreferences sharedPreferences,
@NonNull String mapboxPackage,
@NonNull String version,
Thread.UncaughtExceptionHandler defaultExceptionHandler); static void install(@NonNull Context context, @NonNull String mapboxPackage, @NonNull String version); @Override void uncaughtException(Thread thread, Throwable throwable); @Override void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key); static final String MAPBOX_PREF_ENABLE_CRASH_REPORTER; static final String MAPBOX_CRASH_REPORTER_PREFERENCES; }### Answer:
@Test public void onSharedPreferenceChanged() { boolean isEnabled = exceptionHanlder.isEnabled(); exceptionHanlder.onSharedPreferenceChanged( getMockedSharedPrefs(MAPBOX_PREF_ENABLE_CRASH_REPORTER, false), MAPBOX_PREF_ENABLE_CRASH_REPORTER); assertThat(exceptionHanlder.isEnabled()).isNotEqualTo(isEnabled); } |
### Question:
AndroidLocationEngineImpl implements LocationEngineImpl<LocationListener> { @NonNull @Override public LocationListener createListener(LocationEngineCallback<LocationEngineResult> callback) { return new AndroidLocationEngineCallbackTransport(callback); } AndroidLocationEngineImpl(@NonNull Context context); @NonNull @Override LocationListener createListener(LocationEngineCallback<LocationEngineResult> callback); @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationListener listener,
@Nullable Looper looper); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull PendingIntent pendingIntent); @SuppressLint("MissingPermission") @Override void removeLocationUpdates(@NonNull LocationListener listener); @Override void removeLocationUpdates(PendingIntent pendingIntent); }### Answer:
@Test public void createListener() { LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class); LocationListener locationListener = androidLocationEngineImpl.createListener(callback); Location mockLocation = getMockLocation(LATITUDE, LONGITUDE); locationListener.onLocationChanged(mockLocation); ArgumentCaptor<LocationEngineResult> argument = ArgumentCaptor.forClass(LocationEngineResult.class); verify(callback).onSuccess(argument.capture()); LocationEngineResult result = argument.getValue(); assertThat(result.getLastLocation()).isSameAs(mockLocation); } |
### Question:
AndroidLocationEngineImpl implements LocationEngineImpl<LocationListener> { @SuppressLint("MissingPermission") @Override public void removeLocationUpdates(@NonNull LocationListener listener) { if (listener != null) { locationManager.removeUpdates(listener); } } AndroidLocationEngineImpl(@NonNull Context context); @NonNull @Override LocationListener createListener(LocationEngineCallback<LocationEngineResult> callback); @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationListener listener,
@Nullable Looper looper); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull PendingIntent pendingIntent); @SuppressLint("MissingPermission") @Override void removeLocationUpdates(@NonNull LocationListener listener); @Override void removeLocationUpdates(PendingIntent pendingIntent); }### Answer:
@Test public void removeLocationUpdatesForInvalidListener() { LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class); engine.removeLocationUpdates(callback); verify(locationManagerMock, never()).removeUpdates(any(LocationListener.class)); }
@Test public void removeLocationUpdatesForPendingIntent() { PendingIntent pendingIntent = mock(PendingIntent.class); engine.removeLocationUpdates(pendingIntent); verify(locationManagerMock, times(1)).removeUpdates(any(PendingIntent.class)); } |
### Question:
AndroidLocationEngineImpl implements LocationEngineImpl<LocationListener> { @SuppressLint("MissingPermission") @Override public void requestLocationUpdates(@NonNull LocationEngineRequest request, @NonNull LocationListener listener, @Nullable Looper looper) throws SecurityException { currentProvider = getBestProvider(request.getPriority()); locationManager.requestLocationUpdates(currentProvider, request.getInterval(), request.getDisplacement(), listener, looper); } AndroidLocationEngineImpl(@NonNull Context context); @NonNull @Override LocationListener createListener(LocationEngineCallback<LocationEngineResult> callback); @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationListener listener,
@Nullable Looper looper); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull PendingIntent pendingIntent); @SuppressLint("MissingPermission") @Override void removeLocationUpdates(@NonNull LocationListener listener); @Override void removeLocationUpdates(PendingIntent pendingIntent); }### Answer:
@Test(expected = NullPointerException.class) public void requestLocationUpdatesNullCallback() { engine.requestLocationUpdates(null, null, null); } |
### Question:
LocationEngineResult { @Nullable public static LocationEngineResult extractResult(Intent intent) { LocationEngineResult result = null; if (isOnClasspath(GOOGLE_PLAY_LOCATION_RESULT)) { result = extractGooglePlayResult(intent); } return result == null ? extractAndroidResult(intent) : result; } private LocationEngineResult(List<Location> locations); @NonNull static LocationEngineResult create(@Nullable Location location); @NonNull static LocationEngineResult create(@Nullable List<Location> locations); @Nullable Location getLastLocation(); List<Location> getLocations(); @Nullable static LocationEngineResult extractResult(Intent intent); }### Answer:
@Test public void checkNullIntent() { LocationEngineResult result = LocationEngineResult.extractResult(null); assertThat(result).isNull(); }
@Test public void passInvalidIntent() { Intent intent = mock(Intent.class); LocationEngineResult result = LocationEngineResult.extractResult(intent); assertThat(result).isNull(); } |
### Question:
LocationEngineResult { @NonNull public static LocationEngineResult create(@Nullable Location location) { List<Location> locations = new ArrayList<>(); if (location != null) { locations.add(location); } return new LocationEngineResult(locations); } private LocationEngineResult(List<Location> locations); @NonNull static LocationEngineResult create(@Nullable Location location); @NonNull static LocationEngineResult create(@Nullable List<Location> locations); @Nullable Location getLastLocation(); List<Location> getLocations(); @Nullable static LocationEngineResult extractResult(Intent intent); }### Answer:
@Test public void passNullLocation() { Location location = null; LocationEngineResult result = LocationEngineResult.create(location); assertForNullInput(result); }
@Test public void passNullLocationList() { List<Location> locations = null; LocationEngineResult result = LocationEngineResult.create(locations); assertForNullInput(result); }
@Test public void passValidLocation() { Location location = getValidLocation(); LocationEngineResult result = LocationEngineResult.create(location); assertForValidInput(result); }
@Test public void passValidLocationList() { List<Location> locations = Collections.singletonList(getValidLocation()); LocationEngineResult result = LocationEngineResult.create(locations); assertForValidInput(result); }
@Test public void passMutableLocationListWithNulls() { List<Location> locations = getLocationsWithNulls(); LocationEngineResult result = LocationEngineResult.create(locations); assertForValidInput(result); }
@Test public void passImmutableLocationListWithNulls() { List<Location> locations = Collections.unmodifiableList(getLocationsWithNulls()); LocationEngineResult result = LocationEngineResult.create(locations); assertForValidInput(result); } |
### Question:
MapboxFusedLocationEngineImpl extends AndroidLocationEngineImpl { @Override public void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback) throws SecurityException { Location bestLastLocation = getBestLastLocation(); if (bestLastLocation != null) { callback.onSuccess(LocationEngineResult.create(bestLastLocation)); } else { callback.onFailure(new Exception("Last location unavailable")); } } MapboxFusedLocationEngineImpl(@NonNull Context context); @NonNull @Override LocationListener createListener(LocationEngineCallback<LocationEngineResult> callback); @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationListener listener,
@Nullable Looper looper); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull PendingIntent pendingIntent); }### Answer:
@Test public void getLastLocation() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); final AtomicReference<LocationEngineResult> resultRef = new AtomicReference<>(); LocationEngineCallback<LocationEngineResult> callback = getCallback(resultRef, latch); final Location location = getMockLocation(LATITUDE, LONGITUDE); final LocationEngineResult expectedResult = getMockEngineResult(location); when(locationManagerMock.getAllProviders()).thenReturn(Arrays.asList("gps", "network")); when(locationManagerMock.getLastKnownLocation(anyString())).thenReturn(location); engine.getLastLocation(callback); assertTrue(latch.await(5, SECONDS)); LocationEngineResult result = resultRef.get(); assertThat(result.getLastLocation()).isEqualTo(expectedResult.getLastLocation()); }
@Test(expected = NullPointerException.class) public void getLastLocationNullCallback() { engine.getLastLocation(null); } |
### Question:
GoogleLocationEngineImpl implements LocationEngineImpl<LocationCallback> { @Override public void removeLocationUpdates(@NonNull LocationCallback listener) { if (listener != null) { fusedLocationProviderClient.removeLocationUpdates(listener); } } @VisibleForTesting GoogleLocationEngineImpl(FusedLocationProviderClient fusedLocationProviderClient); GoogleLocationEngineImpl(@NonNull Context context); @NonNull @Override LocationCallback createListener(LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationCallback listener,
@Nullable Looper looper); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull PendingIntent pendingIntent); @Override void removeLocationUpdates(@NonNull LocationCallback listener); @Override void removeLocationUpdates(PendingIntent pendingIntent); }### Answer:
@Test public void removeLocationUpdatesForInvalidListener() { LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class); engine.removeLocationUpdates(callback); verify(fusedLocationProviderClientMock, never()).removeLocationUpdates(any(LocationCallback.class)); }
@Test public void removeLocationUpdatesForPendingIntent() { PendingIntent pendingIntent = mock(PendingIntent.class); engine.removeLocationUpdates(pendingIntent); verify(fusedLocationProviderClientMock, times(1)) .removeLocationUpdates(any(PendingIntent.class)); } |
### Question:
GoogleLocationEngineImpl implements LocationEngineImpl<LocationCallback> { @SuppressLint("MissingPermission") @Override public void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback) throws SecurityException { GoogleLastLocationEngineCallbackTransport transport = new GoogleLastLocationEngineCallbackTransport(callback); fusedLocationProviderClient.getLastLocation().addOnSuccessListener(transport).addOnFailureListener(transport); } @VisibleForTesting GoogleLocationEngineImpl(FusedLocationProviderClient fusedLocationProviderClient); GoogleLocationEngineImpl(@NonNull Context context); @NonNull @Override LocationCallback createListener(LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationCallback listener,
@Nullable Looper looper); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull PendingIntent pendingIntent); @Override void removeLocationUpdates(@NonNull LocationCallback listener); @Override void removeLocationUpdates(PendingIntent pendingIntent); }### Answer:
@Test(expected = NullPointerException.class) public void getLastLocationNullCallback() { engine.getLastLocation(null); } |
### Question:
GoogleLocationEngineImpl implements LocationEngineImpl<LocationCallback> { @SuppressLint("MissingPermission") @Override public void requestLocationUpdates(@NonNull LocationEngineRequest request, @NonNull LocationCallback listener, @Nullable Looper looper) throws SecurityException { fusedLocationProviderClient.requestLocationUpdates(toGMSLocationRequest(request), listener, looper); } @VisibleForTesting GoogleLocationEngineImpl(FusedLocationProviderClient fusedLocationProviderClient); GoogleLocationEngineImpl(@NonNull Context context); @NonNull @Override LocationCallback createListener(LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationCallback listener,
@Nullable Looper looper); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull PendingIntent pendingIntent); @Override void removeLocationUpdates(@NonNull LocationCallback listener); @Override void removeLocationUpdates(PendingIntent pendingIntent); }### Answer:
@Test(expected = NullPointerException.class) public void requestLocationUpdatesNullCallback() { engine.requestLocationUpdates(null, null, null); } |
### Question:
ConfigurationClient implements Callback { boolean shouldUpdate() { SharedPreferences sharedPreferences = TelemetryUtils.obtainSharedPreferences(context); long lastUpdateTime = sharedPreferences.getLong(MAPBOX_CONFIG_SYNC_KEY_TIMESTAMP, 0); long millisecondDiff = System.currentTimeMillis() - lastUpdateTime; return millisecondDiff >= DAY_IN_MILLIS; } ConfigurationClient(Context context, String userAgent, String accessToken, OkHttpClient client); @Override void onFailure(Call call, IOException e); @Override void onResponse(Call call, Response response); }### Answer:
@Test public void checkDaySinceLastUpdate() { assertTrue(configurationClient.shouldUpdate()); } |
### Question:
AppUserTurnstile extends Event implements Parcelable { @Override Type obtainType() { return Type.TURNSTILE; } AppUserTurnstile(String sdkIdentifier, String sdkVersion); AppUserTurnstile(String sdkIdentifier, String sdkVersion, boolean isFromPreferences); private AppUserTurnstile(Parcel in); @Nullable String getSkuId(); void setSkuId(@NonNull String skuId); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); @SuppressWarnings("unused")
static final Parcelable.Creator<AppUserTurnstile> CREATOR; }### Answer:
@Test public void checksAppUserTurnstileType() { Event anAppUserTurnstileEvent = obtainAnAppUserTurnstileEvent(); assertEquals(Event.Type.TURNSTILE, anAppUserTurnstileEvent.obtainType()); } |
### Question:
MapboxFusedLocationEngineImpl extends AndroidLocationEngineImpl { @NonNull @Override public LocationListener createListener(LocationEngineCallback<LocationEngineResult> callback) { return new MapboxLocationEngineCallbackTransport(callback); } MapboxFusedLocationEngineImpl(@NonNull Context context); @NonNull @Override LocationListener createListener(LocationEngineCallback<LocationEngineResult> callback); @Override void getLastLocation(@NonNull LocationEngineCallback<LocationEngineResult> callback); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull LocationListener listener,
@Nullable Looper looper); @SuppressLint("MissingPermission") @Override void requestLocationUpdates(@NonNull LocationEngineRequest request,
@NonNull PendingIntent pendingIntent); }### Answer:
@Test public void createListener() { LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class); LocationListener locationListener = mapboxFusedLocationEngineImpl.createListener(callback); Location mockLocation = getMockLocation(LATITUDE, LONGITUDE); locationListener.onLocationChanged(mockLocation); ArgumentCaptor<LocationEngineResult> argument = ArgumentCaptor.forClass(LocationEngineResult.class); verify(callback).onSuccess(argument.capture()); LocationEngineResult result = argument.getValue(); assertThat(result.getLastLocation()).isSameAs(mockLocation); } |
### Question:
AppUserTurnstile extends Event implements Parcelable { @Nullable public String getSkuId() { return skuId; } AppUserTurnstile(String sdkIdentifier, String sdkVersion); AppUserTurnstile(String sdkIdentifier, String sdkVersion, boolean isFromPreferences); private AppUserTurnstile(Parcel in); @Nullable String getSkuId(); void setSkuId(@NonNull String skuId); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); @SuppressWarnings("unused")
static final Parcelable.Creator<AppUserTurnstile> CREATOR; }### Answer:
@Test public void verifyDefaultSkuId() { AppUserTurnstile anAppUserTurnstileEvent = (AppUserTurnstile)obtainAnAppUserTurnstileEvent(); assertNull(anAppUserTurnstileEvent.getSkuId()); } |
### Question:
NetworkUsageMetricsCollector { void addRxBytes(long bytes) { metrics.addRxBytesForType(getActiveNetworkType(), bytes); } NetworkUsageMetricsCollector(Context context, TelemetryMetrics metrics); }### Answer:
@Test public void addRxBytes() { networkUsageMetricsCollector.addRxBytes(30); verify(metrics).addRxBytesForType(anyInt(), anyLong()); } |
### Question:
NetworkUsageMetricsCollector { void addTxBytes(long bytes) { metrics.addTxBytesForType(getActiveNetworkType(), bytes); } NetworkUsageMetricsCollector(Context context, TelemetryMetrics metrics); }### Answer:
@Test public void addTxBytes() { networkUsageMetricsCollector.addTxBytes(30); verify(metrics).addTxBytesForType(anyInt(), anyLong()); } |
### Question:
TelemetryMetrics extends AbstractCompositeMetrics { public void addRxBytesForType(@IntRange(from = TYPE_MOBILE, to = TYPE_VPN) int networkType, long bytes) { if (isValidNetworkType(networkType)) { add(networkType == TYPE_WIFI ? WIFI_BYTES_RX : MOBILE_BYTES_RX, bytes); } } TelemetryMetrics(long maxLength); void addRxBytesForType(@IntRange(from = TYPE_MOBILE, to = TYPE_VPN) int networkType, long bytes); void addTxBytesForType(@IntRange(from = TYPE_MOBILE, to = TYPE_VPN) int networkType, long bytes); static final String EVENTS_TOTAL; static final String EVENTS_FAILED; }### Answer:
@Test public void addRxBytesForMobileType() { telemetryMetrics.addRxBytesForType(ConnectivityManager.TYPE_MOBILE, 10L); Metrics metrics = telemetryMetrics.getMetrics(TelemetryMetrics.MOBILE_BYTES_RX); assertThat(metrics.getValue()).isEqualTo(10L); }
@Test public void addRxBytesForWifiType() { telemetryMetrics.addRxBytesForType(ConnectivityManager.TYPE_WIFI, 10L); Metrics metrics = telemetryMetrics.getMetrics(TelemetryMetrics.WIFI_BYTES_RX); assertThat(metrics.getValue()).isEqualTo(10L); } |
### Question:
TelemetryMetrics extends AbstractCompositeMetrics { public void addTxBytesForType(@IntRange(from = TYPE_MOBILE, to = TYPE_VPN) int networkType, long bytes) { if (isValidNetworkType(networkType)) { add(networkType == TYPE_WIFI ? WIFI_BYTES_TX : MOBILE_BYTES_TX, bytes); } } TelemetryMetrics(long maxLength); void addRxBytesForType(@IntRange(from = TYPE_MOBILE, to = TYPE_VPN) int networkType, long bytes); void addTxBytesForType(@IntRange(from = TYPE_MOBILE, to = TYPE_VPN) int networkType, long bytes); static final String EVENTS_TOTAL; static final String EVENTS_FAILED; }### Answer:
@Test public void addTxBytesForWifiType() { telemetryMetrics.addTxBytesForType(ConnectivityManager.TYPE_WIFI, 10L); Metrics metrics = telemetryMetrics.getMetrics(TelemetryMetrics.WIFI_BYTES_TX); assertThat(metrics.getValue()).isEqualTo(10L); }
@Test public void addTxBytesForMobileType() { telemetryMetrics.addTxBytesForType(ConnectivityManager.TYPE_MOBILE, 10L); Metrics metrics = telemetryMetrics.getMetrics(TelemetryMetrics.MOBILE_BYTES_TX); assertThat(metrics.getValue()).isEqualTo(10L); } |
### Question:
AlarmSchedulerFlusher implements SchedulerFlusher { @Override public void register() { Intent alarmIntent = receiver.supplyIntent(); pendingIntent = PendingIntent.getBroadcast(context, 0, alarmIntent, PendingIntent.FLAG_UPDATE_CURRENT); IntentFilter filter = new IntentFilter(SCHEDULER_FLUSHER_INTENT); context.registerReceiver(receiver, filter); } AlarmSchedulerFlusher(Context context, AlarmManager manager, AlarmReceiver receiver); @Override void register(); @Override void schedule(long elapsedRealTime); @Override void unregister(); }### Answer:
@Test public void checksAlarmRegistered() throws Exception { Context mockedContext = mock(Context.class); AlarmManager mockedAlarmManager = mock(AlarmManager.class); AlarmReceiver mockedAlarmReceiver = mock(AlarmReceiver.class); AlarmSchedulerFlusher theAlarmSchedulerFlusher = new AlarmSchedulerFlusher(mockedContext, mockedAlarmManager, mockedAlarmReceiver); theAlarmSchedulerFlusher.register(); IntentFilter expectedFilter = new IntentFilter("com.mapbox.scheduler_flusher"); verify(mockedContext, times(1)).registerReceiver( eq(mockedAlarmReceiver), refEq(expectedFilter) ); } |
### Question:
LocationEngineControllerImpl implements LocationEngineController { @Override public void onResume() { registerReceiver(); requestLocationUpdates(); } LocationEngineControllerImpl(@NonNull Context context,
@NonNull LocationEngine locationEngine,
@NonNull LocationUpdatesBroadcastReceiver locationUpdatesBroadcastReceiver); @Override void onPause(); @Override void onResume(); @Override void onDestroy(); }### Answer:
@Test public void testOnResume() { Context mockedContext = mock(Context.class, RETURNS_DEEP_STUBS); when(mockedContext.checkPermission(anyString(), anyInt(), anyInt())).thenReturn(PackageManager.PERMISSION_GRANTED); locationEngineController = new LocationEngineControllerImpl(mockedContext, locationEngine, broadcastReceiver); locationEngineController.onResume(); verify(mockedContext).registerReceiver(any(BroadcastReceiver.class), any(IntentFilter.class)); }
@Test public void testOnResumePermissionsDisabled() { Context mockedContext = mock(Context.class, RETURNS_DEEP_STUBS); when(mockedContext.checkPermission(anyString(), anyInt(), anyInt())).thenReturn(PackageManager.PERMISSION_DENIED); locationEngineController = new LocationEngineControllerImpl(mockedContext, locationEngine, broadcastReceiver); locationEngineController.onResume(); verifyZeroInteractions(locationEngine); } |
### Question:
LocationEngineControllerImpl implements LocationEngineController { @Override public void onDestroy() { removeLocationUpdates(); unregisterReceiver(); } LocationEngineControllerImpl(@NonNull Context context,
@NonNull LocationEngine locationEngine,
@NonNull LocationUpdatesBroadcastReceiver locationUpdatesBroadcastReceiver); @Override void onPause(); @Override void onResume(); @Override void onDestroy(); }### Answer:
@Test public void testOnDestroy() { Context mockedContext = mock(Context.class, RETURNS_DEEP_STUBS); locationEngineController = new LocationEngineControllerImpl(mockedContext, locationEngine, broadcastReceiver); locationEngineController.onDestroy(); verify(mockedContext).unregisterReceiver(any(BroadcastReceiver.class)); } |
### Question:
LocationCollectionClient implements SharedPreferences.OnSharedPreferenceChangeListener { boolean isEnabled() { return isEnabled.get(); } @VisibleForTesting LocationCollectionClient(@NonNull LocationEngineController collectionController,
@NonNull HandlerThread handlerThread,
@NonNull SessionIdentifier sessionIdentifier,
@NonNull SharedPreferences sharedPreferences,
@NonNull MapboxTelemetry telemetry); static LocationCollectionClient install(@NonNull Context context, long defaultInterval); @Override void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key); static final int DEFAULT_SESSION_ROTATION_INTERVAL_HOURS; }### Answer:
@Test public void verifyDefaultStatus() { assertThat(collectionClient.isEnabled()).isFalse(); } |
### Question:
LocationCollectionClient implements SharedPreferences.OnSharedPreferenceChangeListener { long getSessionRotationInterval() { return sessionIdentifier.get().getInterval(); } @VisibleForTesting LocationCollectionClient(@NonNull LocationEngineController collectionController,
@NonNull HandlerThread handlerThread,
@NonNull SessionIdentifier sessionIdentifier,
@NonNull SharedPreferences sharedPreferences,
@NonNull MapboxTelemetry telemetry); static LocationCollectionClient install(@NonNull Context context, long defaultInterval); @Override void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key); static final int DEFAULT_SESSION_ROTATION_INTERVAL_HOURS; }### Answer:
@Test public void verifyDefaultInterval() { assertThat(collectionClient.getSessionRotationInterval()) .isEqualTo(TimeUnit.HOURS.toMillis(DEFAULT_SESSION_ROTATION_INTERVAL_HOURS)); } |
### Question:
LocationCollectionClient implements SharedPreferences.OnSharedPreferenceChangeListener { @Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { try { if (LOCATION_COLLECTOR_ENABLED.equals(key)) { setEnabled(sharedPreferences.getBoolean(LOCATION_COLLECTOR_ENABLED, false)); } else if (SESSION_ROTATION_INTERVAL_MILLIS.equals(key)) { setSessionRotationInterval(sharedPreferences.getLong(SESSION_ROTATION_INTERVAL_MILLIS, TimeUnit.HOURS.toMillis(DEFAULT_SESSION_ROTATION_INTERVAL_HOURS))); } } catch (Exception ex) { Log.e(TAG, ex.toString()); } } @VisibleForTesting LocationCollectionClient(@NonNull LocationEngineController collectionController,
@NonNull HandlerThread handlerThread,
@NonNull SessionIdentifier sessionIdentifier,
@NonNull SharedPreferences sharedPreferences,
@NonNull MapboxTelemetry telemetry); static LocationCollectionClient install(@NonNull Context context, long defaultInterval); @Override void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key); static final int DEFAULT_SESSION_ROTATION_INTERVAL_HOURS; }### Answer:
@Test public void verifyInvalidKeyChangedViaSharedPrefs() { SharedPreferences mockedSharedPrefs = getMockedSharedPrefs(); collectionClient.onSharedPreferenceChanged(mockedSharedPrefs, "foo"); verifyZeroInteractions(mockedSharedPrefs); } |
### Question:
LocationCollectionClient implements SharedPreferences.OnSharedPreferenceChangeListener { @NonNull static LocationCollectionClient getInstance() { synchronized (lock) { if (locationCollectionClient != null) { return locationCollectionClient; } else { throw new IllegalStateException("LocationCollectionClient is not installed."); } } } @VisibleForTesting LocationCollectionClient(@NonNull LocationEngineController collectionController,
@NonNull HandlerThread handlerThread,
@NonNull SessionIdentifier sessionIdentifier,
@NonNull SharedPreferences sharedPreferences,
@NonNull MapboxTelemetry telemetry); static LocationCollectionClient install(@NonNull Context context, long defaultInterval); @Override void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key); static final int DEFAULT_SESSION_ROTATION_INTERVAL_HOURS; }### Answer:
@Test(expected = IllegalStateException.class) public void callGetInstanceBeforeInstall() { LocationCollectionClient.getInstance(); } |
### Question:
LocationCollectionClient implements SharedPreferences.OnSharedPreferenceChangeListener { static boolean uninstall() { boolean uninstalled = false; synchronized (lock) { if (locationCollectionClient != null) { locationCollectionClient.locationEngineController.onDestroy(); locationCollectionClient.settingsChangeHandlerThread.quit(); locationCollectionClient.sharedPreferences.unregisterOnSharedPreferenceChangeListener(locationCollectionClient); locationCollectionClient = null; uninstalled = true; } } return uninstalled; } @VisibleForTesting LocationCollectionClient(@NonNull LocationEngineController collectionController,
@NonNull HandlerThread handlerThread,
@NonNull SessionIdentifier sessionIdentifier,
@NonNull SharedPreferences sharedPreferences,
@NonNull MapboxTelemetry telemetry); static LocationCollectionClient install(@NonNull Context context, long defaultInterval); @Override void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key); static final int DEFAULT_SESSION_ROTATION_INTERVAL_HOURS; }### Answer:
@Test public void callUninstallBeforeInstall() { assertThat(LocationCollectionClient.uninstall()).isFalse(); } |
### Question:
LocationUpdatesBroadcastReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { try { if (intent == null) { Log.w(TAG, "intent == null"); return; } final String action = intent.getAction(); if (!ACTION_LOCATION_UPDATED.equals(action)) { return; } LocationEngineResult result = LocationEngineResult.extractResult(intent); if (result == null) { Log.w(TAG, "LocationEngineResult == null"); return; } LocationCollectionClient collectionClient = LocationCollectionClient.getInstance(); MapboxTelemetry telemetry = collectionClient.getTelemetry(); String sessionId = collectionClient.getSessionId(); List<Location> locations = result.getLocations(); for (Location location : locations) { if (isThereAnyNaN(location) || isThereAnyInfinite(location)) { continue; } telemetry.push(LocationMapper.create(location, sessionId)); } } catch (Throwable throwable) { Log.e(TAG, throwable.toString()); } } @Override void onReceive(Context context, Intent intent); }### Answer:
@Test public void testNullIntentOnReceive() { Context mockedContext = mock(Context.class, RETURNS_DEEP_STUBS); broadcastReceiver.onReceive(mockedContext, null); verify(mockedContext, never()).getApplicationContext(); }
@Test public void testOnReceiveActionReturnNull() { Context mockedContext = mock(Context.class, RETURNS_DEEP_STUBS); Intent mockedIntent = mock(Intent.class); when(mockedIntent.getAction()).thenReturn(null); broadcastReceiver.onReceive(mockedContext, mockedIntent); verify(mockedIntent, never()).getStringExtra(anyString()); } |
### Question:
AlarmReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { try { if (SCHEDULER_FLUSHER_INTENT.equals(intent.getAction())) { callback.onPeriodRaised(); } } catch (Throwable throwable) { Log.e(TAG, throwable.toString()); } } AlarmReceiver(@NonNull SchedulerCallback callback); @Override void onReceive(Context context, Intent intent); }### Answer:
@Test public void checksOnPeriodRaisedCall() throws Exception { Context mockedContext = mock(Context.class); Intent mockedIntent = mock(Intent.class); when(mockedIntent.getAction()).thenReturn("com.mapbox.scheduler_flusher"); SchedulerCallback mockedSchedulerCallback = mock(SchedulerCallback.class); AlarmReceiver theAlarmReceiver = new AlarmReceiver(mockedSchedulerCallback); theAlarmReceiver.onReceive(mockedContext, mockedIntent); verify(mockedSchedulerCallback, times(1)).onPeriodRaised(); } |
### Question:
AlarmReceiver extends BroadcastReceiver { Intent supplyIntent() { return new Intent(SCHEDULER_FLUSHER_INTENT); } AlarmReceiver(@NonNull SchedulerCallback callback); @Override void onReceive(Context context, Intent intent); }### Answer:
@Test public void checksSupplyIntent() throws Exception { SchedulerCallback mockedSchedulerCallback = mock(SchedulerCallback.class); AlarmReceiver theAlarmReceiver = new AlarmReceiver(mockedSchedulerCallback); Intent actualAlarmIntent = theAlarmReceiver.supplyIntent(); Intent expectedAlarmIntent = new Intent("com.mapbox.scheduler_flusher"); assertEquals(expectedAlarmIntent.getAction(), actualAlarmIntent.getAction()); } |
### Question:
MapboxTelemetry implements FullQueueCallback, ServiceTaskCallback { public boolean addTelemetryListener(TelemetryListener listener) { return telemetryListeners.add(listener); } MapboxTelemetry(Context context, String accessToken, String userAgent); MapboxTelemetry(Context context, String accessToken, String userAgent, EventsQueue queue,
TelemetryClient telemetryClient, Callback httpCallback, SchedulerFlusher schedulerFlusher,
Clock clock, TelemetryEnabler telemetryEnabler, ExecutorService executorService); @Override // Callback is dispatched on background thread void onFullQueue(List<Event> fullQueue); @Override void onTaskRemoved(); boolean push(Event event); boolean enable(); boolean disable(); boolean updateSessionIdRotationInterval(SessionInterval interval); void updateDebugLoggingEnabled(boolean isDebugLoggingEnabled); void updateUserAgent(String userAgent); boolean updateAccessToken(String accessToken); boolean addTelemetryListener(TelemetryListener listener); boolean removeTelemetryListener(TelemetryListener listener); boolean addAttachmentListener(AttachmentListener listener); boolean removeAttachmentListener(AttachmentListener listener); @SuppressWarnings("WeakerAccess") @Deprecated synchronized boolean setBaseUrl(String eventsHost); boolean isCnRegion(); synchronized void setCnRegion(boolean setCnRegion); }### Answer:
@Test public void checkAddTelemetryListener() throws Exception { MapboxTelemetry theMapboxTelemetry = obtainMapboxTelemetry(); TelemetryListener telemetryListener = mock(TelemetryListener.class); assertTrue(theMapboxTelemetry.addTelemetryListener(telemetryListener)); } |
### Question:
MapboxTelemetry implements FullQueueCallback, ServiceTaskCallback { public boolean addAttachmentListener(AttachmentListener listener) { return attachmentListeners.add(listener); } MapboxTelemetry(Context context, String accessToken, String userAgent); MapboxTelemetry(Context context, String accessToken, String userAgent, EventsQueue queue,
TelemetryClient telemetryClient, Callback httpCallback, SchedulerFlusher schedulerFlusher,
Clock clock, TelemetryEnabler telemetryEnabler, ExecutorService executorService); @Override // Callback is dispatched on background thread void onFullQueue(List<Event> fullQueue); @Override void onTaskRemoved(); boolean push(Event event); boolean enable(); boolean disable(); boolean updateSessionIdRotationInterval(SessionInterval interval); void updateDebugLoggingEnabled(boolean isDebugLoggingEnabled); void updateUserAgent(String userAgent); boolean updateAccessToken(String accessToken); boolean addTelemetryListener(TelemetryListener listener); boolean removeTelemetryListener(TelemetryListener listener); boolean addAttachmentListener(AttachmentListener listener); boolean removeAttachmentListener(AttachmentListener listener); @SuppressWarnings("WeakerAccess") @Deprecated synchronized boolean setBaseUrl(String eventsHost); boolean isCnRegion(); synchronized void setCnRegion(boolean setCnRegion); }### Answer:
@Test public void checkAddAttachmentListener() throws Exception { MapboxTelemetry theMapboxTelemetry = obtainMapboxTelemetry(); AttachmentListener attachmentListener = mock(AttachmentListener.class); assertTrue(theMapboxTelemetry.addAttachmentListener(attachmentListener)); } |
### Question:
LocationEngineProvider { @NonNull @Deprecated public static LocationEngine getBestLocationEngine(@NonNull Context context, boolean background) { return getBestLocationEngine(context); } private LocationEngineProvider(); @NonNull @Deprecated static LocationEngine getBestLocationEngine(@NonNull Context context, boolean background); @NonNull static LocationEngine getBestLocationEngine(@NonNull Context context); }### Answer:
@Test(expected = NullPointerException.class) public void passNullContext() { LocationEngineProvider.getBestLocationEngine(null, false); } |
### Question:
AtlasJavaModelFactory { public static JavaClass createJavaClass() { JavaClass javaClass = new JavaClass(); javaClass.setJavaEnumFields(new JavaEnumFields()); javaClass.setJavaFields(new JavaFields()); return javaClass; } static JavaClass createJavaClass(); static JavaField createJavaField(); static FieldGroup cloneFieldGroup(FieldGroup group); static Field cloneJavaField(Field field, boolean withActions); static void copyField(Field from, Field to, boolean withActions); static final String URI_FORMAT; }### Answer:
@Test public void testCreateJavaClass() { JavaClass javaClass = AtlasJavaModelFactory.createJavaClass(); assertNotNull(javaClass); assertNotNull(javaClass.getJavaFields()); assertNotNull(javaClass.getJavaFields().getJavaField()); assertEquals(new Integer(0), new Integer(javaClass.getJavaFields().getJavaField().size())); assertNotNull(javaClass.getJavaEnumFields()); assertNotNull(javaClass.getJavaEnumFields().getJavaEnumField()); assertEquals(new Integer(0), new Integer(javaClass.getJavaEnumFields().getJavaEnumField().size())); } |
### Question:
MavenClasspathHelper { public String generateClasspathFromPom(String pom) throws Exception { if (pom == null || pom.isEmpty()) { return null; } if (LOG.isDebugEnabled()) { LOG.debug("Generating classpath from pom:\n" + pom); } Path workingDirectory = createWorkingDirectory(); Path pomFile = Paths.get(workingDirectory.toString(), "pom.xml"); Files.write(pomFile, pom.getBytes()); List<String> cmd = new LinkedList<String>(); cmd.add("mvn"); cmd.add("org.apache.maven.plugins:maven-dependency-plugin:3.0.0:build-classpath"); cmd.add("-DincludeScope=runtime"); String result = executeMavenProcess(workingDirectory.toString(), cmd); if (result != null) { result = parseClasspathFromMavenOutput(result); } else { LOG.error("MavenProcess returned unexpected result: " + result); throw new InspectionException("Unable to generate classpath from pom file"); } try { deleteWorkingDirectory(workingDirectory); } catch (IOException ioe) { LOG.warn("Cleanup of working directory failed to complete: " + ioe.getMessage(), ioe); } return result; } String generateClasspathFromPom(String pom); Integer cleanupTempFolders(); long getProcessCheckInterval(); void setProcessCheckInterval(long processCheckInterval); long getProcessMaxExecutionTime(); void setProcessMaxExecutionTime(long processMaxExecutionTime); String getBaseFolder(); void setBaseFolder(String baseFolder); static final String WORKING_FOLDER_PREFIX; }### Answer:
@Test public void testMavenClasspath() throws Exception { Path testPom = Paths.get("src/test/resources/pom-classpath-test.xml"); String pomData = new String(Files.readAllBytes(testPom)); String classpath = mavenClasspathHelper.generateClasspathFromPom(pomData); assertNotNull(classpath); assertTrue(classpath.contains("jackson-annotations")); assertTrue(classpath.contains("jackson-databind")); assertTrue(classpath.contains("jackson-core")); } |
### Question:
JavaFieldWriterUtil { public Class<?> getDefaultCollectionImplClass(CollectionType type) { if (type == CollectionType.LIST) { return this.defaultCollectionImplClasses.get(List.class); } else if (type == CollectionType.MAP) { return this.defaultCollectionImplClasses.get(Map.class); } return null; } JavaFieldWriterUtil(AtlasConversionService conversionService); JavaFieldWriterUtil(ClassLoader classLoader, AtlasConversionService conversionService); Object instantiateObject(Class<?> clz); Class<?> loadClass(String name); Class<?> getDefaultCollectionImplClass(CollectionType type); Object getChildObject(Object parentObject, SegmentContext segment); Object createComplexChildObject(Object parentObject, SegmentContext segmentContext, Class<?> clazz); Object createComplexChildObject(Object parentObject, SegmentContext segmentContext); void setChildObject(Object parentObject, Object childObject, SegmentContext segmentContext); Class<?> resolveChildClass(Object parentObject, SegmentContext segment); Object getCollectionItem(Object collectionObject, SegmentContext segmentContext); Object adjustCollectionSize(Object collectionObject, SegmentContext segmentContext); @SuppressWarnings({ "rawtypes", "unchecked" }) Object createComplexCollectionItem(Object collectionObject, Class<?> itemType, SegmentContext segmentContext); Object createComplexCollectionItem(Object parentObject, Object collectionObject, SegmentContext segmentContext); Class<?> resolveCollectionItemClass(Object parentObject, SegmentContext segmentContext); @SuppressWarnings({ "rawtypes", "unchecked" }) void setCollectionItem(Object collectionObject, Object item, SegmentContext segmentContext); Map<Class<?>, Class<?>> getDefaultCollectionImplClasses(); }### Answer:
@Test public void testGetDefaultCollectionImplClass() throws Exception { assertNull(writerUtil.getDefaultCollectionImplClass(CollectionType.NONE)); assertNull(writerUtil.getDefaultCollectionImplClass(CollectionType.ARRAY)); assertEquals(LinkedList.class, writerUtil.getDefaultCollectionImplClass(CollectionType.LIST)); assertEquals(HashMap.class, writerUtil.getDefaultCollectionImplClass(CollectionType.MAP)); } |
### Question:
SqlTimestampConverter implements AtlasConverter<Timestamp> { @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.DATE_TIME) public Date toDate(Timestamp timestamp) { return timestamp != null ? Date.from(timestamp.toInstant()) : null; } @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.DATE_TIME_TZ) Calendar toCalendar(Timestamp timestamp); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.DATE_TIME) Date toDate(Timestamp timestamp); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.DATE_TIME_TZ) GregorianCalendar toGregorianCalendar(Timestamp timestamp); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.DATE) LocalDate toLocalDate(Timestamp timestamp); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.DATE_TIME) LocalDateTime toLocalDateTime(Timestamp timestamp); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.TIME) LocalTime toLocalTime(Timestamp timestamp); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.DATE) java.sql.Date toSqlDate(Timestamp timestamp); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.TIME) java.sql.Time toSqlTime(Timestamp timestamp); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME, targetType = FieldType.DATE_TIME_TZ) ZonedDateTime toZonedDateTime(Timestamp timestamp); }### Answer:
@Test public void convertFromTimestamp() { Date date = converter.toDate(new Timestamp(System.nanoTime())); assertNotNull(date); } |
### Question:
StringUtil { public static String getFieldNameFromGetter(String getter) { if (StringUtil.isEmpty(getter)) { return getter; } String subGetter; if (getter.startsWith("get")) { if (getter.length() <= "get".length()) { return getter; } subGetter = getter.substring("get".length()); } else if (getter.startsWith("is")) { if (getter.length() <= "is".length()) { return getter; } subGetter = getter.substring("is".length()); } else { return getter; } return String.valueOf(subGetter.charAt(0)).toLowerCase() + subGetter.substring(1); } static boolean isEmpty(String s); static String capitalizeFirstLetter(String sentence); static String getFieldNameFromGetter(String getter); static String getFieldNameFromSetter(String setter); static String formatTimeHMS(long milliseconds); }### Answer:
@Test public void testRemoveGetterAndLowercaseFirstLetter() { assertNull(StringUtil.getFieldNameFromGetter(null)); assertEquals("", StringUtil.getFieldNameFromGetter("")); assertEquals("g", StringUtil.getFieldNameFromGetter("g")); assertEquals("ge", StringUtil.getFieldNameFromGetter("ge")); assertEquals("get", StringUtil.getFieldNameFromGetter("get")); assertEquals("i", StringUtil.getFieldNameFromGetter("i")); assertEquals("is", StringUtil.getFieldNameFromGetter("is")); assertEquals("abc", StringUtil.getFieldNameFromGetter("getAbc")); assertEquals("abc", StringUtil.getFieldNameFromGetter("isAbc")); } |
### Question:
JavaFieldReader implements AtlasFieldReader { @Override public Field read(AtlasInternalSession session) throws AtlasException { try { Field field = session.head().getSourceField(); if (sourceDocument == null) { AtlasUtil.addAudit(session, field.getDocId(), String.format( "Unable to read sourceField (path=%s), document (docId=%s) is null", field.getPath(), field.getDocId()), field.getPath(), AuditStatus.ERROR, null); } AtlasPath path = new AtlasPath(field.getPath()); List<Field> fields = getFieldsForPath(session, sourceDocument, field, path, 0); if (LOG.isDebugEnabled()) { LOG.debug("Processed input field sPath=" + field.getPath() + " sV=" + field.getValue() + " sT=" + field.getFieldType() + " docId: " + field.getDocId()); } if (path.hasCollection() && !path.isIndexedCollection()) { FieldGroup fieldGroup = AtlasModelFactory.createFieldGroupFrom(field, true); fieldGroup.getField().addAll(fields); session.head().setSourceField(fieldGroup); return fieldGroup; } else if (fields.size() == 1) { field.setValue(fields.get(0).getValue()); return field; } else { return field; } } catch (Exception e) { throw new AtlasException(e); } } @Override Field read(AtlasInternalSession session); void setDocument(Object sourceDocument); void setConversionService(AtlasConversionService conversionService); }### Answer:
@Test public void testRead() throws Exception { TargetTestClass source = new TargetTestClass(); source.setAddress(new TargetAddress()); source.getAddress().setAddressLine1("123 any street"); reader.setDocument(source); read("/address/addressLine1", FieldType.STRING); assertEquals("123 any street", field.getValue()); assertEquals(0, audits.size()); } |
### Question:
AtlasJsonModelFactory { public static JsonDocument createJsonDocument() { JsonDocument jsonDocument = new JsonDocument(); jsonDocument.setFields(new Fields()); return jsonDocument; } static JsonDocument createJsonDocument(); static JsonField createJsonField(); static String toString(JsonField f); static JsonField cloneField(JsonField field, boolean withActions); static FieldGroup cloneFieldGroup(FieldGroup group); static void copyField(Field from, Field to, boolean withActions); static final String URI_FORMAT; }### Answer:
@Test public void testCreateJsonDocument() { JsonDocument jsonDoc = AtlasJsonModelFactory.createJsonDocument(); assertNotNull(jsonDoc); assertNotNull(jsonDoc.getFields()); assertNotNull(jsonDoc.getFields().getField()); assertEquals(new Integer(0), new Integer(jsonDoc.getFields().getField().size())); } |
### Question:
JsonModule extends BaseAtlasModule { @Override public Boolean isSupportedField(Field field) { if (super.isSupportedField(field)) { return true; } return field instanceof JsonField; } @Override void processPreValidation(AtlasInternalSession atlasSession); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); void writeTargetValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); }### Answer:
@Test public void testIsSupportedField() { assertTrue(module.isSupportedField(new JsonField())); assertFalse(module.isSupportedField(new PropertyField())); assertFalse(module.isSupportedField(new ConstantField())); assertTrue(module.isSupportedField(new SimpleField())); } |
### Question:
AtlasXmlModelFactory { public static XmlDocument createXmlDocument() { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.setFields(new Fields()); return xmlDocument; } static XmlDocument createXmlDocument(); static XmlField createXmlField(); static XmlField cloneField(XmlField field, boolean withActions); static FieldGroup cloneFieldGroup(FieldGroup group); static void copyField(Field from, Field to, boolean withActions); static final String URI_FORMAT; }### Answer:
@Test public void testCreateXmlDocument() { XmlDocument xmlDoc = AtlasXmlModelFactory.createXmlDocument(); assertNotNull(xmlDoc); assertNotNull(xmlDoc.getFields()); assertNotNull(xmlDoc.getFields().getField()); assertEquals(new Integer(0), new Integer(xmlDoc.getFields().getField().size())); } |
### Question:
XmlModule extends BaseAtlasModule { @Override public Boolean isSupportedField(Field field) { if (super.isSupportedField(field)) { return true; } return field instanceof XmlField; } @Override void init(); @Override void processPreValidation(AtlasInternalSession atlasSession); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); }### Answer:
@Test public void testIsSupportedField() { assertTrue(module.isSupportedField(new XmlField())); assertFalse(module.isSupportedField(new PropertyField())); assertFalse(module.isSupportedField(new ConstantField())); assertTrue(module.isSupportedField(new SimpleField())); } |
### Question:
JavaModule extends BaseAtlasModule { @Override public Boolean isSupportedField(Field field) { if (super.isSupportedField(field)) { return true; } return field instanceof JavaField || field instanceof JavaEnumField; } JavaModule(); @Override void init(); @Override void destroy(); @Override void processPreValidation(AtlasInternalSession atlasSession); @Override void processPreSourceExecution(AtlasInternalSession atlasSession); @Override void processPreTargetExecution(AtlasInternalSession atlasSession); @Override void readSourceValue(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); static final String DEFAULT_LIST_CLASS; }### Answer:
@Test public void testIsSupportedField() { assertTrue(module.isSupportedField(new JavaField())); assertTrue(module.isSupportedField(new JavaEnumField())); assertFalse(module.isSupportedField(new PropertyField())); assertFalse(module.isSupportedField(new ConstantField())); assertTrue(module.isSupportedField(new SimpleField())); } |
### Question:
StringPatternValidator implements AtlasValidator { @Override public boolean supports(Class<?> clazz) { return String.class.isAssignableFrom(clazz); } StringPatternValidator(ValidationScope scope, String violationMessage, String pattern); StringPatternValidator(ValidationScope scope, String violationMessage, String pattern, boolean useMatch); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testSupported() { validator = new StringPatternValidator(ValidationScope.ALL, "Must match .*", ".*"); assertTrue(validator.supports(String.class)); }
@Test public void testUnsupported() { validator = new StringPatternValidator(ValidationScope.DATA_SOURCE, "Must match [0-9_.]", "[0-9_.]"); assertFalse(validator.supports(Double.class)); } |
### Question:
StringPatternValidator implements AtlasValidator { @Override public void validate(Object target, List<Validation> validations, String id) { validate(target, validations, id, ValidationStatus.ERROR); } StringPatternValidator(ValidationScope scope, String violationMessage, String pattern); StringPatternValidator(ValidationScope scope, String violationMessage, String pattern, boolean useMatch); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testValidate() { validator = new StringPatternValidator(ValidationScope.MAPPING, "Must match [^A-Za-z0-9_.]", "[^A-Za-z0-9_.]"); validator.validate("This. &* should result in an error", validations, "testValidate"); assertTrue(validationHelper.hasErrors()); validations.clear(); assertFalse(validationHelper.hasErrors()); validator.validate("This_isafineexample.whatever1223", validations, "testValidate-2"); assertFalse(validationHelper.hasErrors()); }
@Test public void testValidateUsingMatch() { validator = new StringPatternValidator(ValidationScope.LOOKUP_TABLE, "Must match [0-9]+", "[0-9]+", true); validator.validate("0333", validations, "testValidateUsingMatch"); assertFalse(validationHelper.hasErrors()); validator = new StringPatternValidator(ValidationScope.PROPERTY, "Must match [0-9]", "[0-9]", true); validator.validate("This_isafineexample.whatever", validations, "testValidateUsingMatch-2"); assertTrue(validationHelper.hasErrors()); } |
### Question:
CompositeValidator implements AtlasValidator { @Override public boolean supports(Class<?> clazz) { for (AtlasValidator validator : validators) { if (validator.supports(clazz)) { return true; } } return false; } CompositeValidator(List<AtlasValidator> validators); CompositeValidator(AtlasValidator... validators); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testSupports() { NotEmptyValidator notEmptyValidator = new NotEmptyValidator(ValidationScope.ALL, "violationMessage"); assertTrue(notEmptyValidator.supports(new HashSet<String>())); assertTrue(notEmptyValidator.supports(new ArrayList<String>())); assertTrue(notEmptyValidator.supports(new HashMap<String, String>())); assertFalse(notEmptyValidator.supports(new String[1])); assertTrue(notEmptyValidator.supports(new ArrayDeque<String>())); List<AtlasValidator> validators = new ArrayList<>(); validators.add(notEmptyValidator); CompositeValidator compositeValidator = new CompositeValidator(validators); assertFalse(compositeValidator.supports(NotEmptyValidator.class)); assertTrue(compositeValidator.supports(List.class)); } |
### Question:
LookupTableNameValidator implements AtlasValidator { @Override public boolean supports(Class<?> clazz) { return LookupTables.class.isAssignableFrom(clazz); } LookupTableNameValidator(String violationMessage); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testSupportsLookupTables() { LookupTables lookupTables = makeLookupTables(); assertTrue(validator.supports(lookupTables.getClass())); } |
### Question:
LookupTableNameValidator implements AtlasValidator { @Override public void validate(Object target, List<Validation> validations, String id) { validate(target, validations, id, ValidationStatus.ERROR); } LookupTableNameValidator(String violationMessage); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testValidateDuplicatedNames() { LookupTables lookupTables = makeLookupTables(); validator.validate(lookupTables, validations, null); assertTrue(validationHelper.hasErrors()); assertEquals(ValidationScope.LOOKUP_TABLE, validationHelper.getValidation().get(0).getScope()); assertNull(validationHelper.getValidation().get(0).getId()); debugErrors(validationHelper); }
@Test public void testValidateNoDuplicateNames() { LookupTables lookupTables = makeLookupTables(); lookupTables.getLookupTable().remove(2); validator.validate(lookupTables, validations, null); assertFalse(validationHelper.hasErrors()); } |
### Question:
NotEmptyValidator implements AtlasValidator { @Override public boolean supports(Class<?> clazz) { return clazz.isAssignableFrom(List.class) || clazz.isAssignableFrom(Map.class) || clazz.isAssignableFrom(Set.class) || clazz.isAssignableFrom(Collection.class); } NotEmptyValidator(ValidationScope scope, String violationMessage); @Override boolean supports(Class<?> clazz); boolean supports(Object object); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testSupported() { assertTrue(validator.supports(Map.class)); assertTrue(validator.supports(List.class)); assertTrue(validator.supports(Set.class)); assertTrue(validator.supports(Collection.class)); }
@Test public void testUnsupported() { assertFalse(validator.supports(HashMap.class)); } |
### Question:
NotEmptyValidator implements AtlasValidator { @Override public void validate(Object target, List<Validation> validations, String id) { validate(target, validations, id, ValidationStatus.ERROR); } NotEmptyValidator(ValidationScope scope, String violationMessage); @Override boolean supports(Class<?> clazz); boolean supports(Object object); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testValidate() { List<String> stuff = new ArrayList<>(); stuff.add("one"); stuff.add("two"); validator.validate(stuff, validations, "testValidate-1"); assertFalse(validationHelper.hasErrors()); validator.validate(stuff, validations, "testValidate-2", ValidationStatus.WARN); assertFalse(validationHelper.hasErrors()); }
@Test public void testValidateInvalid() { List<String> stuff = new ArrayList<>(); validator.validate(stuff, validations, "testValidateInvalid"); assertTrue(validationHelper.hasErrors()); assertEquals(new Integer(1), new Integer(validationHelper.getCount())); assertEquals(ValidationScope.MAPPING, validationHelper.getValidation().get(0).getScope()); assertEquals("testValidateInvalid", validationHelper.getValidation().get(0).getId()); assertFalse(validationHelper.hasWarnings()); assertFalse(validationHelper.hasInfos()); } |
### Question:
StringLengthValidator implements AtlasValidator { @Override public boolean supports(Class<?> clazz) { return String.class.isAssignableFrom(clazz); } StringLengthValidator(ValidationScope scope, String violationMessage, int minLength, int maxLength); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testSupported() { assertTrue(validator.supports(String.class)); }
@Test public void testUnsupported() { assertFalse(validator.supports(Integer.class)); } |
### Question:
StringLengthValidator implements AtlasValidator { @Override public void validate(Object target, List<Validation> validations, String id) { validate(target, validations, id, ValidationStatus.ERROR); } StringLengthValidator(ValidationScope scope, String violationMessage, int minLength, int maxLength); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testValidate() { String pass = "1112332"; validator.validate(pass, validations, "testValidate"); assertFalse(validationHelper.hasErrors()); }
@Test public void testValidateInvalid() { String pass = ""; validator.validate(pass, validations, "testValidateInvalid"); assertTrue(validationHelper.hasErrors()); assertEquals(new Integer(1), new Integer(validationHelper.getAllValidations().size())); Validation validation = validations.get(0); assertNotNull(validation); assertEquals(ValidationScope.MAPPING, validation.getScope()); assertEquals("testValidateInvalid", validation.getId()); assertTrue("Must be of this length".equals(validation.getMessage())); } |
### Question:
NonNullValidator implements AtlasValidator { @Override public boolean supports(Class<?> clazz) { return true; } NonNullValidator(ValidationScope scope, String violationMessage); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testSupports() { assertTrue(validator.supports(String.class)); assertTrue(validator.supports(Integer.class)); assertTrue(validator.supports(Double.class)); } |
### Question:
NonNullValidator implements AtlasValidator { @Override public void validate(Object target, List<Validation> validations, String id) { validate(target, validations, id, ValidationStatus.ERROR); } NonNullValidator(ValidationScope scope, String violationMessage); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testValidate() { String notNull = "notNull"; validator.validate(notNull, validations, null); assertFalse(validationHelper.hasErrors()); }
@Test public void testValidateInvalid() { validator.validate(null, validations, null); assertTrue(validationHelper.hasErrors()); assertEquals(new Integer(1), new Integer(validationHelper.getCount())); Validation validation = validationHelper.getAllValidations().get(0); assertNotNull(validation); assertTrue("Cannot be null".equals(validation.getMessage())); assertEquals(ValidationScope.MAPPING, validation.getScope()); assertNull(validation.getId()); String empty = ""; validationHelper.getAllValidations().clear(); validator.validate(empty, validations, "testValidateInvalid-2"); assertTrue(validationHelper.hasErrors()); assertEquals(new Integer(1), new Integer(validationHelper.getCount())); assertEquals(ValidationScope.MAPPING, validationHelper.getValidation().get(0).getScope()); assertEquals("testValidateInvalid-2", validationHelper.getValidation().get(0).getId()); } |
### Question:
PositiveIntegerValidator implements AtlasValidator { @Override public boolean supports(Class<?> clazz) { return Integer.class.isAssignableFrom(clazz) || String.class.isAssignableFrom(clazz); } PositiveIntegerValidator(ValidationScope scope, String violationMessage); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testSupported() { assertTrue(validator.supports(Integer.class)); assertTrue(validator.supports(String.class)); }
@Test public void testUnsupported() { assertFalse(validator.supports(Boolean.class)); } |
### Question:
PositiveIntegerValidator implements AtlasValidator { @Override public void validate(Object target, List<Validation> validations, String id) { this.validate(target, validations, id, ValidationStatus.ERROR); } PositiveIntegerValidator(ValidationScope scope, String violationMessage); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, List<Validation> validations, String id); @Override void validate(Object target, List<Validation> validations, String id, ValidationStatus status); }### Answer:
@Test public void testValidate() { validator.validate(0, validations, null); validator.validate(1222, validations, null); assertFalse(validationHelper.hasErrors()); }
@Test public void testValidateInvalid() { validator.validate(-1, validations, "testValidateInvalid"); assertTrue(validationHelper.hasErrors()); assertEquals(new Integer(1), new Integer(validationHelper.getCount())); assertEquals("testValidateInvalid", validationHelper.getValidation().get(0).getId()); }
@Test public void testValidateInvalidWarn() { validator.validate(-1, validations, "testValidateInvalidWarn", ValidationStatus.WARN); assertFalse(validationHelper.hasErrors()); assertTrue(validationHelper.hasWarnings()); assertEquals(new Integer(1), new Integer(validationHelper.getCount())); assertEquals("testValidateInvalidWarn", validationHelper.getValidation().get(0).getId()); }
@Test public void testValidateInvalidInfo() { validator.validate(-1, validations, "testValidateInvalidInfo", ValidationStatus.INFO); assertFalse(validationHelper.hasErrors()); assertFalse(validationHelper.hasWarnings()); assertTrue(validationHelper.hasInfos()); assertEquals(new Integer(1), new Integer(validationHelper.getCount())); assertEquals("testValidateInvalidInfo", validationHelper.getValidation().get(0).getId()); }
@Test public void testValidateWithErrorLevel() { validator.validate(0, validations, "testValidateWithErrorLevel", ValidationStatus.WARN); assertFalse(validationHelper.hasErrors()); assertFalse(validationHelper.hasWarnings()); assertFalse(validationHelper.hasInfos()); } |
### Question:
AtlasPath { public SegmentContext getLastSegmentParent() { if (this.segmentContexts.isEmpty() || this.segmentContexts.size() == 1) { return null; } return this.segmentContexts.get(this.segmentContexts.size() - 2); } AtlasPath(String p); protected AtlasPath(List<SegmentContext> segments); private AtlasPath(); static Field extractChildren(Field f, String path); static void setCollectionIndexRecursively(FieldGroup group, int segmentIndex, int index); AtlasPath appendField(String fieldExpression); List<SegmentContext> getSegments(boolean includeRoot); Boolean isRoot(); SegmentContext getRootSegment(); Boolean isCollectionRoot(); Boolean hasCollectionRoot(); SegmentContext getLastSegment(); SegmentContext getLastCollectionSegment(); SegmentContext getLastSegmentParent(); AtlasPath getLastSegmentParentPath(); SegmentContext getParentSegmentOf(SegmentContext sc); boolean hasCollection(); boolean isIndexedCollection(); SegmentContext setCollectionIndex(int segmentIndex, Integer collectionIndex); List<SegmentContext> getCollectionSegments(boolean includeRoot); SegmentContext setVacantCollectionIndex(Integer collectionIndex); String getSegmentPath(SegmentContext sc); @Override String toString(); String getOriginalPath(); int getCollectionSegmentCount(); static final String PATH_SEPARATOR; static final char PATH_SEPARATOR_CHAR; static final String PATH_SEPARATOR_ESCAPED; static final String PATH_ARRAY_START; static final String PATH_ARRAY_END; static final String PATH_LIST_START; static final String PATH_LIST_END; static final String PATH_MAP_START; static final String PATH_MAP_END; static final String PATH_ATTRIBUTE_PREFIX; static final String PATH_NAMESPACE_SEPARATOR; }### Answer:
@Test public void testGetLastSegmentParent() { AtlasPath p = new AtlasPath("/orders/contact/firstName"); assertEquals("contact", p.getLastSegmentParent().getName()); assertTrue(new AtlasPath("orders").getLastSegmentParent().isRoot()); } |
### Question:
AtlasPath { public SegmentContext getLastSegment() { return this.segmentContexts.get(this.segmentContexts.size()-1); } AtlasPath(String p); protected AtlasPath(List<SegmentContext> segments); private AtlasPath(); static Field extractChildren(Field f, String path); static void setCollectionIndexRecursively(FieldGroup group, int segmentIndex, int index); AtlasPath appendField(String fieldExpression); List<SegmentContext> getSegments(boolean includeRoot); Boolean isRoot(); SegmentContext getRootSegment(); Boolean isCollectionRoot(); Boolean hasCollectionRoot(); SegmentContext getLastSegment(); SegmentContext getLastCollectionSegment(); SegmentContext getLastSegmentParent(); AtlasPath getLastSegmentParentPath(); SegmentContext getParentSegmentOf(SegmentContext sc); boolean hasCollection(); boolean isIndexedCollection(); SegmentContext setCollectionIndex(int segmentIndex, Integer collectionIndex); List<SegmentContext> getCollectionSegments(boolean includeRoot); SegmentContext setVacantCollectionIndex(Integer collectionIndex); String getSegmentPath(SegmentContext sc); @Override String toString(); String getOriginalPath(); int getCollectionSegmentCount(); static final String PATH_SEPARATOR; static final char PATH_SEPARATOR_CHAR; static final String PATH_SEPARATOR_ESCAPED; static final String PATH_ARRAY_START; static final String PATH_ARRAY_END; static final String PATH_LIST_START; static final String PATH_LIST_END; static final String PATH_MAP_START; static final String PATH_MAP_END; static final String PATH_ATTRIBUTE_PREFIX; static final String PATH_NAMESPACE_SEPARATOR; }### Answer:
@Test public void testGetLastSegment() { AtlasPath p = new AtlasPath("/order/contact/firstName"); assertEquals("firstName", p.getLastSegment().getName()); assertEquals("firstName", p.getLastSegment().getExpression()); assertTrue((new AtlasPath("")).getLastSegment().isRoot()); assertNotNull(p.getOriginalPath()); } |
### Question:
AtlasPath { public boolean hasCollection() { for (SegmentContext sc : this.segmentContexts) { if (sc.getCollectionType() != CollectionType.NONE) { return true; } } return false; } AtlasPath(String p); protected AtlasPath(List<SegmentContext> segments); private AtlasPath(); static Field extractChildren(Field f, String path); static void setCollectionIndexRecursively(FieldGroup group, int segmentIndex, int index); AtlasPath appendField(String fieldExpression); List<SegmentContext> getSegments(boolean includeRoot); Boolean isRoot(); SegmentContext getRootSegment(); Boolean isCollectionRoot(); Boolean hasCollectionRoot(); SegmentContext getLastSegment(); SegmentContext getLastCollectionSegment(); SegmentContext getLastSegmentParent(); AtlasPath getLastSegmentParentPath(); SegmentContext getParentSegmentOf(SegmentContext sc); boolean hasCollection(); boolean isIndexedCollection(); SegmentContext setCollectionIndex(int segmentIndex, Integer collectionIndex); List<SegmentContext> getCollectionSegments(boolean includeRoot); SegmentContext setVacantCollectionIndex(Integer collectionIndex); String getSegmentPath(SegmentContext sc); @Override String toString(); String getOriginalPath(); int getCollectionSegmentCount(); static final String PATH_SEPARATOR; static final char PATH_SEPARATOR_CHAR; static final String PATH_SEPARATOR_ESCAPED; static final String PATH_ARRAY_START; static final String PATH_ARRAY_END; static final String PATH_LIST_START; static final String PATH_LIST_END; static final String PATH_MAP_START; static final String PATH_MAP_END; static final String PATH_ATTRIBUTE_PREFIX; static final String PATH_NAMESPACE_SEPARATOR; }### Answer:
@Test public void testHasCollection() { AtlasPath p = new AtlasPath("/order/contact/firstName"); assertFalse(p.hasCollection()); } |
### Question:
AtlasPath { public Boolean isCollectionRoot() { return this.segmentContexts.size() == 1 && this.segmentContexts.get(0).getCollectionType() != CollectionType.NONE; } AtlasPath(String p); protected AtlasPath(List<SegmentContext> segments); private AtlasPath(); static Field extractChildren(Field f, String path); static void setCollectionIndexRecursively(FieldGroup group, int segmentIndex, int index); AtlasPath appendField(String fieldExpression); List<SegmentContext> getSegments(boolean includeRoot); Boolean isRoot(); SegmentContext getRootSegment(); Boolean isCollectionRoot(); Boolean hasCollectionRoot(); SegmentContext getLastSegment(); SegmentContext getLastCollectionSegment(); SegmentContext getLastSegmentParent(); AtlasPath getLastSegmentParentPath(); SegmentContext getParentSegmentOf(SegmentContext sc); boolean hasCollection(); boolean isIndexedCollection(); SegmentContext setCollectionIndex(int segmentIndex, Integer collectionIndex); List<SegmentContext> getCollectionSegments(boolean includeRoot); SegmentContext setVacantCollectionIndex(Integer collectionIndex); String getSegmentPath(SegmentContext sc); @Override String toString(); String getOriginalPath(); int getCollectionSegmentCount(); static final String PATH_SEPARATOR; static final char PATH_SEPARATOR_CHAR; static final String PATH_SEPARATOR_ESCAPED; static final String PATH_ARRAY_START; static final String PATH_ARRAY_END; static final String PATH_LIST_START; static final String PATH_LIST_END; static final String PATH_MAP_START; static final String PATH_MAP_END; static final String PATH_ATTRIBUTE_PREFIX; static final String PATH_NAMESPACE_SEPARATOR; }### Answer:
@Test public void testIsCollectionRoot() { AtlasPath p = new AtlasPath("/order/contact/firstName"); assertFalse(p.isCollectionRoot()); p = new AtlasPath("/order/contact/phone<>"); assertFalse(p.isCollectionRoot()); p = new AtlasPath("/order<>/contact/phone"); assertFalse(p.isCollectionRoot()); p = new AtlasPath("/<>/order/contact/phone"); assertFalse(p.isCollectionRoot()); } |
### Question:
DefaultAtlasContext implements AtlasContext, AtlasContextMXBean { @Override public AtlasSession createSession() throws AtlasException { init(); return doCreateSession(); } DefaultAtlasContext(URI atlasMappingUri); DefaultAtlasContext(DefaultAtlasContextFactory factory, URI atlasMappingUri); DefaultAtlasContext(DefaultAtlasContextFactory factory, AtlasMapping mapping); DefaultAtlasContext(DefaultAtlasContextFactory factory,
AtlasContextFactory.Format format, InputStream stream); @Override Audits processPreview(Mapping mapping); @Override void process(AtlasSession userSession); @Override void processValidation(AtlasSession userSession); @Override AtlasContextFactory getContextFactory(); AtlasMapping getMapping(); @Override AtlasSession createSession(); AtlasSession createSession(AtlasMapping mappingDefinition); Map<String, AtlasModule> getSourceModules(); void setSourceModules(Map<String, AtlasModule> sourceModules); Map<String, AtlasModule> getTargetModules(); void setTargetModules(Map<String, AtlasModule> targetModules); Map<String, LookupTable> getLookupTables(); void setLookupTables(Map<String, LookupTable> lookupTables); ObjectName getJmxObjectName(); @Override String getUuid(); @Override String getVersion(); @Override String getMappingName(); @Override String getMappingUri(); @Override String getClassName(); @Override String getThreadName(); @Override String toString(); ADMArchiveHandler getADMArchiveHandler(); static final String CONSTANTS_DOCUMENT_ID; static final String PROPERTIES_DOCUMENT_ID; }### Answer:
@Test public void testCreateSession() throws Exception { assertNotNull(context.createSession(mapping)); File file = Paths.get( "src" + File.separator + "test" + File.separator + "resources" + File.separator + "atlasmapping.json") .toFile(); DefaultAtlasContext ctx = new DefaultAtlasContext(file.toURI()); assertNotNull(ctx.createSession()); } |
### Question:
DefaultAtlasModuleInfoRegistry implements AtlasModuleInfoRegistry { public DefaultAtlasModuleInfoRegistry(DefaultAtlasContextFactory factory) { jmxObjectNamePrefix = factory.getJmxObjectName() + ",modules=AvailableModules,moduleName="; } DefaultAtlasModuleInfoRegistry(DefaultAtlasContextFactory factory); @Override AtlasModuleInfo lookupByUri(String uri); @Override Set<AtlasModuleInfo> getAll(); @Override void register(AtlasModuleInfo module); @Override int size(); @Override synchronized void unregisterAll(); }### Answer:
@Test public void testDefaultAtlasModuleInfoRegistry() { assertNotNull(atlasModuleInfoRegistry); } |
### Question:
DefaultAtlasModuleInfoRegistry implements AtlasModuleInfoRegistry { @Override public AtlasModuleInfo lookupByUri(String uri) { if (uri == null) { return null; } for (AtlasModuleInfo module : moduleInfos) { if (uri.startsWith(module.getUri())) { return module; } } return null; } DefaultAtlasModuleInfoRegistry(DefaultAtlasContextFactory factory); @Override AtlasModuleInfo lookupByUri(String uri); @Override Set<AtlasModuleInfo> getAll(); @Override void register(AtlasModuleInfo module); @Override int size(); @Override synchronized void unregisterAll(); }### Answer:
@Test public void testLookupByUri() { assertNull(atlasModuleInfoRegistry.lookupByUri(null)); List<String> formats = new ArrayList<>(); formats.add("java"); List<String> packageNames = new ArrayList<>(); packageNames.add("io.atlasmap.core"); DefaultAtlasModuleInfo atlasModuleInfo = new DefaultAtlasModuleInfo("name", "atlas:java", AtlasModule.class, null, formats, packageNames); atlasModuleInfoRegistry.register(atlasModuleInfo); assertNotNull(atlasModuleInfoRegistry.lookupByUri("atlas:java")); assertNull(atlasModuleInfoRegistry.lookupByUri("java")); } |
### Question:
DefaultAtlasModuleInfoRegistry implements AtlasModuleInfoRegistry { @Override public Set<AtlasModuleInfo> getAll() { return Collections.unmodifiableSet(moduleInfos); } DefaultAtlasModuleInfoRegistry(DefaultAtlasContextFactory factory); @Override AtlasModuleInfo lookupByUri(String uri); @Override Set<AtlasModuleInfo> getAll(); @Override void register(AtlasModuleInfo module); @Override int size(); @Override synchronized void unregisterAll(); }### Answer:
@Test public void testGetAll() { assertNotNull(atlasModuleInfoRegistry.getAll()); } |
### Question:
DefaultAtlasModuleInfoRegistry implements AtlasModuleInfoRegistry { @Override public void register(AtlasModuleInfo module) { moduleInfos.add(module); registerModuleJmx(module); } DefaultAtlasModuleInfoRegistry(DefaultAtlasContextFactory factory); @Override AtlasModuleInfo lookupByUri(String uri); @Override Set<AtlasModuleInfo> getAll(); @Override void register(AtlasModuleInfo module); @Override int size(); @Override synchronized void unregisterAll(); }### Answer:
@Test public void testRegister() { List<String> formats = new ArrayList<>(); formats.add("java"); List<String> packageNames = new ArrayList<>(); packageNames.add("io.atlasmap.core"); DefaultAtlasModuleInfo atlasModuleInfo = new DefaultAtlasModuleInfo("name", "atlas:java", AtlasModule.class, null, formats, packageNames); atlasModuleInfoRegistry.register(atlasModuleInfo); assertEquals(1, atlasModuleInfoRegistry.size()); } |
### Question:
DefaultAtlasModuleInfoRegistry implements AtlasModuleInfoRegistry { @Override public int size() { return moduleInfos.size(); } DefaultAtlasModuleInfoRegistry(DefaultAtlasContextFactory factory); @Override AtlasModuleInfo lookupByUri(String uri); @Override Set<AtlasModuleInfo> getAll(); @Override void register(AtlasModuleInfo module); @Override int size(); @Override synchronized void unregisterAll(); }### Answer:
@Test public void testSize() { assertEquals(0, atlasModuleInfoRegistry.size()); } |
### Question:
DefaultAtlasModuleInfoRegistry implements AtlasModuleInfoRegistry { @Override public synchronized void unregisterAll() { for (AtlasModuleInfo info : moduleInfos) { unregisterModuleJmx(info); } moduleInfos.clear(); } DefaultAtlasModuleInfoRegistry(DefaultAtlasContextFactory factory); @Override AtlasModuleInfo lookupByUri(String uri); @Override Set<AtlasModuleInfo> getAll(); @Override void register(AtlasModuleInfo module); @Override int size(); @Override synchronized void unregisterAll(); }### Answer:
@Test public void testUnregisterAll() { atlasModuleInfoRegistry.unregisterAll(); assertEquals(0, atlasModuleInfoRegistry.size()); } |
### Question:
DefaultAtlasCombineStrategy implements AtlasCombineStrategy { @Override public String combineValues(Map<Integer, String> values) { return combineValues(values, getDelimiter(), getLimit()); } @Override StringDelimiter getDelimiter(); @Override void setDelimiter(StringDelimiter delimiter); @Override Integer getLimit(); @Override void setLimit(Integer limit); boolean isDisableAutoTrim(); void setDisableAutoTrim(boolean disableAutoTrim); boolean isDisableAddDelimiterOnNull(); void setDisableAddDelimiterOnNull(boolean disableAddDelimiterOnNull); @Override String combineValues(Map<Integer, String> values); @Override String combineValues(Map<Integer, String> values, StringDelimiter delimiter); @Override String combineValues(Map<Integer, String> values, StringDelimiter delimiter, Integer limit); @Override String combineValues(Map<Integer, String> values, String delimiter); static final StringDelimiter DEFAULT_COMBINE_DELIMITER; static final Integer DEFAULT_COMBINE_LIMIT; }### Answer:
@Test public void testCombineSingleValue() { assertNotNull(combine); String value = combine.combineValues(generateCombineMap(1)); assertNotNull(value); assertEquals("a", value); }
@Test public void testCombineValues() { assertNotNull(combine); String value = combine.combineValues(generateCombineMap(6)); assertNotNull(value); assertEquals("a b c d e f", value); }
@Test public void testSeparateValuesNullValue() { assertNotNull(combine); String value = combine.combineValues(null); assertNull(value); }
@Test public void testCombineValuesEmptyValue() { assertNotNull(combine); String value = combine.combineValues(new HashMap<Integer, String>()); assertNull(value); } |
### Question:
DefaultAtlasContextFactory implements AtlasContextFactory, AtlasContextFactoryMXBean { protected String getModuleName(Class<?> clazz) { AtlasModuleDetail detail = clazz.getAnnotation(AtlasModuleDetail.class); if (detail != null) { return detail.name(); } return "UNDEFINED-" + UUID.randomUUID().toString(); } private DefaultAtlasContextFactory(); static DefaultAtlasContextFactory getInstance(); @Override synchronized void init(); synchronized void init(CompoundClassLoader cl); @Override void setProperties(Map<String, String> properties); @Override void setProperties(Properties properties); @Override Map<String, String> getProperties(); @Override synchronized void destroy(); @Override AtlasContext createContext(File atlasMappingFile); @Override AtlasContext createContext(URI atlasMappingUri); AtlasContext createContext(AtlasMapping mapping); @Override AtlasContext createContext(Format format, InputStream stream); @Override String getClassName(); @Override String getThreadName(); void setThreadName(String threadName); @Override String getVersion(); @Override String getUuid(); ObjectName getJmxObjectName(); AtlasModuleInfoRegistry getModuleInfoRegistry(); void setModuleInfoRegistry(AtlasModuleInfoRegistry registry); @Override AtlasConversionService getConversionService(); @Override AtlasFieldActionService getFieldActionService(); @Override AtlasCombineStrategy getCombineStrategy(); void setCombineStrategy(AtlasCombineStrategy atlasCombineStrategy); @Override AtlasPropertyStrategy getPropertyStrategy(); @Override void setPropertyStrategy(AtlasPropertyStrategy atlasPropertyStrategy); @Override AtlasSeparateStrategy getSeparateStrategy(); void setSeparateStrategy(AtlasSeparateStrategy atlasSeparateStrategy); @Override AtlasValidationService getValidationService(); void setValidationService(AtlasValidationService atlasValidationService); CompoundClassLoader getClassLoader(); @Override void addClassLoader(ClassLoader cl); void setClassLoader(CompoundClassLoader cl); }### Answer:
@Test public void testGetModuleName() { factory = DefaultAtlasContextFactory.getInstance(); assertNotNull(factory.getModuleName(Object.class)); } |
### Question:
DefaultAtlasContextFactory implements AtlasContextFactory, AtlasContextFactoryMXBean { protected String getModuleUri(Class<?> clazz) { AtlasModuleDetail detail = clazz.getAnnotation(AtlasModuleDetail.class); if (detail != null) { return detail.uri(); } return "UNDEFINED"; } private DefaultAtlasContextFactory(); static DefaultAtlasContextFactory getInstance(); @Override synchronized void init(); synchronized void init(CompoundClassLoader cl); @Override void setProperties(Map<String, String> properties); @Override void setProperties(Properties properties); @Override Map<String, String> getProperties(); @Override synchronized void destroy(); @Override AtlasContext createContext(File atlasMappingFile); @Override AtlasContext createContext(URI atlasMappingUri); AtlasContext createContext(AtlasMapping mapping); @Override AtlasContext createContext(Format format, InputStream stream); @Override String getClassName(); @Override String getThreadName(); void setThreadName(String threadName); @Override String getVersion(); @Override String getUuid(); ObjectName getJmxObjectName(); AtlasModuleInfoRegistry getModuleInfoRegistry(); void setModuleInfoRegistry(AtlasModuleInfoRegistry registry); @Override AtlasConversionService getConversionService(); @Override AtlasFieldActionService getFieldActionService(); @Override AtlasCombineStrategy getCombineStrategy(); void setCombineStrategy(AtlasCombineStrategy atlasCombineStrategy); @Override AtlasPropertyStrategy getPropertyStrategy(); @Override void setPropertyStrategy(AtlasPropertyStrategy atlasPropertyStrategy); @Override AtlasSeparateStrategy getSeparateStrategy(); void setSeparateStrategy(AtlasSeparateStrategy atlasSeparateStrategy); @Override AtlasValidationService getValidationService(); void setValidationService(AtlasValidationService atlasValidationService); CompoundClassLoader getClassLoader(); @Override void addClassLoader(ClassLoader cl); void setClassLoader(CompoundClassLoader cl); }### Answer:
@Test public void testGetModuleUri() { factory = DefaultAtlasContextFactory.getInstance(); assertEquals("UNDEFINED", factory.getModuleUri(Object.class)); } |
### Question:
ConstantModule implements AtlasModule { @Override public void destroy() { } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testDestroy() { module.destroy(); } |
### Question:
ConstantModule implements AtlasModule { @Override public void processPreValidation(AtlasInternalSession session) throws AtlasException { } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testProcessPreValidation() throws AtlasException { module.processPreValidation(null); } |
### Question:
ConstantModule implements AtlasModule { @Override public void processPreSourceExecution(AtlasInternalSession session) throws AtlasException { } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testProcessPreSourceExecution() throws AtlasException { module.processPreSourceExecution(null); } |
### Question:
ConstantModule implements AtlasModule { @Override public void processPostSourceExecution(AtlasInternalSession session) throws AtlasException { } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testProcessPostSourceExecution() throws AtlasException { module.processPostSourceExecution(null); } |
### Question:
ConstantModule implements AtlasModule { @Override public void processPreTargetExecution(AtlasInternalSession session) throws AtlasException { throw new UnsupportedOperationException("ConstantField cannot be placed as a target field"); } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testProcessPreTargetExecution() throws AtlasException { module.processPreTargetExecution(null); } |
### Question:
ConstantModule implements AtlasModule { @Override public void writeTargetValue(AtlasInternalSession session) throws AtlasException { throw new UnsupportedOperationException("ConstantField cannot be placed as a target field"); } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testProcessTargetFieldMapping() throws AtlasException { module.writeTargetValue(null); } |
### Question:
ConstantModule implements AtlasModule { @Override public void processPostTargetExecution(AtlasInternalSession session) throws AtlasException { throw new UnsupportedOperationException("ConstantField cannot be placed as a target field"); } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testProcessPostTargetExecution() throws AtlasException { module.processPostTargetExecution(null); } |
### Question:
ConstantModule implements AtlasModule { @Override public void processPostValidation(AtlasInternalSession session) throws AtlasException { } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testProcessPostValidation() throws AtlasException { module.processPostValidation(null); } |
### Question:
ConstantModule implements AtlasModule { @Override public AtlasModuleMode getMode() { return AtlasModuleMode.SOURCE; } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testGetMode() { assertNotNull(module.getMode()); } |
### Question:
ConstantModule implements AtlasModule { @Override public AtlasConversionService getConversionService() { return this.conversionService; } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testGetConversionService() { assertNotNull(module.getConversionService()); } |
### Question:
ConstantModule implements AtlasModule { @Override public List<AtlasModuleMode> listSupportedModes() { return Arrays.asList(new AtlasModuleMode[] { AtlasModuleMode.SOURCE }); } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testListSupportedModes() { assertNotNull(module.listSupportedModes()); } |
### Question:
ConstantModule implements AtlasModule { @Override public String getDocId() { return null; } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testGetDocId() { assertNull(module.getDocId()); } |
### Question:
ConstantModule implements AtlasModule { @Override public String getUri() { return null; } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testGetUri() { assertNull(module.getUri()); } |
### Question:
ConstantModule implements AtlasModule { @Override public Boolean isStatisticsSupported() { return false; } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testIsStatisticsSupported() { assertFalse(module.isStatisticsSupported()); } |
### Question:
ConstantModule implements AtlasModule { @Override public Boolean isStatisticsEnabled() { return false; } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testIsStatisticsEnabled() { assertFalse(module.isStatisticsEnabled()); } |
### Question:
ConstantModule implements AtlasModule { @Override public Boolean isSupportedField(Field field) { return field instanceof ConstantField; } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testIsSupportedField() { assertFalse(module.isSupportedField(new MockField())); } |
### Question:
ConstantModule implements AtlasModule { @Override public Field cloneField(Field field) throws AtlasException { return null; } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testCloneField() throws AtlasException { assertNull(module.cloneField(new MockField())); } |
### Question:
ConstantModule implements AtlasModule { @Override public AtlasFieldActionService getFieldActionService() { return this.fieldActionService; } @Override void init(); @Override void destroy(); @Override void setClassLoader(ClassLoader classLoader); @Override ClassLoader getClassLoader(); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void populateTargetField(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override AtlasModuleMode getMode(); @Override void setMode(AtlasModuleMode atlasModuleMode); @Override AtlasConversionService getConversionService(); @Override void setConversionService(AtlasConversionService atlasConversionService); @Override List<AtlasModuleMode> listSupportedModes(); @Override String getDocId(); @Override void setDocId(String docId); @Override String getUri(); @Override void setUri(String uri); @Override Boolean isStatisticsSupported(); @Override Boolean isStatisticsEnabled(); @Override Boolean isSupportedField(Field field); @Override Field cloneField(Field field); @Override AtlasFieldActionService getFieldActionService(); @Override void setFieldActionService(AtlasFieldActionService atlasFieldActionService); AtlasCollectionHelper getCollectionHelper(); @Override String getUriDataType(); @Override Map<String, String> getUriParameters(); @Override void setDataSourceMetadata(DataSourceMetadata meta); @Override DataSourceMetadata getDataSourceMetadata(); }### Answer:
@Test public void testGetFieldActionService() { assertNull(module.getFieldActionService()); } |
### Question:
DefaultAtlasConversionService implements AtlasConversionService { public static DefaultAtlasConversionService getInstance() { DefaultAtlasConversionService result = instance; if (result == null) { synchronized (SINGLETON_LOCK) { result = instance; if (result == null) { result = new DefaultAtlasConversionService(); result.init(); instance = result; } } } return result; } private DefaultAtlasConversionService(); static DefaultAtlasConversionService getInstance(); static Set<String> listPrimitiveClassNames(); @Override Optional<AtlasConverter<?>> findMatchingConverter(FieldType source, FieldType target); @Override Optional<AtlasConverter<?>> findMatchingConverter(String sourceClassName, String targetClassName); @Override Object copyPrimitive(Object sourceValue); @Override Object convertType(Object sourceValue, FieldType origSourceType, FieldType targetType); @Override Object convertType(Object sourceValue, String sourceFormat, FieldType targetType, String targetFormat); @Override Object convertType(Object sourceValue, String sourceFormat, Class<?> targetType, String targetFormat); @Override boolean isConvertionAvailableFor(Object sourceValue, Class<?> targetType); @Override Boolean isPrimitive(String className); @Override Boolean isPrimitive(Class<?> clazz); @Override Boolean isPrimitive(FieldType fieldType); @Override Boolean isBoxedPrimitive(Class<?> clazz); @Override Class<?> boxOrUnboxPrimitive(String clazzName); @Override Class<?> boxOrUnboxPrimitive(Class<?> clazz); @Override FieldType fieldTypeFromClass(Class<?> clazz); @Override FieldType fieldTypeFromClass(String className); @Override Class<?> classFromFieldType(FieldType fieldType); @Override Boolean isAssignableFieldType(FieldType source, FieldType target); }### Answer:
@Test public void getservice() { assertNotNull(service); DefaultAtlasConversionService service2 = DefaultAtlasConversionService.getInstance(); assertNotNull(service2); assertSame(service, service2); } |
### Question:
DefaultAtlasConversionService implements AtlasConversionService { public static Set<String> listPrimitiveClassNames() { return PRIMITIVE_CLASSNAMES; } private DefaultAtlasConversionService(); static DefaultAtlasConversionService getInstance(); static Set<String> listPrimitiveClassNames(); @Override Optional<AtlasConverter<?>> findMatchingConverter(FieldType source, FieldType target); @Override Optional<AtlasConverter<?>> findMatchingConverter(String sourceClassName, String targetClassName); @Override Object copyPrimitive(Object sourceValue); @Override Object convertType(Object sourceValue, FieldType origSourceType, FieldType targetType); @Override Object convertType(Object sourceValue, String sourceFormat, FieldType targetType, String targetFormat); @Override Object convertType(Object sourceValue, String sourceFormat, Class<?> targetType, String targetFormat); @Override boolean isConvertionAvailableFor(Object sourceValue, Class<?> targetType); @Override Boolean isPrimitive(String className); @Override Boolean isPrimitive(Class<?> clazz); @Override Boolean isPrimitive(FieldType fieldType); @Override Boolean isBoxedPrimitive(Class<?> clazz); @Override Class<?> boxOrUnboxPrimitive(String clazzName); @Override Class<?> boxOrUnboxPrimitive(Class<?> clazz); @Override FieldType fieldTypeFromClass(Class<?> clazz); @Override FieldType fieldTypeFromClass(String className); @Override Class<?> classFromFieldType(FieldType fieldType); @Override Boolean isAssignableFieldType(FieldType source, FieldType target); }### Answer:
@Test public void testListPrimitiveClassNames() { assertNotNull(DefaultAtlasConversionService.listPrimitiveClassNames()); } |
### Question:
CsvModule extends BaseAtlasModule { @Override public Boolean isSupportedField(Field field) { return field instanceof CsvField || field instanceof FieldGroup; } @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override Field cloneField(Field field); @Override Boolean isSupportedField(Field field); }### Answer:
@Test public void testIsSupportedField() { assertFalse(module.isSupportedField(new PropertyField())); assertFalse(module.isSupportedField(new ConstantField())); assertTrue(module.isSupportedField(new CsvField())); } |
### Question:
AtlasUtil { public static boolean isEmpty(String string) { return string == null || string.isEmpty() || string.matches("^\\s+$"); } static Properties loadPropertiesFromURL(URL url); static boolean isEmpty(String string); static boolean matchUriModule(String uriA, String uriB); static String getUriScheme(String atlasUri); static String getUriModule(String atlasUri); static String getUriDataType(String atlasUri); static String getUriModuleVersion(String atlasUri); static String getUriParameterValue(String atlasUri, String key); static Map<String, String> getUriParameters(String atlasUri); static int countCharacters(String text, char match); static List<Class<?>> findClassesForPackage(String scannedPackage); static void addAudit(AtlasSession session, String docId, String message, String path, AuditStatus status,
String value); static Audit createAudit(AuditStatus status, String docId, String docName, String path, String value, String message); static void addAudit(AtlasSession session, Validation validation); static void addAudits(AtlasInternalSession session, String docId, List<Audit> audits); static AuditStatus toAuditStatus(ValidationStatus vstatus); static String getDocumentNameById(AtlasMapping mapping, String docId); static String getChainedMessage(Throwable t); static String escapeForUri(String source); static String unescapeFromUri(String uri); static void deleteDirectory(File targetDir); static void deleteDirectoryContents(File targetDir); static void copyFile(Path sourcePath, Path destPath); static final int SPLIT_LIMIT; static final String NEW_LINE_CHARS; }### Answer:
@Test public void testIsEmpty() { assertTrue(AtlasUtil.isEmpty(null)); assertTrue(AtlasUtil.isEmpty("")); assertTrue(AtlasUtil.isEmpty(" ")); assertTrue(AtlasUtil.isEmpty("\n\n")); assertTrue(AtlasUtil.isEmpty("\t\t")); assertTrue(AtlasUtil.isEmpty("\r\n")); assertTrue(AtlasUtil.isEmpty("\f\t\n\r")); assertFalse(AtlasUtil.isEmpty("\b")); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.