method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
Http2SettingsFrameHandler extends SimpleChannelInboundHandler<Http2SettingsFrame> { @Override protected void channelRead0(ChannelHandlerContext ctx, Http2SettingsFrame msg) { Long serverMaxStreams = Optional.ofNullable(msg.settings().maxConcurrentStreams()).orElse(Long.MAX_VALUE); channel.attr(MAX_CONCURRENT_STREAMS).set(Math.min(clientMaxStreams, serverMaxStreams)); channel.attr(PROTOCOL_FUTURE).get().complete(Protocol.HTTP2); } Http2SettingsFrameHandler(Channel channel, long clientMaxStreams, AtomicReference<ChannelPool> channelPoolRef); @Override void channelUnregistered(ChannelHandlerContext ctx); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); }### Answer:
@Test public void channelRead_useServerMaxStreams() { long serverMaxStreams = 50L; Http2SettingsFrame http2SettingsFrame = http2SettingsFrame(serverMaxStreams); handler.channelRead0(context, http2SettingsFrame); assertThat(channel.attr(MAX_CONCURRENT_STREAMS).get()).isEqualTo(serverMaxStreams); assertThat(protocolCompletableFuture).isDone(); assertThat(protocolCompletableFuture.join()).isEqualTo(Protocol.HTTP2); }
@Test public void channelRead_useClientMaxStreams() { long serverMaxStreams = 10000L; Http2SettingsFrame http2SettingsFrame = http2SettingsFrame(serverMaxStreams); handler.channelRead0(context, http2SettingsFrame); assertThat(channel.attr(MAX_CONCURRENT_STREAMS).get()).isEqualTo(clientMaxStreams); assertThat(protocolCompletableFuture).isDone(); assertThat(protocolCompletableFuture.join()).isEqualTo(Protocol.HTTP2); } |
### Question:
Http2SettingsFrameHandler extends SimpleChannelInboundHandler<Http2SettingsFrame> { @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { channelError(cause, channel, ctx); } Http2SettingsFrameHandler(Channel channel, long clientMaxStreams, AtomicReference<ChannelPool> channelPoolRef); @Override void channelUnregistered(ChannelHandlerContext ctx); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); }### Answer:
@Test public void exceptionCaught_shouldHandleErrorCloseChannel() throws Exception { Throwable cause = new Throwable(new RuntimeException("BOOM")); handler.exceptionCaught(context, cause); verifyChannelError(cause.getClass()); } |
### Question:
Http2SettingsFrameHandler extends SimpleChannelInboundHandler<Http2SettingsFrame> { @Override public void channelUnregistered(ChannelHandlerContext ctx) { if (!channel.attr(PROTOCOL_FUTURE).get().isDone()) { channelError(new IOException("The channel was closed before the protocol could be determined."), channel, ctx); } } Http2SettingsFrameHandler(Channel channel, long clientMaxStreams, AtomicReference<ChannelPool> channelPoolRef); @Override void channelUnregistered(ChannelHandlerContext ctx); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); }### Answer:
@Test public void channelUnregistered_ProtocolFutureNotDone_ShouldRaiseError() throws InterruptedException { handler.channelUnregistered(context); verifyChannelError(IOException.class); } |
### Question:
MultiplexedChannelRecord { boolean acquireStream(Promise<Channel> promise) { if (claimStream()) { releaseClaimOnFailure(promise); acquireClaimedStream(promise); return true; } return false; } MultiplexedChannelRecord(Channel connection, long maxConcurrencyPerConnection, Duration allowedIdleConnectionTime); Channel getConnection(); }### Answer:
@Test public void availableStream0_reusableShouldBeFalse() { loopGroup.register(channel).awaitUninterruptibly(); Promise<Channel> channelPromise = new DefaultPromise<>(loopGroup.next()); channelPromise.setSuccess(channel); MultiplexedChannelRecord record = new MultiplexedChannelRecord(channel, 0, Duration.ofSeconds(10)); assertThat(record.acquireStream(null)).isFalse(); } |
### Question:
HttpOrHttp2ChannelPool implements SdkChannelPool { @Override public void close() { doInEventLoop(eventLoop, this::close0); } HttpOrHttp2ChannelPool(ChannelPool delegatePool,
EventLoopGroup group,
int maxConcurrency,
NettyConfiguration configuration); @Override Future<Channel> acquire(); @Override Future<Channel> acquire(Promise<Channel> promise); @Override Future<Void> release(Channel channel); @Override Future<Void> release(Channel channel, Promise<Void> promise); @Override void close(); @Override CompletableFuture<Void> collectChannelPoolMetrics(MetricCollector metrics); }### Answer:
@Test public void protocolConfigNotStarted_closeSucceeds() { httpOrHttp2ChannelPool.close(); }
@Test public void protocolConfigNotStarted_closeClosesDelegatePool() throws InterruptedException { httpOrHttp2ChannelPool.close(); Thread.sleep(500); verify(mockDelegatePool).close(); } |
### Question:
Http2StreamExceptionHandler extends ChannelInboundHandlerAdapter { @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { if (isIoError(cause) && ctx.channel().parent() != null) { Channel parent = ctx.channel().parent(); log.debug(() -> "An I/O error occurred on an Http2 stream, notifying the connection channel " + parent); parent.pipeline().fireExceptionCaught(new Http2ConnectionTerminatingException("An I/O error occurred on an " + "associated Http2 " + "stream " + ctx.channel())); } ctx.fireExceptionCaught(cause); } private Http2StreamExceptionHandler(); static Http2StreamExceptionHandler create(); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); }### Answer:
@Test public void timeoutException_shouldFireExceptionAndPropagateException() { when(streamChannel.parent()).thenReturn(embeddedParentChannel); handler.exceptionCaught(context, ReadTimeoutException.INSTANCE); assertThat(verifyExceptionHandler.exceptionCaught).isExactlyInstanceOf(Http2ConnectionTerminatingException.class); verify(context).fireExceptionCaught(ReadTimeoutException.INSTANCE); }
@Test public void ioException_shouldFireExceptionAndPropagateException() { IOException ioException = new IOException("yolo"); when(streamChannel.parent()).thenReturn(embeddedParentChannel); handler.exceptionCaught(context, ioException); assertThat(verifyExceptionHandler.exceptionCaught).isExactlyInstanceOf(Http2ConnectionTerminatingException.class); verify(context).fireExceptionCaught(ioException); }
@Test public void otherException_shouldJustPropagateException() { when(streamChannel.parent()).thenReturn(embeddedParentChannel); RuntimeException otherException = new RuntimeException("test"); handler.exceptionCaught(context, otherException); assertThat(embeddedParentChannel.attr(PING_TRACKER).get()).isNull(); verify(context).fireExceptionCaught(otherException); assertThat(verifyExceptionHandler.exceptionCaught).isNull(); } |
### Question:
LastHttpContentHandler extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { if (msg instanceof LastHttpContent) { logger.debug(() -> "Received LastHttpContent " + ctx.channel()); ctx.channel().attr(LAST_HTTP_CONTENT_RECEIVED_KEY).set(true); } ctx.fireChannelRead(msg); } @Override void channelRead(ChannelHandlerContext ctx, Object msg); static LastHttpContentHandler create(); }### Answer:
@Test public void lastHttpContentReceived_shouldSetAttribute() { LastHttpContent lastHttpContent = LastHttpContent.EMPTY_LAST_CONTENT; contentHandler.channelRead(handlerContext, lastHttpContent); assertThat(channel.attr(LAST_HTTP_CONTENT_RECEIVED_KEY).get()).isTrue(); }
@Test public void otherContentReceived_shouldNotSetAttribute() { String content = "some content"; contentHandler.channelRead(handlerContext, content); assertThat(channel.attr(LAST_HTTP_CONTENT_RECEIVED_KEY).get()).isFalse(); } |
### Question:
HonorCloseOnReleaseChannelPool implements ChannelPool { @Override public Future<Void> release(Channel channel) { return release(channel, channel.eventLoop().newPromise()); } HonorCloseOnReleaseChannelPool(ChannelPool delegatePool); @Override Future<Channel> acquire(); @Override Future<Channel> acquire(Promise<Channel> promise); @Override Future<Void> release(Channel channel); @Override Future<Void> release(Channel channel, Promise<Void> promise); @Override void close(); }### Answer:
@Test public void releaseDoesntCloseIfNotFlagged() throws Exception { ChannelPool channelPool = Mockito.mock(ChannelPool.class); MockChannel channel = new MockChannel(); channel.attr(ChannelAttributeKey.CLOSE_ON_RELEASE).set(false); new HonorCloseOnReleaseChannelPool(channelPool).release(channel); channel.runAllPendingTasks(); assertThat(channel.isOpen()).isTrue(); Mockito.verify(channelPool, new Times(0)).release(any()); Mockito.verify(channelPool, new Times(1)).release(any(), any()); }
@Test public void releaseClosesIfFlagged() throws Exception { ChannelPool channelPool = Mockito.mock(ChannelPool.class); MockChannel channel = new MockChannel(); channel.attr(ChannelAttributeKey.CLOSE_ON_RELEASE).set(true); new HonorCloseOnReleaseChannelPool(channelPool).release(channel); channel.runAllPendingTasks(); assertThat(channel.isOpen()).isFalse(); Mockito.verify(channelPool, new Times(0)).release(any()); Mockito.verify(channelPool, new Times(1)).release(any(), any()); } |
### Question:
StaticKeyManagerFactorySpi extends KeyManagerFactorySpi { @Override protected KeyManager[] engineGetKeyManagers() { return keyManagers; } StaticKeyManagerFactorySpi(KeyManager[] keyManagers); }### Answer:
@Test public void constructorCreatesArrayCopy() { KeyManager[] keyManagers = IntStream.range(0,8) .mapToObj(i -> mock(KeyManager.class)) .toArray(KeyManager[]::new); KeyManager[] arg = Arrays.copyOf(keyManagers, keyManagers.length); StaticKeyManagerFactorySpi spi = new StaticKeyManagerFactorySpi(arg); for (int i = 0; i < keyManagers.length; ++i) { arg[i] = null; } assertThat(spi.engineGetKeyManagers()).containsExactly(keyManagers); }
@Test public void engineGetKeyManagers_returnsProvidedList() { KeyManager[] keyManagers = IntStream.range(0,8) .mapToObj(i -> mock(KeyManager.class)) .toArray(KeyManager[]::new); StaticKeyManagerFactorySpi spi = new StaticKeyManagerFactorySpi(keyManagers); assertThat(spi.engineGetKeyManagers()).containsExactly(keyManagers); } |
### Question:
StaticKeyManagerFactorySpi extends KeyManagerFactorySpi { @Override protected void engineInit(KeyStore ks, char[] password) { throw new UnsupportedOperationException("engineInit not supported by this KeyManagerFactory"); } StaticKeyManagerFactorySpi(KeyManager[] keyManagers); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void engineInit_storeAndPasswords_throws() { StaticKeyManagerFactorySpi staticKeyManagerFactorySpi = new StaticKeyManagerFactorySpi(new KeyManager[0]); staticKeyManagerFactorySpi.engineInit(null, null); }
@Test(expected = UnsupportedOperationException.class) public void engineInit_spec_throws() { StaticKeyManagerFactorySpi staticKeyManagerFactorySpi = new StaticKeyManagerFactorySpi(new KeyManager[0]); staticKeyManagerFactorySpi.engineInit(null); } |
### Question:
LastHttpContentSwallower extends SimpleChannelInboundHandler<HttpObject> { @Override protected void channelRead0(ChannelHandlerContext ctx, HttpObject obj) { if (obj instanceof LastHttpContent) { ctx.read(); } else { ctx.fireChannelRead(obj); } ctx.pipeline().remove(this); } private LastHttpContentSwallower(); static LastHttpContentSwallower getInstance(); }### Answer:
@Test public void testOtherHttpObjectRead_removesSelfFromPipeline() { HttpObject contentObject = mock(HttpContent.class); lastHttpContentSwallower.channelRead0(mockCtx, contentObject); verify(mockPipeline).remove(eq(lastHttpContentSwallower)); }
@Test public void testLastHttpContentRead_removesSelfFromPipeline() { LastHttpContent lastContent = mock(LastHttpContent.class); lastHttpContentSwallower.channelRead0(mockCtx, lastContent); verify(mockPipeline).remove(eq(lastHttpContentSwallower)); }
@Test public void testLastHttpContentRead_swallowsObject() { LastHttpContent lastContent = mock(LastHttpContent.class); lastHttpContentSwallower.channelRead0(mockCtx, lastContent); verify(mockCtx, times(0)).fireChannelRead(eq(lastContent)); }
@Test public void testOtherHttpObjectRead_doesNotSwallowObject() { HttpContent content = mock(HttpContent.class); lastHttpContentSwallower.channelRead0(mockCtx, content); verify(mockCtx).fireChannelRead(eq(content)); }
@Test public void testCallsReadAfterSwallowingContent() { LastHttpContent lastContent = mock(LastHttpContent.class); lastHttpContentSwallower.channelRead0(mockCtx, lastContent); verify(mockCtx).read(); } |
### Question:
S3BucketResource implements S3Resource, ToCopyableBuilder<S3BucketResource.Builder, S3BucketResource> { @Override public Builder toBuilder() { return builder() .partition(partition) .region(region) .accountId(accountId) .bucketName(bucketName); } private S3BucketResource(Builder b); static Builder builder(); @Override String type(); @Override Optional<String> partition(); @Override Optional<String> region(); @Override Optional<String> accountId(); String bucketName(); @Override boolean equals(Object o); @Override int hashCode(); @Override Builder toBuilder(); }### Answer:
@Test public void toBuilder() { S3BucketResource s3BucketResource = S3BucketResource.builder() .bucketName("bucket") .accountId("account-id") .partition("partition") .region("region") .build() .toBuilder() .build(); assertEquals("bucket", s3BucketResource.bucketName()); assertEquals(Optional.of("account-id"), s3BucketResource.accountId()); assertEquals(Optional.of("partition"), s3BucketResource.partition()); assertEquals(Optional.of("region"), s3BucketResource.region()); assertEquals("bucket_name", s3BucketResource.type()); } |
### Question:
BootstrapProvider { public Bootstrap createBootstrap(String host, int port) { Bootstrap bootstrap = new Bootstrap() .group(sdkEventLoopGroup.eventLoopGroup()) .channelFactory(sdkEventLoopGroup.channelFactory()) .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, nettyConfiguration.connectTimeoutMillis()) .remoteAddress(InetSocketAddress.createUnresolved(host, port)); sdkChannelOptions.channelOptions().forEach(bootstrap::option); return bootstrap; } BootstrapProvider(SdkEventLoopGroup sdkEventLoopGroup,
NettyConfiguration nettyConfiguration,
SdkChannelOptions sdkChannelOptions); Bootstrap createBootstrap(String host, int port); }### Answer:
@Test public void createBootstrap_usesUnresolvedInetSocketAddress() { Bootstrap bootstrap = bootstrapProvider.createBootstrap("some-awesome-service-1234.amazonaws.com", 443); SocketAddress socketAddress = bootstrap.config().remoteAddress(); assertThat(socketAddress).isInstanceOf(InetSocketAddress.class); InetSocketAddress inetSocketAddress = (InetSocketAddress)socketAddress; assertThat(inetSocketAddress.isUnresolved()).isTrue(); } |
### Question:
StaticKeyManagerFactory extends KeyManagerFactory { public static StaticKeyManagerFactory create(KeyManager[] keyManagers) { return new StaticKeyManagerFactory(keyManagers); } private StaticKeyManagerFactory(KeyManager[] keyManagers); static StaticKeyManagerFactory create(KeyManager[] keyManagers); }### Answer:
@Test public void createReturnFactoryWithCorrectKeyManagers() { KeyManager[] keyManagers = IntStream.range(0,8) .mapToObj(i -> mock(KeyManager.class)) .toArray(KeyManager[]::new); StaticKeyManagerFactory staticKeyManagerFactory = StaticKeyManagerFactory.create(keyManagers); assertThat(staticKeyManagerFactory.getKeyManagers()) .containsExactly(keyManagers); } |
### Question:
SdkChannelOptions { public Map<ChannelOption, Object> channelOptions() { return Collections.unmodifiableMap(options); } SdkChannelOptions(); SdkChannelOptions putOption(ChannelOption<T> channelOption, T channelOptionValue); Map<ChannelOption, Object> channelOptions(); }### Answer:
@Test public void defaultSdkSocketOptionPresent() { SdkChannelOptions channelOptions = new SdkChannelOptions(); Map<ChannelOption, Object> expectedOptions = new HashMap<>(); expectedOptions.put(ChannelOption.TCP_NODELAY, Boolean.TRUE); assertEquals(expectedOptions, channelOptions.channelOptions()); } |
### Question:
SdkEventLoopGroup { public static SdkEventLoopGroup create(EventLoopGroup eventLoopGroup, ChannelFactory<? extends Channel> channelFactory) { return new SdkEventLoopGroup(eventLoopGroup, channelFactory); } SdkEventLoopGroup(EventLoopGroup eventLoopGroup, ChannelFactory<? extends Channel> channelFactory); private SdkEventLoopGroup(DefaultBuilder builder); EventLoopGroup eventLoopGroup(); ChannelFactory<? extends Channel> channelFactory(); static SdkEventLoopGroup create(EventLoopGroup eventLoopGroup, ChannelFactory<? extends Channel> channelFactory); static SdkEventLoopGroup create(EventLoopGroup eventLoopGroup); static Builder builder(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void notProvidingChannelFactory_unknownEventLoopGroup() { SdkEventLoopGroup.create(new DefaultEventLoopGroup()); } |
### Question:
ProxyConfiguration implements ToCopyableBuilder<ProxyConfiguration.Builder, ProxyConfiguration> { @Override public Builder toBuilder() { return new BuilderImpl(this); } private ProxyConfiguration(BuilderImpl builder); String scheme(); String host(); int port(); String username(); String password(); @Override boolean equals(Object o); @Override int hashCode(); @Override Builder toBuilder(); static Builder builder(); }### Answer:
@Test public void toBuilder_roundTrip_producesExactCopy() { ProxyConfiguration original = allPropertiesSetConfig(); ProxyConfiguration copy = original.toBuilder().build(); assertThat(copy).isEqualTo(original); }
@Test public void toBuilderModified_doesNotModifySource() { ProxyConfiguration original = allPropertiesSetConfig(); ProxyConfiguration modified = setAllPropertiesToRandomValues(original.toBuilder()).build(); assertThat(original).isNotEqualTo(modified); } |
### Question:
S3BucketResource implements S3Resource, ToCopyableBuilder<S3BucketResource.Builder, S3BucketResource> { public static Builder builder() { return new Builder(); } private S3BucketResource(Builder b); static Builder builder(); @Override String type(); @Override Optional<String> partition(); @Override Optional<String> region(); @Override Optional<String> accountId(); String bucketName(); @Override boolean equals(Object o); @Override int hashCode(); @Override Builder toBuilder(); }### Answer:
@Test(expected = NullPointerException.class) public void buildWithMissingBucketName() { S3BucketResource.builder().build(); } |
### Question:
ApacheHttpClient implements SdkHttpClient { public static Builder builder() { return new DefaultBuilder(); } @SdkTestInternalApi ApacheHttpClient(ConnectionManagerAwareHttpClient httpClient,
ApacheHttpRequestConfig requestConfig,
AttributeMap resolvedOptions); private ApacheHttpClient(DefaultBuilder builder, AttributeMap resolvedOptions); static Builder builder(); static SdkHttpClient create(); @Override ExecutableHttpRequest prepareRequest(HttpExecuteRequest request); @Override void close(); @Override String clientName(); static final String CLIENT_NAME; }### Answer:
@Test public void httpRoutePlannerCantBeUsedWithProxy_SystemPropertiesEnabled() { System.setProperty("http.proxyHost", "localhost"); System.setProperty("http.proxyPort", "1234"); assertThatThrownBy(() -> { ApacheHttpClient.builder() .httpRoutePlanner(Mockito.mock(HttpRoutePlanner.class)) .build(); }).isInstanceOf(IllegalArgumentException.class); }
@Test public void httpRoutePlannerCantBeUsedWithProxy_SystemPropertiesDisabled() { System.setProperty("http.proxyHost", "localhost"); System.setProperty("http.proxyPort", "1234"); ProxyConfiguration proxyConfig = ProxyConfiguration.builder() .useSystemPropertyValues(Boolean.FALSE) .build(); ApacheHttpClient.builder() .proxyConfiguration(proxyConfig) .httpRoutePlanner(Mockito.mock(HttpRoutePlanner.class)) .build(); }
@Test public void credentialProviderCantBeUsedWithProxyCredentials_SystemProperties() { System.setProperty("http.proxyUser", "foo"); System.setProperty("http.proxyPassword", "bar"); assertThatThrownBy(() -> { ApacheHttpClient.builder() .credentialsProvider(Mockito.mock(CredentialsProvider.class)) .build(); }).isInstanceOf(IllegalArgumentException.class); } |
### Question:
IdleConnectionReaper { public synchronized boolean registerConnectionManager(HttpClientConnectionManager manager, long maxIdleTime) { boolean notPreviouslyRegistered = connectionManagers.put(manager, maxIdleTime) == null; setupExecutorIfNecessary(); return notPreviouslyRegistered; } private IdleConnectionReaper(); @SdkTestInternalApi IdleConnectionReaper(Map<HttpClientConnectionManager, Long> connectionManagers,
Supplier<ExecutorService> executorServiceSupplier,
long sleepPeriod); synchronized boolean registerConnectionManager(HttpClientConnectionManager manager, long maxIdleTime); synchronized boolean deregisterConnectionManager(HttpClientConnectionManager manager); static IdleConnectionReaper getInstance(); }### Answer:
@Test public void setsUpExecutorIfManagerNotPreviouslyRegistered() { idleConnectionReaper.registerConnectionManager(connectionManager, 1L); verify(executorService).execute(any(Runnable.class)); } |
### Question:
ClientConnectionManagerFactory { public static HttpClientConnectionManager wrap(HttpClientConnectionManager orig) { if (orig instanceof Wrapped) { throw new IllegalArgumentException(); } Class<?>[] interfaces; if (orig instanceof ConnPoolControl) { interfaces = new Class<?>[]{ HttpClientConnectionManager.class, ConnPoolControl.class, Wrapped.class}; } else { interfaces = new Class<?>[]{ HttpClientConnectionManager.class, Wrapped.class }; } return (HttpClientConnectionManager) Proxy.newProxyInstance( ClientConnectionManagerFactory.class.getClassLoader(), interfaces, new Handler(orig)); } private ClientConnectionManagerFactory(); static HttpClientConnectionManager wrap(HttpClientConnectionManager orig); }### Answer:
@Test public void wrapOnce() { HttpClientConnectionManager wrapped = ClientConnectionManagerFactory.wrap(noop); assertTrue(wrapped instanceof Wrapped); }
@Test(expected = IllegalArgumentException.class) public void wrapTwice() { HttpClientConnectionManager wrapped = ClientConnectionManagerFactory.wrap(noop); ClientConnectionManagerFactory.wrap(wrapped); } |
### Question:
ProfileUseArnRegionProvider implements UseArnRegionProvider { @Override public Optional<Boolean> resolveUseArnRegion() { return profileFile.get() .profile(profileName) .map(p -> p.properties().get(AWS_USE_ARN_REGION)) .map(StringUtils::safeStringToBoolean); } private ProfileUseArnRegionProvider(Supplier<ProfileFile> profileFile, String profileName); static ProfileUseArnRegionProvider create(); static ProfileUseArnRegionProvider create(ProfileFile profileFile, String profileName); @Override Optional<Boolean> resolveUseArnRegion(); }### Answer:
@Test public void notSpecified_shouldReturnEmptyOptional() { assertThat(provider.resolveUseArnRegion()).isEqualTo(Optional.empty()); }
@Test public void specifiedInConfigFile_shouldResolve() { String configFile = getClass().getResource("UseArnRegionSet_true").getFile(); System.setProperty(AWS_CONFIG_FILE.property(), configFile); assertThat(provider.resolveUseArnRegion()).isEqualTo(Optional.of(TRUE)); }
@Test public void configFile_mixedSpace() { String configFile = getClass().getResource("UseArnRegionSet_mixedSpace").getFile(); System.setProperty(AWS_CONFIG_FILE.property(), configFile); assertThat(provider.resolveUseArnRegion()).isEqualTo(Optional.of(FALSE)); }
@Test public void unsupportedValue_shouldThrowException() { String configFile = getClass().getResource("UseArnRegionSet_unsupportedValue").getFile(); System.setProperty(AWS_CONFIG_FILE.property(), configFile); assertThatThrownBy(() -> provider.resolveUseArnRegion()).isInstanceOf(IllegalArgumentException.class); }
@Test public void commaNoSpace_shouldResolveCorrectly() { String configFile = getClass().getResource("UseArnRegionSet_noSpace").getFile(); System.setProperty(AWS_CONFIG_FILE.property(), configFile); assertThat(provider.resolveUseArnRegion()).isEqualTo(Optional.of(FALSE)); } |
### Question:
ApacheHttpRequestFactory { public HttpRequestBase create(final HttpExecuteRequest request, final ApacheHttpRequestConfig requestConfig) { HttpRequestBase base = createApacheRequest(request, sanitizeUri(request.httpRequest())); addHeadersToRequest(base, request.httpRequest()); addRequestConfig(base, request.httpRequest(), requestConfig); return base; } HttpRequestBase create(final HttpExecuteRequest request, final ApacheHttpRequestConfig requestConfig); }### Answer:
@Test public void ceateSetsHostHeaderByDefault() { SdkHttpRequest sdkRequest = SdkHttpRequest.builder() .uri(URI.create("http: .method(SdkHttpMethod.HEAD) .build(); HttpExecuteRequest request = HttpExecuteRequest.builder() .request(sdkRequest) .build(); HttpRequestBase result = instance.create(request, requestConfig); Header[] hostHeaders = result.getHeaders(HttpHeaders.HOST); assertNotNull(hostHeaders); assertEquals(1, hostHeaders.length); assertEquals("localhost:12345", hostHeaders[0].getValue()); }
@Test public void defaultHttpPortsAreNotInDefaultHostHeader() { SdkHttpRequest sdkRequest = SdkHttpRequest.builder() .uri(URI.create("http: .method(SdkHttpMethod.HEAD) .build(); HttpExecuteRequest request = HttpExecuteRequest.builder() .request(sdkRequest) .build(); HttpRequestBase result = instance.create(request, requestConfig); Header[] hostHeaders = result.getHeaders(HttpHeaders.HOST); assertNotNull(hostHeaders); assertEquals(1, hostHeaders.length); assertEquals("localhost", hostHeaders[0].getValue()); sdkRequest = SdkHttpRequest.builder() .uri(URI.create("https: .method(SdkHttpMethod.HEAD) .build(); request = HttpExecuteRequest.builder() .request(sdkRequest) .build(); result = instance.create(request, requestConfig); hostHeaders = result.getHeaders(HttpHeaders.HOST); assertNotNull(hostHeaders); assertEquals(1, hostHeaders.length); assertEquals("localhost", hostHeaders[0].getValue()); } |
### Question:
ProfileUseArnRegionProvider implements UseArnRegionProvider { public static ProfileUseArnRegionProvider create() { return new ProfileUseArnRegionProvider(ProfileFile::defaultProfileFile, ProfileFileSystemSetting.AWS_PROFILE.getStringValueOrThrow()); } private ProfileUseArnRegionProvider(Supplier<ProfileFile> profileFile, String profileName); static ProfileUseArnRegionProvider create(); static ProfileUseArnRegionProvider create(ProfileFile profileFile, String profileName); @Override Optional<Boolean> resolveUseArnRegion(); }### Answer:
@Test public void specifiedInOverrideConfig_shouldUse() { ExecutionInterceptor interceptor = Mockito.spy(AbstractExecutionInterceptor.class); String profileFileContent = "[default]\n" + "s3_use_arn_region = true\n"; ProfileFile profileFile = ProfileFile.builder() .type(ProfileFile.Type.CONFIGURATION) .content(new StringInputStream(profileFileContent)) .build(); S3Client s3 = S3Client.builder() .region(Region.US_WEST_2) .credentialsProvider(AnonymousCredentialsProvider.create()) .overrideConfiguration(c -> c.defaultProfileFile(profileFile) .defaultProfileName("default") .addExecutionInterceptor(interceptor) .retryPolicy(r -> r.numRetries(0))) .build(); String arn = "arn:aws:s3:us-banana-46:12345567890:accesspoint:foo"; assertThatThrownBy(() -> s3.getObject(r -> r.bucket(arn).key("bar"))).isInstanceOf(SdkException.class); ArgumentCaptor<Context.BeforeTransmission> context = ArgumentCaptor.forClass(Context.BeforeTransmission.class); Mockito.verify(interceptor).beforeTransmission(context.capture(), any()); String host = context.getValue().httpRequest().host(); assertThat(host).contains("us-banana-46"); } |
### Question:
FormService { public ResponseEntity<?> handleKillThreadPost(Map<String, String> form, TileLayer tl) { String id = form.get("thread_id"); StringBuilder doc = new StringBuilder(); makeHeader(doc); if (seeder.terminateGWCTask(Long.parseLong(id))) { doc.append("<ul><li>Requested to terminate task " + id + ".</li></ul>"); } else { doc.append( "<ul><li>Sorry, either task " + id + " has not started yet, or it is a truncate task that cannot be interrutped.</li></ul>"); } if (tl != null) { doc.append("<p><a href=\"./" + tl.getName() + "\">Go back</a></p>\n"); } return new ResponseEntity<Object>(doc.toString(), getHeaders(), HttpStatus.OK); } ResponseEntity<?> handleKillAllThreadsPost(Map<String, String> form, TileLayer tl); ResponseEntity<?> handleKillThreadPost(Map<String, String> form, TileLayer tl); ResponseEntity<?> handleFormPost(String layer, Map<String, String> params); ResponseEntity<?> handleGet(HttpServletRequest request, String layer); void setTileBreeder(TileBreeder seeder); }### Answer:
@Test public void testKill() { Map<String, String> form = new HashMap<>(); form.put("kill_thread", "1"); form.put("thread_id", "2"); TileLayer tl = EasyMock.createMock("tl", TileLayer.class); EasyMock.expect(breeder.terminateGWCTask(2)).andReturn(true); EasyMock.expect(tl.getName()).andStubReturn("testLayer"); EasyMock.replay(tl, breeder); ResponseEntity<?> response = service.handleKillThreadPost(form, tl); EasyMock.verify(tl, breeder); assertThat(response, hasProperty("statusCode", equalTo(HttpStatus.OK))); assertThat( response, hasProperty("body", Matchers.containsString("Requested to terminate task 2"))); } |
### Question:
MbtilesBlobStore extends SqliteBlobStore { @Override public boolean layerExists(String layerName) { return !fileManager.getFiles(layerName).isEmpty(); } MbtilesBlobStore(MbtilesInfo configuration); MbtilesBlobStore(MbtilesInfo configuration, SqliteConnectionManager connectionManager); @Override void put(TileObject tile); @Override boolean get(final TileObject tile); @Override boolean delete(TileObject tile); @Override synchronized void putLayerMetadata(String layerName, String key, String value); @Override String getLayerMetadata(String layerName, String key); @Override boolean layerExists(String layerName); @Override boolean delete(String layerName); @Override boolean deleteByGridsetId(String layerName, String gridSetId); @Override boolean deleteByParametersId(String layerName, String parametersId); @Override boolean delete(TileRange tileRange); @Override boolean rename(String oldLayerName, String newLayerName); @Override void addListener(BlobStoreListener listener); @Override boolean removeListener(BlobStoreListener listener); @Override void clear(); @Override void destroy(); Map<String, Optional<Map<String, String>>> getParametersMapping(String layerName); }### Answer:
@Test public void testLayerExistsOperation() throws Exception { MbtilesInfo configuration = getDefaultConfiguration(); MbtilesBlobStore store = new MbtilesBlobStore(configuration); addStoresToClean(store); createFileInRootDir( Utils.buildPath("grid1", "europe", "image_png", "10", "tiles-0-0.sqlite")); assertThat(store.layerExists("europe"), is(true)); assertThat(store.layerExists("asia"), is(false)); } |
### Question:
SwiftTile { public Payload getPayload() { Payload payload = new ByteArrayPayload(data); payload.setContentMetadata(getMetadata()); return payload; } SwiftTile(final TileObject tile); Payload getPayload(); void setExisted(long oldSize); void notifyListeners(BlobStoreListenerList listeners); String toString(); }### Answer:
@Test public void testGetPayloadMetadataOutputLength() { Long testOutputLengthValue = 5L; ReflectionTestUtils.setField(swiftTile, "outputLength", testOutputLengthValue); Payload testPayload = swiftTile.getPayload(); assertEquals(testOutputLengthValue, testPayload.getContentMetadata().getContentLength()); }
@Test public void testGetPayloadMetadataMimeType() { String testBlobFormat = "image/png"; ReflectionTestUtils.setField(swiftTile, "blobFormat", testBlobFormat); Payload testPayload = swiftTile.getPayload(); assertEquals(testBlobFormat, testPayload.getContentMetadata().getContentType()); } |
### Question:
SwiftTile { public void notifyListeners(BlobStoreListenerList listeners) { boolean hasListeners = !listeners.isEmpty(); if (hasListeners && existed) { listeners.sendTileUpdated( layerName, gridSetId, blobFormat, parametersId, x, y, z, outputLength, oldSize); } else if (hasListeners) { listeners.sendTileStored( layerName, gridSetId, blobFormat, parametersId, x, y, z, outputLength); } } SwiftTile(final TileObject tile); Payload getPayload(); void setExisted(long oldSize); void notifyListeners(BlobStoreListenerList listeners); String toString(); }### Answer:
@Test public void testNotifyListenersWhenEmptyAndExisted() { ReflectionTestUtils.setField(swiftTile, "existed", true); swiftTile.notifyListeners(testListeners); checkListenersNotifications(0, 0); }
@Test public void testNotifyListenersWhenEmptyAndNotExisted() { ReflectionTestUtils.setField(swiftTile, "existed", false); swiftTile.notifyListeners(testListeners); checkListenersNotifications(0, 0); }
@Test public void testNotifyListenersWhenNotEmptyAndExisted() { ReflectionTestUtils.setField(swiftTile, "existed", true); addListener(); swiftTile.notifyListeners(testListeners); checkListenersNotifications(1, 0); }
@Test public void testNotifyListenersWhenNotEmptyAndNotExisted() { ReflectionTestUtils.setField(swiftTile, "existed", false); addListener(); swiftTile.notifyListeners(testListeners); checkListenersNotifications(0, 1); } |
### Question:
SwiftBlobStore implements BlobStore { @Override public void destroy() { try { this.shutDown = true; this.swiftApi.close(); this.blobStoreContext.close(); } catch (IOException e) { log.error("Error closing connection."); log.error(e); } } SwiftBlobStore(SwiftBlobStoreInfo config, TileLayerDispatcher layers); @Override void destroy(); @Override void addListener(BlobStoreListener listener); @Override boolean removeListener(BlobStoreListener listener); @Override void put(TileObject obj); @Override boolean get(TileObject obj); @Override boolean delete(final TileRange tileRange); @Override boolean delete(String layerName); @Override boolean deleteByGridsetId(final String layerName, final String gridSetId); @Override boolean delete(TileObject obj); @Override boolean rename(String oldLayerName, String newLayerName); @Override void clear(); @Nullable @Override String getLayerMetadata(String layerName, String key); @Override void putLayerMetadata(String layerName, String key, String value); @Override boolean layerExists(String layerName); @Override Map<String, Optional<Map<String, String>>> getParametersMapping(String layerName); @Override boolean deleteByParametersId(String layerName, String parametersId); }### Answer:
@Test public void destroy() { this.swiftBlobStore.destroy(); try { verify(swiftApi, times(1)).close(); verify(blobStoreContext, times(1)).close(); } catch (IOException e) { fail(e.getMessage()); } } |
### Question:
SwiftBlobStore implements BlobStore { @Override public void addListener(BlobStoreListener listener) { listeners.addListener(listener); } SwiftBlobStore(SwiftBlobStoreInfo config, TileLayerDispatcher layers); @Override void destroy(); @Override void addListener(BlobStoreListener listener); @Override boolean removeListener(BlobStoreListener listener); @Override void put(TileObject obj); @Override boolean get(TileObject obj); @Override boolean delete(final TileRange tileRange); @Override boolean delete(String layerName); @Override boolean deleteByGridsetId(final String layerName, final String gridSetId); @Override boolean delete(TileObject obj); @Override boolean rename(String oldLayerName, String newLayerName); @Override void clear(); @Nullable @Override String getLayerMetadata(String layerName, String key); @Override void putLayerMetadata(String layerName, String key, String value); @Override boolean layerExists(String layerName); @Override Map<String, Optional<Map<String, String>>> getParametersMapping(String layerName); @Override boolean deleteByParametersId(String layerName, String parametersId); }### Answer:
@Test public void addListener() { assertTrue(testListeners.isEmpty()); BlobStoreListener swiftListener = mock(BlobStoreListener.class); this.swiftBlobStore.addListener(swiftListener); ArrayList<BlobStoreListener> blobStoreListenersResult = (ArrayList) testListeners.getListeners(); assertTrue(blobStoreListenersResult.contains(swiftListener)); } |
### Question:
SwiftBlobStore implements BlobStore { @Override public boolean removeListener(BlobStoreListener listener) { return listeners.removeListener(listener); } SwiftBlobStore(SwiftBlobStoreInfo config, TileLayerDispatcher layers); @Override void destroy(); @Override void addListener(BlobStoreListener listener); @Override boolean removeListener(BlobStoreListener listener); @Override void put(TileObject obj); @Override boolean get(TileObject obj); @Override boolean delete(final TileRange tileRange); @Override boolean delete(String layerName); @Override boolean deleteByGridsetId(final String layerName, final String gridSetId); @Override boolean delete(TileObject obj); @Override boolean rename(String oldLayerName, String newLayerName); @Override void clear(); @Nullable @Override String getLayerMetadata(String layerName, String key); @Override void putLayerMetadata(String layerName, String key, String value); @Override boolean layerExists(String layerName); @Override Map<String, Optional<Map<String, String>>> getParametersMapping(String layerName); @Override boolean deleteByParametersId(String layerName, String parametersId); }### Answer:
@Test public void removeListener() { BlobStoreListener swiftListener = mock(BlobStoreListener.class); this.testListeners.addListener(swiftListener); ArrayList<BlobStoreListener> testListenersList = (ArrayList) testListeners.getListeners(); assertTrue(testListenersList.contains(swiftListener)); this.swiftBlobStore.removeListener(swiftListener); assertTrue(testListeners.isEmpty()); } |
### Question:
SwiftBlobStore implements BlobStore { @Override public boolean rename(String oldLayerName, String newLayerName) { log.debug("No need to rename layers, SwiftBlobStore uses layer id as key root"); if (objectApi.get(oldLayerName) != null) { listeners.sendLayerRenamed(oldLayerName, newLayerName); } return true; } SwiftBlobStore(SwiftBlobStoreInfo config, TileLayerDispatcher layers); @Override void destroy(); @Override void addListener(BlobStoreListener listener); @Override boolean removeListener(BlobStoreListener listener); @Override void put(TileObject obj); @Override boolean get(TileObject obj); @Override boolean delete(final TileRange tileRange); @Override boolean delete(String layerName); @Override boolean deleteByGridsetId(final String layerName, final String gridSetId); @Override boolean delete(TileObject obj); @Override boolean rename(String oldLayerName, String newLayerName); @Override void clear(); @Nullable @Override String getLayerMetadata(String layerName, String key); @Override void putLayerMetadata(String layerName, String key, String value); @Override boolean layerExists(String layerName); @Override Map<String, Optional<Map<String, String>>> getParametersMapping(String layerName); @Override boolean deleteByParametersId(String layerName, String parametersId); }### Answer:
@Test public void rename() { boolean result = this.swiftBlobStore.rename(VALID_TEST_LAYER_NAME, "NewLayerName"); verify(objectApi, times(1)).get(VALID_TEST_LAYER_NAME); verify(this.testListeners, times(0)) .sendLayerRenamed(VALID_TEST_LAYER_NAME, "NewLayerName"); assertTrue(result); when(this.objectApi.get(VALID_TEST_LAYER_NAME)).thenReturn(mock(SwiftObject.class)); result = this.swiftBlobStore.rename(VALID_TEST_LAYER_NAME, "NewLayerName"); verify(objectApi, times(2)).get(VALID_TEST_LAYER_NAME); verify(this.testListeners, times(1)) .sendLayerRenamed(VALID_TEST_LAYER_NAME, "NewLayerName"); assertTrue(result); } |
### Question:
SwiftBlobStore implements BlobStore { @Override public void clear() { throw new UnsupportedOperationException("clear() should not be called"); } SwiftBlobStore(SwiftBlobStoreInfo config, TileLayerDispatcher layers); @Override void destroy(); @Override void addListener(BlobStoreListener listener); @Override boolean removeListener(BlobStoreListener listener); @Override void put(TileObject obj); @Override boolean get(TileObject obj); @Override boolean delete(final TileRange tileRange); @Override boolean delete(String layerName); @Override boolean deleteByGridsetId(final String layerName, final String gridSetId); @Override boolean delete(TileObject obj); @Override boolean rename(String oldLayerName, String newLayerName); @Override void clear(); @Nullable @Override String getLayerMetadata(String layerName, String key); @Override void putLayerMetadata(String layerName, String key, String value); @Override boolean layerExists(String layerName); @Override Map<String, Optional<Map<String, String>>> getParametersMapping(String layerName); @Override boolean deleteByParametersId(String layerName, String parametersId); }### Answer:
@Test public void clear() { try { this.swiftBlobStore.clear(); fail("This method should not work, it should throw a Unsupported Operation Exception"); } catch (UnsupportedOperationException e) { assertThat(e.getMessage(), is("clear() should not be called")); } } |
### Question:
SwiftBlobStore implements BlobStore { @Override public boolean layerExists(String layerName) { return this.objectApi.get(layerName) != null; } SwiftBlobStore(SwiftBlobStoreInfo config, TileLayerDispatcher layers); @Override void destroy(); @Override void addListener(BlobStoreListener listener); @Override boolean removeListener(BlobStoreListener listener); @Override void put(TileObject obj); @Override boolean get(TileObject obj); @Override boolean delete(final TileRange tileRange); @Override boolean delete(String layerName); @Override boolean deleteByGridsetId(final String layerName, final String gridSetId); @Override boolean delete(TileObject obj); @Override boolean rename(String oldLayerName, String newLayerName); @Override void clear(); @Nullable @Override String getLayerMetadata(String layerName, String key); @Override void putLayerMetadata(String layerName, String key, String value); @Override boolean layerExists(String layerName); @Override Map<String, Optional<Map<String, String>>> getParametersMapping(String layerName); @Override boolean deleteByParametersId(String layerName, String parametersId); }### Answer:
@Test public void layerExists() { SwiftObject swiftObject = mock(SwiftObject.class); when(objectApi.get(VALID_TEST_LAYER_NAME)).thenReturn(swiftObject); assertTrue(swiftBlobStore.layerExists(VALID_TEST_LAYER_NAME)); when(objectApi.get("layer which doesn't exist")).thenReturn(null); assertFalse(swiftBlobStore.layerExists("layer which doesn't exist")); } |
### Question:
S3BlobStoreConfigProvider implements XMLConfigurationProvider { @Override public XStream getConfiguredXStream(XStream xs) { xs.alias("S3BlobStore", S3BlobStoreInfo.class); xs.registerLocalConverter( S3BlobStoreInfo.class, "maxConnections", EnvironmentNullableIntConverter); xs.registerLocalConverter( S3BlobStoreInfo.class, "proxyPort", EnvironmentNullableIntConverter); xs.registerLocalConverter( S3BlobStoreInfo.class, "useHTTPS", EnvironmentNullableBooleanConverter); xs.registerLocalConverter( S3BlobStoreInfo.class, "useGzip", EnvironmentNullableBooleanConverter); xs.registerLocalConverter(S3BlobStoreInfo.class, "bucket", EnvironmentStringConverter); xs.registerLocalConverter( S3BlobStoreInfo.class, "awsAccessKey", EnvironmentStringConverter); xs.registerLocalConverter( S3BlobStoreInfo.class, "awsSecretKey", EnvironmentStringConverter); xs.registerLocalConverter(S3BlobStoreInfo.class, "prefix", EnvironmentStringConverter); xs.registerLocalConverter(S3BlobStoreInfo.class, "proxyHost", EnvironmentStringConverter); xs.registerLocalConverter( BlobStoreInfo.class, "enabled", EnvironmentNullableBooleanConverter); xs.aliasField("id", S3BlobStoreInfo.class, "name"); return xs; } @Override XStream getConfiguredXStream(XStream xs); @Override boolean canSave(Info i); }### Answer:
@Test public void testValuesFromEnvironment() { S3BlobStoreConfigProvider provider = new S3BlobStoreConfigProvider(); XStream stream = new XStream(); stream = provider.getConfiguredXStream(stream); Object config = stream.fromXML(getClass().getResourceAsStream("blobstore.xml")); assertTrue(config instanceof S3BlobStoreInfo); S3BlobStoreInfo s3Config = (S3BlobStoreInfo) config; assertEquals("MYBUCKET", s3Config.getBucket()); assertEquals(30, s3Config.getMaxConnections().intValue()); assertEquals(true, s3Config.isEnabled()); } |
### Question:
AzureBlobStoreConfigProvider implements XMLConfigurationProvider { @Override public XStream getConfiguredXStream(XStream xs) { Class<AzureBlobStoreInfo> clazz = AzureBlobStoreInfo.class; xs.alias("AzureBlobStore", clazz); xs.aliasField("id", clazz, "name"); return xs; } @Override XStream getConfiguredXStream(XStream xs); @Override boolean canSave(Info i); }### Answer:
@Test public void testValuesFromEnvironment() { AzureBlobStoreConfigProvider provider = new AzureBlobStoreConfigProvider(); XStream stream = new XStream(); stream = provider.getConfiguredXStream(stream); Object config = stream.fromXML(getClass().getResourceAsStream("blobstore.xml")); assertTrue(config instanceof AzureBlobStoreInfo); AzureBlobStoreInfo abConfig = (AzureBlobStoreInfo) config; assertEquals("${CONTAINER}", abConfig.getContainer()); assertEquals("myname", abConfig.getAccountName()); assertEquals("${MYKEY}", abConfig.getAccountKey()); assertEquals("30", abConfig.getMaxConnections()); assertEquals(true, abConfig.isEnabled()); } |
### Question:
ImageMime extends MimeType { public ImageWriter getImageWriter(RenderedImage image) { Iterator<ImageWriter> it = javax.imageio.ImageIO.getImageWritersByFormatName(internalName); ImageWriter writer = it.next(); if (this.internalName.equals(ImageMime.png.internalName) || this.internalName.equals(ImageMime.png8.internalName)) { int bitDepth = image.getSampleModel().getSampleSize(0); if (bitDepth > 1 && bitDepth < 8 && writer.getClass().getName().equals(NATIVE_PNG_WRITER_CLASS_NAME)) { writer = it.next(); } } return writer; } private ImageMime(
String mimeType,
String fileExtension,
String internalName,
String format,
boolean tiled,
boolean alphaChannel,
boolean alphaBit); boolean supportsAlphaBit(); boolean supportsAlphaChannel(); ImageWriter getImageWriter(RenderedImage image); RenderedImage preprocess(RenderedImage tile); static final String NATIVE_PNG_WRITER_CLASS_NAME; static final ImageMime png; static final ImageMime jpeg; static final ImageMime gif; static final ImageMime tiff; static final ImageMime png8; static final ImageMime png24; static final ImageMime png_24; static final ImageMime dds; static final ImageMime jpegPng; static final ImageMime jpegPng8; }### Answer:
@Test public void test4BitPNG() throws IOException, URISyntaxException { URL url = this.getClass().getResource("/images/4bit.png"); RenderedImage tile = ImageIO.read(new File(url.toURI())); ImageWriter writer = ImageMime.png8.getImageWriter(tile); assertNotEquals( "Writer for this image should not be the native version.", writer.getClass().getName(), ImageMime.NATIVE_PNG_WRITER_CLASS_NAME); } |
### Question:
LegendInfoBuilder { public LegendInfoBuilder withUrl(String url) { this.url = url; return this; } LegendInfoBuilder withLayerName(String layerName); LegendInfoBuilder withLayerUrl(String layerUrl); LegendInfoBuilder withDefaultWidth(Integer defaultWidth); LegendInfoBuilder withDefaultHeight(Integer defaultHeight); LegendInfoBuilder withDefaultFormat(String defaultFormat); LegendInfoBuilder withStyleName(String styleName); LegendInfoBuilder withWidth(Integer width); LegendInfoBuilder withHeight(Integer height); LegendInfoBuilder withFormat(String format); LegendInfoBuilder withUrl(String url); LegendInfoBuilder withCompleteUrl(String completeUrl); LegendInfoBuilder withMinScale(Double minScale); LegendInfoBuilder withMaxScale(Double maxScale); LegendInfo build(); }### Answer:
@Test public void testWithUrl() { LegendInfo legendInfo = new LegendInfoBuilder() .withLayerName("layer1") .withLayerUrl("http: .withDefaultWidth(50) .withDefaultHeight(100) .withDefaultFormat("image/png") .withStyleName("style1") .withWidth(150) .withHeight(200) .withFormat("image/gif") .withUrl("http: .build(); assertThat(legendInfo.getWidth(), is(150)); assertThat(legendInfo.getHeight(), is(200)); assertThat(legendInfo.getFormat(), is("image/gif")); assertThat(legendInfo.getStyleName(), is("style1")); assertThat( legendInfo.getLegendUrl(), is( "http: + "service=WMS&request=GetLegendGraphic&format=image/gif&width=150&height=200&layer=layer1&style=style1")); } |
### Question:
LegendInfoBuilder { public LegendInfoBuilder withCompleteUrl(String completeUrl) { this.completeUrl = completeUrl; return this; } LegendInfoBuilder withLayerName(String layerName); LegendInfoBuilder withLayerUrl(String layerUrl); LegendInfoBuilder withDefaultWidth(Integer defaultWidth); LegendInfoBuilder withDefaultHeight(Integer defaultHeight); LegendInfoBuilder withDefaultFormat(String defaultFormat); LegendInfoBuilder withStyleName(String styleName); LegendInfoBuilder withWidth(Integer width); LegendInfoBuilder withHeight(Integer height); LegendInfoBuilder withFormat(String format); LegendInfoBuilder withUrl(String url); LegendInfoBuilder withCompleteUrl(String completeUrl); LegendInfoBuilder withMinScale(Double minScale); LegendInfoBuilder withMaxScale(Double maxScale); LegendInfo build(); }### Answer:
@Test public void testWithCompleteUrl() { LegendInfo legendInfo = new LegendInfoBuilder() .withLayerName("layer1") .withLayerUrl("http: .withDefaultWidth(50) .withDefaultHeight(100) .withDefaultFormat("image/png") .withStyleName("style1") .withWidth(150) .withHeight(200) .withFormat("image/gif") .withCompleteUrl("http: .build(); assertThat(legendInfo.getWidth(), is(150)); assertThat(legendInfo.getHeight(), is(200)); assertThat(legendInfo.getFormat(), is("image/gif")); assertThat(legendInfo.getStyleName(), is("style1")); assertThat(legendInfo.getLegendUrl(), is("http: } |
### Question:
ListenerCollection { public synchronized void safeForEach(HandlerMethod<Listener> method) throws GeoWebCacheException, IOException { LinkedList<Exception> exceptions = listeners .stream() .map( l -> { try { method.callOn(l); return Optional.<Exception>empty(); } catch (Exception ex) { return Optional.of(ex); } }) .filter(Optional::isPresent) .map(Optional::get) .collect( Collectors.collectingAndThen(Collectors.toList(), LinkedList::new)); if (!exceptions.isEmpty()) { Iterator<Exception> it = exceptions.descendingIterator(); Exception ex = it.next(); while (it.hasNext()) { ex.addSuppressed(it.next()); } if (ex instanceof GeoWebCacheException) { throw (GeoWebCacheException) ex; } else if (ex instanceof IOException) { throw (IOException) ex; } else { throw (RuntimeException) ex; } } } synchronized void add(Listener listener); synchronized void remove(Listener listener); synchronized void safeForEach(HandlerMethod<Listener> method); }### Answer:
@Test public void testEmpty() throws Exception { ListenerCollection<Runnable> collection = new ListenerCollection<>(); collection.safeForEach( (x) -> { fail("should not be called"); }); } |
### Question:
ListenerCollection { public synchronized void remove(Listener listener) { listeners.remove(listener); } synchronized void add(Listener listener); synchronized void remove(Listener listener); synchronized void safeForEach(HandlerMethod<Listener> method); }### Answer:
@Test public void testRemove() throws Exception { ListenerCollection<Runnable> collection = new ListenerCollection<>(); IMocksControl control = EasyMock.createControl(); Runnable l1 = control.createMock("l1", Runnable.class); Runnable l2 = control.createMock("l2", Runnable.class); control.checkOrder(true); l2.run(); EasyMock.expectLastCall().once(); control.replay(); collection.add(l1); collection.add(l2); collection.remove(l1); collection.safeForEach(Runnable::run); control.verify(); } |
### Question:
GeoWebCacheExtensions implements ApplicationContextAware, ApplicationListener { @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD") public void setApplicationContext(ApplicationContext context) throws BeansException { GeoWebCacheExtensions.context = context; extensionsCache.clear(); } @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD") void setApplicationContext(ApplicationContext context); @SuppressWarnings("unchecked") static final List<T> extensions(
Class<T> extensionPoint, ApplicationContext context); static String[] getBeansNamesOrderedByPriority(Class<T> extensionType); static final List<T> extensions(Class<T> extensionPoint); static List<T> configurations(
Class<T> extensionPoint, ApplicationContext context); static List<T> configurations(Class<T> extensionPoint); static void reinitialize(ApplicationContext context); static final Object bean(String name); static final Object bean(String name, ApplicationContext context); static final T bean(Class<T> type); static final T bean(Class<T> type, ApplicationContext context); void onApplicationEvent(ApplicationEvent event); static String getProperty(String propertyName); static String getProperty(String propertyName, ApplicationContext context); static String getProperty(String propertyName, ServletContext context); }### Answer:
@Test public void testSetApplicationContext() { ApplicationContext appContext1 = createMock(ApplicationContext.class); ApplicationContext appContext2 = createMock(ApplicationContext.class); GeoWebCacheExtensions gse = new GeoWebCacheExtensions(); gse.setApplicationContext(appContext1); GeoWebCacheExtensions.extensionsCache.put( GeoWebCacheExtensionsTest.class, new String[] {"fake"}); assertSame(appContext1, GeoWebCacheExtensions.context); gse.setApplicationContext(appContext2); assertSame(appContext2, GeoWebCacheExtensions.context); assertEquals(0, GeoWebCacheExtensions.extensionsCache.size()); } |
### Question:
GeoWebCacheExtensions implements ApplicationContextAware, ApplicationListener { public static String getProperty(String propertyName) { return getProperty(propertyName, context); } @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD") void setApplicationContext(ApplicationContext context); @SuppressWarnings("unchecked") static final List<T> extensions(
Class<T> extensionPoint, ApplicationContext context); static String[] getBeansNamesOrderedByPriority(Class<T> extensionType); static final List<T> extensions(Class<T> extensionPoint); static List<T> configurations(
Class<T> extensionPoint, ApplicationContext context); static List<T> configurations(Class<T> extensionPoint); static void reinitialize(ApplicationContext context); static final Object bean(String name); static final Object bean(String name, ApplicationContext context); static final T bean(Class<T> type); static final T bean(Class<T> type, ApplicationContext context); void onApplicationEvent(ApplicationEvent event); static String getProperty(String propertyName); static String getProperty(String propertyName, ApplicationContext context); static String getProperty(String propertyName, ServletContext context); }### Answer:
@Test public void testSystemProperty() { testProperty.setValue("ABC"); assertEquals( "ABC", GeoWebCacheExtensions.getProperty("TEST_PROPERTY", (ApplicationContext) null)); assertEquals( "ABC", GeoWebCacheExtensions.getProperty("TEST_PROPERTY", (ServletContext) null)); }
@Test public void testWebProperty() { testProperty.setValue("ABC"); ServletContext servletContext = createMock(ServletContext.class); expect(servletContext.getInitParameter("TEST_PROPERTY")).andReturn("DEF").anyTimes(); expect(servletContext.getInitParameter("WEB_PROPERTY")).andReturn("WWW").anyTimes(); replay(servletContext); assertEquals("ABC", GeoWebCacheExtensions.getProperty("TEST_PROPERTY", servletContext)); assertEquals("WWW", GeoWebCacheExtensions.getProperty("WEB_PROPERTY", servletContext)); } |
### Question:
GridSetBroker implements ConfigurationAggregator<GridSetConfiguration>,
ApplicationContextAware,
InitializingBean { public @Nullable GridSet get(String gridSetId) { return getGridSet(gridSetId).orElse(null); } GridSetBroker(); GridSetBroker(List<GridSetConfiguration> configurations); void afterPropertiesSet(); @Nullable GridSet get(String gridSetId); Set<String> getEmbeddedNames(); Set<String> getNames(); Set<String> getGridSetNames(); Collection<GridSet> getGridSets(); synchronized void put(GridSet gridSet); void addGridSet(GridSet gridSet); synchronized GridSet remove(final String gridSetName); synchronized void removeGridSet(final String gridSetName); DefaultGridsets getDefaults(); GridSet getWorldEpsg4326(); GridSet getWorldEpsg3857(); @SuppressWarnings("unchecked") List<? extends GSC> getConfigurations(
Class<GSC> type); @Override void setApplicationContext(ApplicationContext applicationContext); }### Answer:
@Test public void testGetDefaultGridsetOld() throws IOException { GridSet existingGridSet = gridSetBroker.get(GWCConfigIntegrationTestData.GRIDSET_EPSG4326); assertThat( existingGridSet, hasProperty("name", equalTo(GWCConfigIntegrationTestData.GRIDSET_EPSG4326))); }
@Test public void testGetGridsetOld() throws IOException { GridSet existingGridSet = gridSetBroker.get(GWCConfigIntegrationTestData.GRIDSET_EPSG2163); assertThat( existingGridSet, hasProperty("name", equalTo(GWCConfigIntegrationTestData.GRIDSET_EPSG2163))); }
@Test public void testGetNotPresentGridsetOld() throws IOException { GridSet existingGridSet = gridSetBroker.get("DOESNOTEXIST"); assertThat(existingGridSet, nullValue()); } |
### Question:
GridSetBroker implements ConfigurationAggregator<GridSetConfiguration>,
ApplicationContextAware,
InitializingBean { public synchronized void removeGridSet(final String gridSetName) { getConfigurations() .stream() .filter(c -> c.getGridSet(gridSetName).isPresent()) .forEach( c -> { c.removeGridSet(gridSetName); }); } GridSetBroker(); GridSetBroker(List<GridSetConfiguration> configurations); void afterPropertiesSet(); @Nullable GridSet get(String gridSetId); Set<String> getEmbeddedNames(); Set<String> getNames(); Set<String> getGridSetNames(); Collection<GridSet> getGridSets(); synchronized void put(GridSet gridSet); void addGridSet(GridSet gridSet); synchronized GridSet remove(final String gridSetName); synchronized void removeGridSet(final String gridSetName); DefaultGridsets getDefaults(); GridSet getWorldEpsg4326(); GridSet getWorldEpsg3857(); @SuppressWarnings("unchecked") List<? extends GSC> getConfigurations(
Class<GSC> type); @Override void setApplicationContext(ApplicationContext applicationContext); }### Answer:
@Test public void testRemoveGridset() throws IOException { String gridsetToRemove = GWCConfigIntegrationTestData.GRIDSET_EPSG2163; gridSetBroker.removeGridSet(gridsetToRemove); assertThat(gridSetBroker.getGridSetNames(), not(hasItem(gridsetToRemove))); assertThat(gridSetBroker.getGridSet(gridsetToRemove), notPresent()); } |
### Question:
TileLayerDispatcher implements DisposableBean,
InitializingBean,
ApplicationContextAware,
ConfigurationAggregator<TileLayerConfiguration> { public synchronized void addLayer(final TileLayer tl) throws IllegalArgumentException { for (TileLayerConfiguration c : configs) { if (c.canSave(tl)) { c.addLayer(tl); return; } } throw new IllegalArgumentException("No configuration found capable of saving " + tl); } TileLayerDispatcher(GridSetBroker gridSetBroker, List<TileLayerConfiguration> configs); TileLayerDispatcher(GridSetBroker gridSetBroker); boolean layerExists(final String layerName); TileLayer getTileLayer(final String layerName); int getLayerCount(); Set<String> getLayerNames(); @SuppressWarnings("unchecked") Iterable<TileLayer> getLayerList(); ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInformation); void destroy(); synchronized void removeLayer(final String layerName); synchronized void addLayer(final TileLayer tl); synchronized void rename(final String oldName, final String newName); synchronized void modify(final TileLayer tl); TileLayerConfiguration getConfiguration(TileLayer tl); TileLayerConfiguration getConfiguration(final String tileLayerName); synchronized void addGridSet(final GridSet gridSet); synchronized void removeGridSet(String gridsetToRemove); synchronized void removeGridSetRecursive(String gridsetToRemove); @SuppressWarnings("unchecked") @Override List<? extends T> getConfigurations(Class<T> clazz); @Override void afterPropertiesSet(); @Override void setApplicationContext(ApplicationContext applicationContext); void reInit(); }### Answer:
@Test public void testAddLayer() throws GeoWebCacheException { String layerName = "newLayer"; WMSLayer layer = new WMSLayer( layerName, new String[] {"http: null, null, null, null, null, null, null, false, null); tileLayerDispatcher.addLayer(layer); assertTrue(tileLayerDispatcher.getLayerNames().contains(layerName)); assertEquals(layer, tileLayerDispatcher.getTileLayer(layerName)); } |
### Question:
TileLayerDispatcher implements DisposableBean,
InitializingBean,
ApplicationContextAware,
ConfigurationAggregator<TileLayerConfiguration> { public synchronized void modify(final TileLayer tl) throws IllegalArgumentException { TileLayerConfiguration config = getConfiguration(tl); config.modifyLayer(tl); } TileLayerDispatcher(GridSetBroker gridSetBroker, List<TileLayerConfiguration> configs); TileLayerDispatcher(GridSetBroker gridSetBroker); boolean layerExists(final String layerName); TileLayer getTileLayer(final String layerName); int getLayerCount(); Set<String> getLayerNames(); @SuppressWarnings("unchecked") Iterable<TileLayer> getLayerList(); ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInformation); void destroy(); synchronized void removeLayer(final String layerName); synchronized void addLayer(final TileLayer tl); synchronized void rename(final String oldName, final String newName); synchronized void modify(final TileLayer tl); TileLayerConfiguration getConfiguration(TileLayer tl); TileLayerConfiguration getConfiguration(final String tileLayerName); synchronized void addGridSet(final GridSet gridSet); synchronized void removeGridSet(String gridsetToRemove); synchronized void removeGridSetRecursive(String gridsetToRemove); @SuppressWarnings("unchecked") @Override List<? extends T> getConfigurations(Class<T> clazz); @Override void afterPropertiesSet(); @Override void setApplicationContext(ApplicationContext applicationContext); void reInit(); }### Answer:
@Test public void testModifyBadLayer() { String layerName = "newLayer"; WMSLayer layer = new WMSLayer( layerName, new String[] {"http: null, null, null, null, null, null, null, false, null); try { tileLayerDispatcher.modify(layer); fail("Expected exception when modifiying nonexistant layer"); } catch (IllegalArgumentException e) { } try { tileLayerDispatcher.modify(null); fail("Expected exception when modifiying null layer"); } catch (IllegalArgumentException e) { } } |
### Question:
HelloControllerWithRepository { @GetMapping("/hello/data/{name}") public Hello sayHi(@PathVariable String name) { Optional<Person> foundPerson = personRepository.findByFirstName(name); String result = foundPerson .map(person -> String.format("Hello %s", person.getFirstName())) .orElse("Data not found"); return new Hello(result); } @Autowired HelloControllerWithRepository(PersonRepository personRepository); @GetMapping("/hello/data/{name}") Hello sayHi(@PathVariable String name); }### Answer:
@Test public void shouldReturnHelloSomkiat() { Person somkiat = new Person("somkiat", "pui"); given(personRepository.findByFirstName("somkiat")) .willReturn(Optional.of(somkiat)); Hello hello = controllerWithRepository.sayHi("somkiat"); assertEquals("Hello somkiat", hello.getMessage()); } |
### Question:
Hello { public String getMessage() { return message; } Hello(String message); String getMessage(); void setMessage(String message); }### Answer:
@Test public void success_to_create_model_with_constructor() { Hello hello = new Hello("Somkiat"); assertEquals("Somkiat", hello.getMessage()); } |
### Question:
HelloWithRepositoryController { @GetMapping("/hello/data/{name}") public Hello sayHi(@PathVariable String name) { Optional<Person> person = personRepository.findByFirstName(name); String message = person.map(person1 -> String.format("Hello %s", person1.getFirstName())) .orElse("Data not found"); return new Hello(message); } @Autowired HelloWithRepositoryController(PersonRepository personRepository); @GetMapping("/hello/data/{name}") Hello sayHi(@PathVariable String name); }### Answer:
@Test public void shouldReturnHelloSomkiat() { Person somkiat = new Person("somkiat", "pui"); given(personRepository.findByFirstName("somkiat")) .willReturn(Optional.of(somkiat)); Hello hello = controller.sayHi("somkiat"); assertEquals("Hello somkiat", hello.getMessage()); } |
### Question:
Hello { public String getMessage() { return message; } Hello(String message); String getMessage(); }### Answer:
@Test public void shouldReturnSomkiat() { Hello hello = new Hello("somkiat"); assertEquals("somkiat", hello.getMessage()); } |
### Question:
Recommendations extends SimpleBenchmark { public Map<Integer, List<Integer>> calculateRecommendations(int reps) { Map<Integer, List<Integer>> results = null; for (int i = 0; i < reps; i++) { results = lambdaRecommendations.calculateRecommendations(); } return results; } void setPurchases(Purchases purchases); Map<Integer, List<Integer>> calculateRecommendations(int reps); MutableMap<Integer, MutableList<Integer>> timeGSRecommendations(int reps); }### Answer:
@Test public void lambdaVariant() { LambdaRecommendations recommendations = new LambdaRecommendations(makePurchases()); Map<Integer, List<Integer>> results = recommendations.calculateRecommendations(); assertTrue("product 5 is similar to 4", recommendations.alsoBought(4, 1, results).contains(5)); assertTrue("product 4 is similar to 5", recommendations.alsoBought(5, 1, results).contains(4)); }
@Test public void imperativeVariant() { ImperativeRecommendations recommendations = new ImperativeRecommendations(makePurchases()); Map<Integer, List<Integer>> results = recommendations.calculateRecommendations(); List<Integer> similarTo4 = recommendations.alsoBought(4, 1, results); assertTrue("product 5 is similar to 4: " + similarTo4, similarTo4.contains(5)); assertTrue("product 4 is similar to 5", recommendations.alsoBought(5, 1, results).contains(4)); }
@Ignore @Test public void gsVariant() { GSLambdaRecommendations recommendations = new GSLambdaRecommendations(makePurchases()); MutableMap<Integer, MutableList<Integer>> results = recommendations.calculateRecommendations(); Assert.assertEquals(4, results.get(5).get(0).intValue()); Assert.assertEquals(5, results.get(4).get(0).intValue()); } |
### Question:
BaseController extends Controller { @NonNull @Override protected final View onCreateView(@NonNull LayoutInflater inflater, @NonNull ViewGroup container) { U view = createView(inflater, container); view.setController(getThis()); return view; } BaseController(); BaseController(@Nullable Bundle args); }### Answer:
@Test public void setView() { DummyView dummyView = (DummyView) dummyController.onCreateView(null, null); Assert.assertEquals(dummyController, dummyView.getController()); } |
### Question:
TasksPresenter implements TasksContract.Presenter { @Override public void addNewTask() { if (mTasksView != null) { mTasksView.showAddTask(); } } @Inject TasksPresenter(TasksRepository tasksRepository); @Override void result(int requestCode, int resultCode); @Override void loadTasks(boolean forceUpdate); @Override void addNewTask(); @Override void openTaskDetails(@NonNull Task requestedTask); @Override void completeTask(@NonNull Task completedTask); @Override void activateTask(@NonNull Task activeTask); @Override void clearCompletedTasks(); @Override TasksFilterType getFiltering(); @Override void setFiltering(TasksFilterType requestType); @Override void takeView(TasksContract.View view); @Override void dropView(); }### Answer:
@Test public void clickOnFab_ShowsAddTaskUi() { mTasksPresenter.addNewTask(); verify(mTasksView).showAddTask(); } |
### Question:
TasksPresenter implements TasksContract.Presenter { @Override public void openTaskDetails(@NonNull Task requestedTask) { checkNotNull(requestedTask, "requestedTask cannot be null!"); if (mTasksView != null) { mTasksView.showTaskDetailsUi(requestedTask.getId()); } } @Inject TasksPresenter(TasksRepository tasksRepository); @Override void result(int requestCode, int resultCode); @Override void loadTasks(boolean forceUpdate); @Override void addNewTask(); @Override void openTaskDetails(@NonNull Task requestedTask); @Override void completeTask(@NonNull Task completedTask); @Override void activateTask(@NonNull Task activeTask); @Override void clearCompletedTasks(); @Override TasksFilterType getFiltering(); @Override void setFiltering(TasksFilterType requestType); @Override void takeView(TasksContract.View view); @Override void dropView(); }### Answer:
@Test public void clickOnTask_ShowsDetailUi() { Task requestedTask = new Task("Details Requested", "For this task"); mTasksPresenter.openTaskDetails(requestedTask); verify(mTasksView).showTaskDetailsUi(any(String.class)); } |
### Question:
TasksPresenter implements TasksContract.Presenter { @Override public void completeTask(@NonNull Task completedTask) { checkNotNull(completedTask, "completedTask cannot be null!"); mTasksRepository.completeTask(completedTask); if (mTasksView != null) { mTasksView.showTaskMarkedComplete(); } loadTasks(false, false); } @Inject TasksPresenter(TasksRepository tasksRepository); @Override void result(int requestCode, int resultCode); @Override void loadTasks(boolean forceUpdate); @Override void addNewTask(); @Override void openTaskDetails(@NonNull Task requestedTask); @Override void completeTask(@NonNull Task completedTask); @Override void activateTask(@NonNull Task activeTask); @Override void clearCompletedTasks(); @Override TasksFilterType getFiltering(); @Override void setFiltering(TasksFilterType requestType); @Override void takeView(TasksContract.View view); @Override void dropView(); }### Answer:
@Test public void completeTask_ShowsTaskMarkedComplete() { Task task = new Task("Details Requested", "For this task"); mTasksPresenter.completeTask(task); verify(mTasksRepository).completeTask(task); verify(mTasksView).showTaskMarkedComplete(); } |
### Question:
TaskDetailPresenter implements TaskDetailContract.Presenter { @Override public void deleteTask() { if (Strings.isNullOrEmpty(mTaskId)) { if (mTaskDetailView != null) { mTaskDetailView.showMissingTask(); } return; } mTasksRepository.deleteTask(mTaskId); if (mTaskDetailView != null) { mTaskDetailView.showTaskDeleted(); } } @Inject TaskDetailPresenter(@Nullable String taskId,
TasksRepository tasksRepository); @Override void editTask(); @Override void deleteTask(); @Override void completeTask(); @Override void activateTask(); @Override void takeView(TaskDetailContract.View taskDetailView); @Override void dropView(); }### Answer:
@Test public void deleteTask() { Task task = new Task(TITLE_TEST, DESCRIPTION_TEST); mTaskDetailPresenter = new TaskDetailPresenter( task.getId(), mTasksRepository); mTaskDetailPresenter.takeView(mTaskDetailView); mTaskDetailPresenter.deleteTask(); verify(mTasksRepository).deleteTask(task.getId()); verify(mTaskDetailView).showTaskDeleted(); } |
### Question:
TaskDetailPresenter implements TaskDetailContract.Presenter { @Override public void completeTask() { if (Strings.isNullOrEmpty(mTaskId)) { if (mTaskDetailView != null) { mTaskDetailView.showMissingTask(); } return; } mTasksRepository.completeTask(mTaskId); if (mTaskDetailView != null) { mTaskDetailView.showTaskMarkedComplete(); } } @Inject TaskDetailPresenter(@Nullable String taskId,
TasksRepository tasksRepository); @Override void editTask(); @Override void deleteTask(); @Override void completeTask(); @Override void activateTask(); @Override void takeView(TaskDetailContract.View taskDetailView); @Override void dropView(); }### Answer:
@Test public void completeTask() { Task task = new Task(TITLE_TEST, DESCRIPTION_TEST); mTaskDetailPresenter = new TaskDetailPresenter( task.getId(), mTasksRepository); mTaskDetailPresenter.takeView(mTaskDetailView); mTaskDetailPresenter.completeTask(); verify(mTasksRepository).completeTask(task.getId()); verify(mTaskDetailView).showTaskMarkedComplete(); } |
### Question:
TaskDetailPresenter implements TaskDetailContract.Presenter { @Override public void activateTask() { if (Strings.isNullOrEmpty(mTaskId)) { if (mTaskDetailView != null) { mTaskDetailView.showMissingTask(); } return; } mTasksRepository.activateTask(mTaskId); if (mTaskDetailView != null) { mTaskDetailView.showTaskMarkedActive(); } } @Inject TaskDetailPresenter(@Nullable String taskId,
TasksRepository tasksRepository); @Override void editTask(); @Override void deleteTask(); @Override void completeTask(); @Override void activateTask(); @Override void takeView(TaskDetailContract.View taskDetailView); @Override void dropView(); }### Answer:
@Test public void activateTask() { Task task = new Task(TITLE_TEST, DESCRIPTION_TEST, true); mTaskDetailPresenter = new TaskDetailPresenter( task.getId(), mTasksRepository); mTaskDetailPresenter.takeView(mTaskDetailView); mTaskDetailPresenter.activateTask(); verify(mTasksRepository).activateTask(task.getId()); verify(mTaskDetailView).showTaskMarkedActive(); } |
### Question:
TasksRepository implements TasksDataSource { @Override public void saveTask(@NonNull Task task) { checkNotNull(task); mTasksRemoteDataSource.saveTask(task); mTasksLocalDataSource.saveTask(task); if (mCachedTasks == null) { mCachedTasks = new LinkedHashMap<>(); } mCachedTasks.put(task.getId(), task); } private TasksRepository(@NonNull TasksDataSource tasksRemoteDataSource,
@NonNull TasksDataSource tasksLocalDataSource); static TasksRepository getInstance(@NonNull TasksDataSource tasksRemoteDataSource,
@NonNull TasksDataSource tasksLocalDataSource); static void destroyInstance(); @Override Flowable<List<Task>> getTasks(); @Override void saveTask(@NonNull Task task); @Override void completeTask(@NonNull Task task); @Override void completeTask(@NonNull String taskId); @Override void activateTask(@NonNull Task task); @Override void activateTask(@NonNull String taskId); @Override void clearCompletedTasks(); @Override Flowable<Optional<Task>> getTask(@NonNull final String taskId); @Override void refreshTasks(); @Override void deleteAllTasks(); @Override void deleteTask(@NonNull String taskId); }### Answer:
@Test public void saveTask_savesTaskToServiceAPI() { Task newTask = new Task(TASK_TITLE, "Some Task Description"); mTasksRepository.saveTask(newTask); verify(mTasksRemoteDataSource).saveTask(newTask); verify(mTasksLocalDataSource).saveTask(newTask); assertThat(mTasksRepository.mCachedTasks.size(), is(1)); } |
### Question:
ByteArrayDequeue { public void push(byte[] src) { push(src, 0, src.length); } ByteArrayDequeue(); ByteArrayDequeue(int initalCapacity); int getRemaining(); void push(byte[] src); void push(byte[] src, int srcOffset, int srcLengthToPush); void pushLast(byte[] src); void pushLast(byte[] src, int srcOffset, int srcLengthToPush); ByteBuffer popMaximum(int maximumLengthToPop); ByteBuffer popExactly(int lengthToPop); void popExactly(byte[] into); void clear(); }### Answer:
@Test public void testCombineArrays() { for (int i = 0; i < 200; i++) { push("ABCDEFGH"); push("IJK"); assertEquals("ABCDE", pop(5)); assertEquals("FGHIJK", pop(6)); } } |
### Question:
ClassUtils { public static String getMethodsList(Class<?> type) { final String SEPARATOR = ","; final List<Method> methods = Arrays.asList(type.getDeclaredMethods()); StringBuilder result = new StringBuilder(); Collections.sort(methods, (o1, o2) -> o1.getName().compareToIgnoreCase(o2.getName())); for (Method method : methods) { int modifiers = method.getModifiers(); if (Modifier.isAbstract(modifiers)) { result.append(method.getName()).append(SEPARATOR); } } return result.deleteCharAt(result.length() - 1).toString(); } static String getMethodsList(Class<?> type); }### Answer:
@Test public void testGetFieldsReturnsCorrectString_forAutoValueClass() { String detectedAVFields = ClassUtils.getMethodsList(ComicVolumeInfoList.class); String actualFields = "count_of_issues,id,image,name,publisher,start_year"; assertEquals("getMethodsList method returned incorrect list!", actualFields, detectedAVFields); } |
### Question:
IssueTextUtils { public static String getFormattedIssueName(String issue, String volume, int number) { String name; if (issue != null) { name = String.format(Locale.US, "%s #%d - %s", volume, number, issue); } else { name = String.format(Locale.US, "%s #%d", volume, number); } return name; } static String getFormattedIssueName(String issue, String volume, int number); static String getFormattedIssueTitle(String volume, int number); }### Answer:
@Test public void testGetFormattedIssueName() { assertEquals("getFormattedIssueName method returned incorrect string!", FORMATTED_NAME_FULL, IssueTextUtils.getFormattedIssueName(ISSUE_NAME, VOLUME_NAME, ISSUE_NUMBER)); assertEquals("getFormattedIssueName method returned incorrect string!", FORMATTED_NAME_SHORT, IssueTextUtils.getFormattedIssueName(null, VOLUME_NAME, ISSUE_NUMBER)); } |
### Question:
IssueTextUtils { public static String getFormattedIssueTitle(String volume, int number) { return String.format(Locale.US, "%s #%d", volume, number); } static String getFormattedIssueName(String issue, String volume, int number); static String getFormattedIssueTitle(String volume, int number); }### Answer:
@Test public void testGetFormattedIssueDetailsTitle() { assertEquals("getFormattedIssueTitle method returned incorrect string!", FORMATTED_NAME_SHORT, IssueTextUtils.getFormattedIssueTitle(VOLUME_NAME, ISSUE_NUMBER)); } |
### Question:
SparkVerifier { static int getMaximumNumberOfGroups(BoundedDouble approxCountBoundedDouble, int maxGroupSize) { long countApprox = Math.round(approxCountBoundedDouble.mean()); LOGGER.info("Approximate count of expected results: " + countApprox); LOGGER.info("Maximum group size: " + maxGroupSize); long maximumNumberOfGroups = Math.max(1, countApprox / maxGroupSize); if (maximumNumberOfGroups > Integer.MAX_VALUE) { throw new IllegalStateException("Invalid max group size: " + maximumNumberOfGroups); } return (int) maximumNumberOfGroups; } SparkVerifier(List<String> groupKeyColumns); final SparkVerifier withMetadata(String name, String value); SparkVerifier withIgnoreSurplusColumns(boolean ignoreSurplusColumns); SparkVerifier withColumnsToIgnore(Set<String> columnsToIgnore); SparkVerifier withTolerance(double tolerance); SparkVerifier withTolerance(String columnName, double tolerance); SparkVerifier withMaxGroupSize(int maxGroupSize); SparkResult verify(String dataName, Supplier<DistributedTable> actualDataSupplier, Supplier<DistributedTable> expectedDataSupplier); }### Answer:
@Test public void getMaximumNumberOfGroups() { Assert.assertEquals(1, SparkVerifier.getMaximumNumberOfGroups(new BoundedDouble(100.0, 50.0, 0.0, 200.0), 10_000)); Assert.assertEquals(5, SparkVerifier.getMaximumNumberOfGroups(new BoundedDouble(100.0, 50.0, 0.0, 200.0), 20)); Assert.assertEquals(100, SparkVerifier.getMaximumNumberOfGroups(new BoundedDouble(100.0, 50.0, 0.0, 200.0), 1)); } |
### Question:
TableAdapters { public static VerifiableTable withRows(VerifiableTable delegate, IntPredicate rowFilter) { return new RowFilterAdapter(delegate, rowFilter); } private TableAdapters(); static VerifiableTable withRows(VerifiableTable delegate, IntPredicate rowFilter); static VerifiableTable withColumns(VerifiableTable delegate, Predicate<String> columnFilter); }### Answer:
@Test public void testAllRows() { this.verify( TableTestUtils.createTable(1, "C", 1, 2, 3, 4, 5), TableAdapters.withRows(TableTestUtils.createTable(1, "C", 1, 2, 3, 4, 5), i -> true)); }
@Test public void testNoRows() { VerifiableTable table = TableTestUtils.createTable(1, "C", 1, 2, 3, 4, 5); this.verify( TableTestUtils.createTable(1, "C"), TableAdapters.withRows(table, i -> false)); }
@Test public void testSomeRows() { VerifiableTable table = TableTestUtils.createTable(1, "C", 1, 2, 3, 4, 5); this.verify( TableTestUtils.createTable(1, "C", 2, 4), TableAdapters.withRows(table, i -> (Integer) table.getValueAt(i, 0) % 2 == 0)); } |
### Question:
TableAdapters { public static VerifiableTable withColumns(VerifiableTable delegate, Predicate<String> columnFilter) { return new ColumnFilterAdapter(delegate, columnFilter); } private TableAdapters(); static VerifiableTable withRows(VerifiableTable delegate, IntPredicate rowFilter); static VerifiableTable withColumns(VerifiableTable delegate, Predicate<String> columnFilter); }### Answer:
@Test public void testAllColumns() { this.verify( TableTestUtils.createTable(5, "C1", "C2", "C3", "C4", "C5"), TableAdapters.withColumns(TableTestUtils.createTable(5, "C1", "C2", "C3", "C4", "C5"), name -> true)); }
@Test public void testSomeColumns() { this.verify( TableTestUtils.createTable(3, "C1", "C3", "C5"), TableAdapters.withColumns(TableTestUtils.createTable(5, "C1", "C2", "C3", "C4", "C5"), name -> name.matches("C[135]"))); } |
### Question:
ExpectedResultsParser { public ExpectedResults parse() { this.results = new ExpectedResults(); try (InputStream inputStream = this.loader.load(this.file)) { BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)); parse(reader); return this.results; } catch (IOException e) { throw new RuntimeException(e); } catch (ParseException e) { throw new RuntimeException("Parsing error reading '" + this.file + '\'', e); } } ExpectedResultsParser(ExpectedResultsLoader loader, File file); ExpectedResults parse(); }### Answer:
@Test public void testParse() { File expected = new File(TableTestUtils.getExpectedDirectory(), ExpectedResultsParserTest.class.getSimpleName() + ".txt"); ExpectedResults results = new ExpectedResultsParser(new FileSystemExpectedResultsLoader(), expected).parse(); VerifiableTable summary = results.getTable("Summary"); Assert.assertEquals(6, summary.getColumnCount()); Assert.assertEquals(5, summary.getRowCount()); VerifiableTable drillDown = results.getTable("DrillDown"); Assert.assertEquals(6, drillDown.getColumnCount()); Assert.assertEquals(1, drillDown.getRowCount()); Assert.assertEquals(2, results.getMetadata().getData().size()); Assert.assertEquals(Collections.singletonMap("Recorded At", "2013-06-26 12:00:00").entrySet().iterator().next(), results.getMetadata().getData().get(0)); Assert.assertEquals(Collections.singletonMap("App Server URL", "http: }
@Test public void testMissingExpectedResultsFileResultsInClearErrorMessage() { String missingFileName = "missing-expected-results.txt"; try { new ExpectedResultsParser(new FileSystemExpectedResultsLoader(), new File(missingFileName)).parse(); Assert.fail("Should have failed looking for non-existent file"); } catch (IllegalStateException expected) { Assert.assertTrue(expected.getMessage().contains(missingFileName)); } } |
### Question:
ExpectedResultsParser { ExpectedResults getExpectedResults() { return this.results; } ExpectedResultsParser(ExpectedResultsLoader loader, File file); ExpectedResults parse(); }### Answer:
@Test public void testCache() { File expected = new File(TableTestUtils.getExpectedDirectory(), ExpectedResultsParserTest.class.getSimpleName() + ".txt"); Map<ExpectedResults, String> results = new IdentityHashMap<>(); for (int i = 0; i < 10; i++) { results.put(ExpectedResultsCache.getExpectedResults(new FileSystemExpectedResultsLoader(), expected), ""); } Assert.assertTrue("cache was hit at least once", results.size() < 10); } |
### Question:
ResultSetTable { public static VerifiableTable create(ResultSet resultSet) throws SQLException { ResultSetMetaData metaData = resultSet.getMetaData(); int columnCount = metaData.getColumnCount(); List<String> headers = new ArrayList<>(columnCount); for (int n = 1; n <= columnCount; n++) { headers.add(metaData.getColumnName(n)); } List<List> rows = new ArrayList<>(); while (resultSet.next()) { List<Object> row = new ArrayList<>(columnCount); for (int n = 1; n <= columnCount; n++) { row.add(resultSet.getObject(n)); } rows.add(row); } return ListVerifiableTable.create(headers, rows); } private ResultSetTable(); static VerifiableTable create(ResultSet resultSet); }### Answer:
@Test public void create() throws SQLException { SimpleResultSet resultSet = new SimpleResultSet(); resultSet.addColumn("Name", Types.VARCHAR, 0, 0); resultSet.addColumn("Age", Types.INTEGER, 0, 0); resultSet.addColumn("Height", Types.DOUBLE, 0, 0); resultSet.addColumn("DoB", Types.DATE, 0, 0); resultSet.addRow("Joe", 70, 6.0, Date.valueOf("1940-02-16")); resultSet.addRow("Sue", 45, 5.8, Date.valueOf("1975-02-16")); VerifiableTable expected = new TestTable("Name", "Age", "Height", "DoB") .withRow("Joe", 70, 6.0, Date.valueOf("1940-02-16")) .withRow("Sue", 45, 5.8, Date.valueOf("1975-02-16")); VerifiableTable actual = ResultSetTable.create(resultSet); this.tableVerifier.verify( Collections.singletonList(new NamedTable("table", expected)), Collections.singletonList(new NamedTable("table", actual))); } |
### Question:
ListVerifiableTable implements VerifiableTable { @Override public int getRowCount() { return this.data.size(); } ListVerifiableTable(List<List<Object>> headersAndData); ListVerifiableTable(List<?> headers, List<List<Object>> data); static VerifiableTable create(Iterable<List> headersAndRows); static VerifiableTable create(List<String> headers, Iterable<List> rows); @Override int getRowCount(); @Override int getColumnCount(); @Override String getColumnName(int columnIndex); @Override Object getValueAt(int rowIndex, int columnIndex); }### Answer:
@Test public void testHeaderTypes() throws Exception { List<Object> headersAsObjects = Collections.singletonList("Col"); List<List<Object>> headersAndDataAsObjects = Arrays.asList(headersAsObjects, Collections.<Object>singletonList("Val")); Assert.assertEquals("Test constructor with headers and rows in one List<List<Object>>", 1, new ListVerifiableTable(headersAndDataAsObjects).getRowCount()); Assert.assertEquals("Test constructor with headers as List<Object>", 2, new ListVerifiableTable(headersAsObjects, headersAndDataAsObjects).getRowCount()); List<String> headersAsStrings = Collections.singletonList("Col"); Assert.assertEquals("Test cast that used to be necessary for headers as List<String>", 2, new ListVerifiableTable((List) headersAsStrings, headersAndDataAsObjects).getRowCount()); Assert.assertEquals("Test headers as List<String> can now be passed in as-is", 2, new ListVerifiableTable(headersAsStrings, headersAndDataAsObjects).getRowCount()); } |
### Question:
ListVerifiableTable implements VerifiableTable { public static VerifiableTable create(Iterable<List> headersAndRows) { Iterator<List> iterator = headersAndRows.iterator(); List headers = iterator.next(); headers.forEach(ListVerifiableTable::verifyHeader); List rowList = new ArrayList(); iterator.forEachRemaining(verifyRowSize(headers).andThen(rowList::add)); return new ListVerifiableTable(headers, rowList); } ListVerifiableTable(List<List<Object>> headersAndData); ListVerifiableTable(List<?> headers, List<List<Object>> data); static VerifiableTable create(Iterable<List> headersAndRows); static VerifiableTable create(List<String> headers, Iterable<List> rows); @Override int getRowCount(); @Override int getColumnCount(); @Override String getColumnName(int columnIndex); @Override Object getValueAt(int rowIndex, int columnIndex); }### Answer:
@Test(expected = IllegalArgumentException.class) public void createList_headersNotStrings() { ListVerifiableTable.create(Arrays.asList(Arrays.asList('A', 'B'), Arrays.asList(1, 2))); }
@Test(expected = IllegalArgumentException.class) public void createList_wrongRowSize() { ListVerifiableTable.create(Arrays.asList(Arrays.asList("A", "B"), Arrays.asList(1, 2), Collections.singletonList(3))); }
@Test(expected = IllegalArgumentException.class) public void createHeadersAndList_wrongRowSize() { ListVerifiableTable.create(Arrays.asList("A", "B"), Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4, 5))); }
@Test(expected = IllegalArgumentException.class) public void createHeadersAndIterable_wrongRowSize() { ListVerifiableTable.create(Arrays.asList("A", "B"), new LinkedHashSet<>(Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4, 5)))); } |
### Question:
CellFormatter implements Function<Object, String>, Serializable { private String formatString(String untrimmedValue) { String value = untrimmedValue.trim(); this.builder.setLength(0); boolean changed = false; for (int i = 0; i < value.length(); i++) { char c = value.charAt(i); if (Character.isWhitespace(c)) { this.builder.append(' '); if (c != ' ') { changed = true; } } else { this.builder.append(c); } } return changed ? this.builder.toString() : value; } CellFormatter(double tolerance, boolean isGroupingUsed); @Override String apply(Object object); String format(Object value); }### Answer:
@Test public void formatString() { CellFormatter formatter = new CellFormatter(0, false); Assert.assertEquals("", formatter.format("")); Assert.assertEquals("foo", formatter.format("foo")); Assert.assertEquals("foo", formatter.format(" foo ")); Assert.assertEquals("foo bar", formatter.format("foo bar")); Assert.assertEquals("foo bar", formatter.format("foo bar")); Assert.assertEquals("foo bar", formatter.format("foo\nbar ")); Assert.assertEquals("foo bar", formatter.format(" foo\rbar")); Assert.assertEquals("foo bar", formatter.format(" foo\r \nbar ")); Assert.assertEquals("foo", formatter.format("foo\r")); Assert.assertEquals("foo", formatter.format("\n foo")); Assert.assertEquals("", formatter.format("\n \r ")); Assert.assertEquals("", formatter.format(" \n \r")); } |
### Question:
ExceptionHtml { static String stackTraceToString(Throwable e) throws UnsupportedEncodingException { ByteArrayOutputStream bytes = new ByteArrayOutputStream(); PrintStream out = new PrintStream(bytes, false, "UTF-8"); stackTraceToString(e, out); out.close(); return bytes.toString("UTF-8"); } private ExceptionHtml(); static void create(File resultsFile, Throwable reason); }### Answer:
@Test public void testException() throws IOException { String stackTraceToString = ExceptionHtml.stackTraceToString(new RuntimeException(new IllegalArgumentException(new UnsupportedOperationException()))); List<Map.Entry<String, List<String>>> stackTraces = getStackLineCount(stackTraceToString); Assert.assertEquals(3, stackTraces.size()); Assert.assertEquals(RuntimeException.class.getName() + ": " + IllegalArgumentException.class.getName() + ": " + UnsupportedOperationException.class.getName(), stackTraces.get(0).getKey()); Assert.assertTrue(stackTraces.get(0).getValue().size() > 1); Assert.assertEquals("Caused by: " + IllegalArgumentException.class.getName() + ": " + UnsupportedOperationException.class.getName(), stackTraces.get(1).getKey()); Assert.assertTrue(stackTraces.get(1).getValue().size() > 1); Assert.assertEquals("Caused by: " + UnsupportedOperationException.class.getName(), stackTraces.get(2).getKey()); Assert.assertTrue(stackTraces.get(2).getValue().size() > 1); } |
### Question:
UnmatchedIndexMap extends IndexMap { public void addMatch(int matchScore, UnmatchedIndexMap match) { if (this.equals(match)) { throw new IllegalArgumentException("Cannot add this as partial match"); } if (this.partialMatches == null) { this.partialMatches = new TreeSet<>(); } if (match.partialMatches == null) { match.partialMatches = new TreeSet<>(); } if (this.getExpectedIndex() < 0 || match.getActualIndex() < 0) { throw new IllegalStateException("Expecting this to be expected and that to be actual"); } this.partialMatches.add(new Match(matchScore, match)); match.partialMatches.add(new Match(matchScore, this)); } UnmatchedIndexMap(int expectedIndex, int actualIndex); void addMatch(int matchScore, UnmatchedIndexMap match); boolean match(); UnmatchedIndexMap getBestMutualMatch(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testAddPartialMatchFailsIfSelf() { this.unmatched.addMatch(2, this.unmatched); } |
### Question:
UnmatchedIndexMap extends IndexMap { public UnmatchedIndexMap getBestMutualMatch() { return this.bestMutualMatch; } UnmatchedIndexMap(int expectedIndex, int actualIndex); void addMatch(int matchScore, UnmatchedIndexMap match); boolean match(); UnmatchedIndexMap getBestMutualMatch(); }### Answer:
@Test public void testInitialState() { Assert.assertNull(this.unmatched.getBestMutualMatch()); } |
### Question:
IndexMap implements Comparable<IndexMap> { @Override public int compareTo(IndexMap that) { if (this.equals(that)) { return 0; } if (this.isMatched()) { if (that.actualIndex >= 0) { return compareUnequals(this.actualIndex, that.actualIndex, this.isSurplus()); } return compareUnequals(this.expectedIndex, that.expectedIndex, this.isSurplus()); } if (this.isSurplus()) { if (that.actualIndex >= 0) { return compareUnequals(this.actualIndex, that.actualIndex, this.isSurplus()); } return compareUnequals(this.actualIndex, that.expectedIndex, this.isSurplus()); } if (that.expectedIndex >= 0) { return compareUnequals(this.expectedIndex, that.expectedIndex, this.isSurplus()); } return compareUnequals(this.expectedIndex, that.actualIndex, this.isSurplus()); } IndexMap(int expectedIndex, int actualIndex); @Override boolean equals(Object obj); @Override int hashCode(); @Override int compareTo(IndexMap that); boolean isMissing(); boolean isSurplus(); boolean isMatched(); @Override String toString(); }### Answer:
@Test public void compareTo1() { IndexMap im1 = new IndexMap(1, 2); IndexMap im2 = new IndexMap(2, 1); Assert.assertTrue(im1.compareTo(im2) > 0); Assert.assertTrue(im2.compareTo(im1) < 0); }
@Test public void compareTo2() { IndexMap im1 = new IndexMap(1, 2); IndexMap im2 = new IndexMap(2, -1); Assert.assertTrue(im1.compareTo(im2) < 0); Assert.assertTrue(im2.compareTo(im1) > 0); } |
### Question:
JAXWSBundle implements ConfiguredBundle<C> { public Endpoint publishEndpoint(EndpointBuilder endpointBuilder) { checkArgument(endpointBuilder != null, "EndpointBuilder is null"); return this.jaxwsEnvironment.publishEndpoint(endpointBuilder); } JAXWSBundle(); JAXWSBundle(String servletPath); JAXWSBundle(String servletPath, JAXWSEnvironment jaxwsEnvironment); @Override void initialize(Bootstrap<?> bootstrap); @Override void run(C configuration, Environment environment); Endpoint publishEndpoint(EndpointBuilder endpointBuilder); Endpoint publishEndpoint(String path, Object service); Endpoint publishEndpoint(String path, Object service, SessionFactory sessionFactory); Endpoint publishEndpoint(String path, Object service, BasicAuthentication authentication); Endpoint publishEndpoint(String path, Object service, BasicAuthentication auth,
SessionFactory sessionFactory); @Deprecated T getClient(Class<T> serviceClass, String address, Handler...handlers); T getClient(ClientBuilder<T> clientBuilder); }### Answer:
@Test public void publishEndpoint() { JAXWSBundle<?> jaxwsBundle = new JAXWSBundle<>("/soap", jaxwsEnvironment); Object service = new Object(); try { jaxwsBundle.publishEndpoint(new EndpointBuilder("foo", null)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } try { jaxwsBundle.publishEndpoint(new EndpointBuilder(null, service)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } try { jaxwsBundle.publishEndpoint(new EndpointBuilder(" ", service)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } EndpointBuilder builder = mock(EndpointBuilder.class); jaxwsBundle.publishEndpoint(builder); verify(jaxwsEnvironment).publishEndpoint(builder); } |
### Question:
JAXWSBundle implements ConfiguredBundle<C> { @Deprecated public <T> T getClient(Class<T> serviceClass, String address, Handler...handlers) { checkArgument(serviceClass != null, "ServiceClass is null"); checkArgument(address != null, "Address is null"); checkArgument((address).trim().length() > 0, "Address is empty"); return jaxwsEnvironment.getClient( new ClientBuilder<>(serviceClass, address).handlers(handlers)); } JAXWSBundle(); JAXWSBundle(String servletPath); JAXWSBundle(String servletPath, JAXWSEnvironment jaxwsEnvironment); @Override void initialize(Bootstrap<?> bootstrap); @Override void run(C configuration, Environment environment); Endpoint publishEndpoint(EndpointBuilder endpointBuilder); Endpoint publishEndpoint(String path, Object service); Endpoint publishEndpoint(String path, Object service, SessionFactory sessionFactory); Endpoint publishEndpoint(String path, Object service, BasicAuthentication authentication); Endpoint publishEndpoint(String path, Object service, BasicAuthentication auth,
SessionFactory sessionFactory); @Deprecated T getClient(Class<T> serviceClass, String address, Handler...handlers); T getClient(ClientBuilder<T> clientBuilder); }### Answer:
@Test public void getClient() { JAXWSBundle<?> jaxwsBundle = new JAXWSBundle<>("/soap", jaxwsEnvironment); Class<?> cls = Object.class; String url = "http: try { jaxwsBundle.getClient(new ClientBuilder<>(null, null)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } try { jaxwsBundle.getClient(new ClientBuilder<>(null, url)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } try { jaxwsBundle.getClient(new ClientBuilder<>(cls, " ")); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } ClientBuilder<?> builder = new ClientBuilder<>(cls, url); jaxwsBundle.getClient(builder); verify(jaxwsEnvironment).getClient(builder); } |
### Question:
JAXWSEnvironment { public HttpServlet buildServlet() { CXFNonSpringServlet cxf = new CXFNonSpringServlet(); cxf.setBus(bus); return cxf; } JAXWSEnvironment(String defaultPath); String getDefaultPath(); HttpServlet buildServlet(); void setPublishedEndpointUrlPrefix(String publishedEndpointUrlPrefix); void setInstrumentedInvokerBuilder(InstrumentedInvokerFactory instrumentedInvokerBuilder); void setUnitOfWorkInvokerBuilder(UnitOfWorkInvokerFactory unitOfWorkInvokerBuilder); void logEndpoints(); Endpoint publishEndpoint(EndpointBuilder endpointBuilder); T getClient(ClientBuilder<T> clientBuilder); }### Answer:
@Test public void buildServlet() { Object result = jaxwsEnvironment.buildServlet(); assertThat(result, is(instanceOf(CXFNonSpringServlet.class))); assertThat(((CXFNonSpringServlet) result).getBus(), is(instanceOf(Bus.class))); } |
### Question:
CertificateEnrollmentDao extends AbstractModelDao<CertificateEnrollment> implements ReadDao<CertificateEnrollment> { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateEnrollmentDao clone() { try { return new CertificateEnrollmentDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateEnrollmentDao(); CertificateEnrollmentDao(ApiClientWrapper client); CertificateEnrollmentDao(ConnectionOptions options); CertificateEnrollmentDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateEnrollmentDao clone(); @Override CertificateEnrollment read(); CertificateEnrollment read(@NonNull CertificateEnrollment certificateEnrollment); @Override CertificateEnrollment read(@NonNull String id); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { CertificateEnrollmentDao certificateenrollmentdao1 = new CertificateEnrollmentDao(); CertificateEnrollmentDao certificateenrollmentdao2 = certificateenrollmentdao1.clone(); assertNotNull(certificateenrollmentdao1); assertNotNull(certificateenrollmentdao2); assertNotSame(certificateenrollmentdao2, certificateenrollmentdao1); assertEquals(certificateenrollmentdao2, certificateenrollmentdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
PreSharedKeyDao extends AbstractPreSharedKeyDao { @Override @SuppressWarnings({ "resource", "unused" }) public PreSharedKeyDao clone() { try { return new PreSharedKeyDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } PreSharedKeyDao(); PreSharedKeyDao(ApiClientWrapper client); PreSharedKeyDao(ConnectionOptions options); PreSharedKeyDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) PreSharedKeyDao clone(); @Override @NotImplemented PreSharedKey create(); @Override @NotImplemented PreSharedKey create(PreSharedKey modelToCreate); void create(PreSharedKey modelToCreate, @NonNull String secretHex); @Override @NotImplemented void delete(PreSharedKey modelToDelete); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { PreSharedKeyDao presharedkeydao1 = new PreSharedKeyDao(); PreSharedKeyDao presharedkeydao2 = presharedkeydao1.clone(); assertNotNull(presharedkeydao1); assertNotNull(presharedkeydao2); assertNotSame(presharedkeydao2, presharedkeydao1); assertEquals(presharedkeydao2, presharedkeydao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
CertificateEnrollmentListDao extends
AbstractModelListDao<CertificateEnrollment, CertificateEnrollmentListOptions> implements
ModelListDao<CertificateEnrollment, CertificateEnrollmentListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateEnrollmentListDao clone() { try { return new CertificateEnrollmentListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateEnrollmentListDao(); CertificateEnrollmentListDao(ApiClientWrapper client); CertificateEnrollmentListDao(ConnectionOptions options); CertificateEnrollmentListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateEnrollmentListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<CertificateEnrollmentDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) CertificateEnrollmentDao getNewModelDao(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { CertificateEnrollmentListDao certificateenrollmentlistdao1 = new CertificateEnrollmentListDao(); CertificateEnrollmentListDao certificateenrollmentlistdao2 = certificateenrollmentlistdao1.clone(); assertNotNull(certificateenrollmentlistdao1); assertNotNull(certificateenrollmentlistdao2); assertNotSame(certificateenrollmentlistdao2, certificateenrollmentlistdao1); assertEquals(certificateenrollmentlistdao2, certificateenrollmentlistdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
CertificateIssuerConfigListDao extends
AbstractModelListDao<CertificateIssuerConfig,
CertificateIssuerConfigListOptions> implements
ModelListDao<CertificateIssuerConfig, CertificateIssuerConfigListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateIssuerConfigListDao clone() { try { return new CertificateIssuerConfigListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateIssuerConfigListDao(); CertificateIssuerConfigListDao(ApiClientWrapper client); CertificateIssuerConfigListDao(ConnectionOptions options); CertificateIssuerConfigListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateIssuerConfigListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<CertificateIssuerConfigDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) CertificateIssuerConfigDao getNewModelDao(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { CertificateIssuerConfigListDao certificateissuerconfiglistdao1 = new CertificateIssuerConfigListDao(); CertificateIssuerConfigListDao certificateissuerconfiglistdao2 = certificateissuerconfiglistdao1.clone(); assertNotNull(certificateissuerconfiglistdao1); assertNotNull(certificateissuerconfiglistdao2); assertNotSame(certificateissuerconfiglistdao2, certificateissuerconfiglistdao1); assertEquals(certificateissuerconfiglistdao2, certificateissuerconfiglistdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
CertificateIssuerConfigDao extends AbstractModelDao<CertificateIssuerConfig> implements CrudDao<CertificateIssuerConfig> { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateIssuerConfigDao clone() { try { return new CertificateIssuerConfigDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateIssuerConfigDao(); CertificateIssuerConfigDao(ApiClientWrapper client); CertificateIssuerConfigDao(ConnectionOptions options); CertificateIssuerConfigDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateIssuerConfigDao clone(); @Override CertificateIssuerConfig create(); @Override CertificateIssuerConfig create(@NonNull CertificateIssuerConfig createCertificateIssuerConfig); @Override void delete(); @Override void delete(@NonNull CertificateIssuerConfig certificateIssuerConfig); @Override void delete(@NonNull String id); CertificateIssuerConfig getDefault(); @Override CertificateIssuerConfig read(); CertificateIssuerConfig read(@NonNull CertificateIssuerConfig certificateIssuerConfig); @Override CertificateIssuerConfig read(@NonNull String id); @Override CertificateIssuerConfig update(); CertificateIssuerConfig update(@NonNull CertificateIssuerConfig certificateIssuerConfigRequest,
@NonNull String id); @Override CertificateIssuerConfig update(@NonNull CertificateIssuerConfig certificateIssuerConfig); CertificateIssuerConfig update(@NonNull String id); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { CertificateIssuerConfigDao certificateissuerconfigdao1 = new CertificateIssuerConfigDao(); CertificateIssuerConfigDao certificateissuerconfigdao2 = certificateissuerconfigdao1.clone(); assertNotNull(certificateissuerconfigdao1); assertNotNull(certificateissuerconfigdao2); assertNotSame(certificateissuerconfigdao2, certificateissuerconfigdao1); assertEquals(certificateissuerconfigdao2, certificateissuerconfigdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
ServerCredentialsDao extends AbstractModelDao<ServerCredentials> { @Override @SuppressWarnings({ "resource", "unused" }) public ServerCredentialsDao clone() { try { return new ServerCredentialsDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } ServerCredentialsDao(); ServerCredentialsDao(ApiClientWrapper client); ServerCredentialsDao(ConnectionOptions options); ServerCredentialsDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) ServerCredentialsDao clone(); ServerCredentials getBootstrap(); ServerCredentials getLwm2m(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { ServerCredentialsDao servercredentialsdao1 = new ServerCredentialsDao(); ServerCredentialsDao servercredentialsdao2 = servercredentialsdao1.clone(); assertNotNull(servercredentialsdao1); assertNotNull(servercredentialsdao2); assertNotSame(servercredentialsdao2, servercredentialsdao1); assertEquals(servercredentialsdao2, servercredentialsdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
TrustedCertificateListDao extends AbstractModelListDao<TrustedCertificate, TrustedCertificateListOptions> implements ModelListDao<TrustedCertificate, TrustedCertificateListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public TrustedCertificateListDao clone() { try { return new TrustedCertificateListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } TrustedCertificateListDao(); TrustedCertificateListDao(ApiClientWrapper client); TrustedCertificateListDao(ConnectionOptions options); TrustedCertificateListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) TrustedCertificateListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<TrustedCertificateDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) TrustedCertificateDao getNewModelDao(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { TrustedCertificateListDao trustedcertificatelistdao1 = new TrustedCertificateListDao(); TrustedCertificateListDao trustedcertificatelistdao2 = trustedcertificatelistdao1.clone(); assertNotNull(trustedcertificatelistdao1); assertNotNull(trustedcertificatelistdao2); assertNotSame(trustedcertificatelistdao2, trustedcertificatelistdao1); assertEquals(trustedcertificatelistdao2, trustedcertificatelistdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
CertificateIssuerDao extends AbstractCertificateIssuerDao { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateIssuerDao clone() { try { return new CertificateIssuerDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateIssuerDao(); CertificateIssuerDao(ApiClientWrapper client); CertificateIssuerDao(ConnectionOptions options); CertificateIssuerDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateIssuerDao clone(); @Override @NotImplemented CertificateIssuer create(); @Override @NotImplemented CertificateIssuer create(CertificateIssuer modelToCreate); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { CertificateIssuerDao certificateissuerdao1 = new CertificateIssuerDao(); CertificateIssuerDao certificateissuerdao2 = certificateissuerdao1.clone(); assertNotNull(certificateissuerdao1); assertNotNull(certificateissuerdao2); assertNotSame(certificateissuerdao2, certificateissuerdao1); assertEquals(certificateissuerdao2, certificateissuerdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
PreSharedKeyListOptions extends ListOptions { @Override public PreSharedKeyListOptions clone() { final PreSharedKeyListOptions opt = new PreSharedKeyListOptions(); opt.setOptions(this); return opt; } @Internal PreSharedKeyListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal PreSharedKeyListOptions(PreSharedKeyListOptions preSharedKeyListOptions); PreSharedKeyListOptions(); @Internal PreSharedKeyListOptions(String after, Filters filter); @Override String toString(); @Override PreSharedKeyListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { PreSharedKeyListOptions presharedkeylistoptions1 = new PreSharedKeyListOptions(Integer.valueOf(46), Long.valueOf(-31), Order.getDefault(), "7d7d94bb-63a2-422b-aa73-d6dac53f13cb", null, null); PreSharedKeyListOptions presharedkeylistoptions2 = presharedkeylistoptions1.clone(); assertNotNull(presharedkeylistoptions1); assertNotNull(presharedkeylistoptions2); assertNotSame(presharedkeylistoptions2, presharedkeylistoptions1); assertEquals(presharedkeylistoptions2, presharedkeylistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
PreSharedKeyListOptions extends ListOptions { @Override @SuppressWarnings("PMD.UselessOverridingMethod") public int hashCode() { return super.hashCode(); } @Internal PreSharedKeyListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal PreSharedKeyListOptions(PreSharedKeyListOptions preSharedKeyListOptions); PreSharedKeyListOptions(); @Internal PreSharedKeyListOptions(String after, Filters filter); @Override String toString(); @Override PreSharedKeyListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); }### Answer:
@SuppressWarnings("resource") @Test public void testHashCode() { try { PreSharedKeyListOptions presharedkeylistoptions1 = new PreSharedKeyListOptions(Integer.valueOf(-77), Long.valueOf(-91), Order.getDefault(), "25769883-3a5a-45e7-8db4-28e644b43a60", null, null); PreSharedKeyListOptions presharedkeylistoptions2 = new PreSharedKeyListOptions(Integer.valueOf(-77), Long.valueOf(-91), Order.getDefault(), "25769883-3a5a-45e7-8db4-28e644b43a60", null, null); assertNotNull(presharedkeylistoptions1); assertNotNull(presharedkeylistoptions2); assertNotSame(presharedkeylistoptions2, presharedkeylistoptions1); assertEquals(presharedkeylistoptions2, presharedkeylistoptions1); assertEquals(presharedkeylistoptions2.hashCode(), presharedkeylistoptions1.hashCode()); int hashCode = presharedkeylistoptions1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, presharedkeylistoptions1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
SubtenantLightThemeColorDao extends AbstractSubtenantLightThemeColorDao { @Override @SuppressWarnings({ "resource", "unused" }) public SubtenantLightThemeColorDao clone() { try { return new SubtenantLightThemeColorDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } SubtenantLightThemeColorDao(); SubtenantLightThemeColorDao(ApiClientWrapper client); SubtenantLightThemeColorDao(ConnectionOptions options); SubtenantLightThemeColorDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) SubtenantLightThemeColorDao clone(); @Override @NotImplemented void delete(); @Override @NotImplemented void delete(SubtenantLightThemeColor modelToDelete); @Override @NotImplemented SubtenantLightThemeColor read(); @Override @NotImplemented SubtenantLightThemeColor update(); @Override @NotImplemented SubtenantLightThemeColor update(SubtenantLightThemeColor modelToUpdate); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { SubtenantLightThemeColorDao subtenantlightthemecolordao1 = new SubtenantLightThemeColorDao(); SubtenantLightThemeColorDao subtenantlightthemecolordao2 = subtenantlightthemecolordao1.clone(); assertNotNull(subtenantlightthemecolordao1); assertNotNull(subtenantlightthemecolordao2); assertNotSame(subtenantlightthemecolordao2, subtenantlightthemecolordao1); assertEquals(subtenantlightthemecolordao2, subtenantlightthemecolordao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
LightThemeColorListDao extends AbstractModelListDao<LightThemeColor, LightThemeColorListOptions> implements ModelListDao<LightThemeColor, LightThemeColorListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public LightThemeColorListDao clone() { try { return new LightThemeColorListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } LightThemeColorListDao(); LightThemeColorListDao(ApiClientWrapper client); LightThemeColorListDao(ConnectionOptions options); LightThemeColorListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) LightThemeColorListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<LightThemeColorDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) LightThemeColorDao getNewModelDao(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { LightThemeColorListDao lightthemecolorlistdao1 = new LightThemeColorListDao(); LightThemeColorListDao lightthemecolorlistdao2 = lightthemecolorlistdao1.clone(); assertNotNull(lightthemecolorlistdao1); assertNotNull(lightthemecolorlistdao2); assertNotSame(lightthemecolorlistdao2, lightthemecolorlistdao1); assertEquals(lightthemecolorlistdao2, lightthemecolorlistdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
SubtenantDarkThemeImageListOptions extends ListOptions { @Override public SubtenantDarkThemeImageListOptions clone() { final SubtenantDarkThemeImageListOptions opt = new SubtenantDarkThemeImageListOptions(); opt.setOptions(this); return opt; } @Internal SubtenantDarkThemeImageListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal SubtenantDarkThemeImageListOptions(SubtenantDarkThemeImageListOptions subtenantDarkThemeImageListOptions); SubtenantDarkThemeImageListOptions(); @Internal SubtenantDarkThemeImageListOptions(String after, Filters filter); @Override String toString(); @Override SubtenantDarkThemeImageListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { SubtenantDarkThemeImageListOptions subtenantdarkthemeimagelistoptions1 = new SubtenantDarkThemeImageListOptions(Integer.valueOf(67), Long.valueOf(70), Order.getDefault(), "9ccbb436-c74e-440e-b595-bfd773a81e92", null, null); SubtenantDarkThemeImageListOptions subtenantdarkthemeimagelistoptions2 = subtenantdarkthemeimagelistoptions1.clone(); assertNotNull(subtenantdarkthemeimagelistoptions1); assertNotNull(subtenantdarkthemeimagelistoptions2); assertNotSame(subtenantdarkthemeimagelistoptions2, subtenantdarkthemeimagelistoptions1); assertEquals(subtenantdarkthemeimagelistoptions2, subtenantdarkthemeimagelistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
SubtenantLightThemeImageListOptions extends ListOptions { @Override public SubtenantLightThemeImageListOptions clone() { final SubtenantLightThemeImageListOptions opt = new SubtenantLightThemeImageListOptions(); opt.setOptions(this); return opt; } @Internal SubtenantLightThemeImageListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal SubtenantLightThemeImageListOptions(SubtenantLightThemeImageListOptions subtenantLightThemeImageListOptions); SubtenantLightThemeImageListOptions(); @Internal SubtenantLightThemeImageListOptions(String after, Filters filter); @Override String toString(); @Override SubtenantLightThemeImageListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { SubtenantLightThemeImageListOptions subtenantlightthemeimagelistoptions1 = new SubtenantLightThemeImageListOptions(Integer.valueOf(117), Long.valueOf(-75), Order.getDefault(), "99d8ea69-16e7-4650-b19b-d45723d03ece", null, null); SubtenantLightThemeImageListOptions subtenantlightthemeimagelistoptions2 = subtenantlightthemeimagelistoptions1.clone(); assertNotNull(subtenantlightthemeimagelistoptions1); assertNotNull(subtenantlightthemeimagelistoptions2); assertNotSame(subtenantlightthemeimagelistoptions2, subtenantlightthemeimagelistoptions1); assertEquals(subtenantlightthemeimagelistoptions2, subtenantlightthemeimagelistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
LightThemeColorDao extends AbstractLightThemeColorDao { @Override @SuppressWarnings({ "resource", "unused" }) public LightThemeColorDao clone() { try { return new LightThemeColorDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } LightThemeColorDao(); LightThemeColorDao(ApiClientWrapper client); LightThemeColorDao(ConnectionOptions options); LightThemeColorDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) LightThemeColorDao clone(); @Override void delete(String id); @Override LightThemeColor read(String id); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { LightThemeColorDao lightthemecolordao1 = new LightThemeColorDao(); LightThemeColorDao lightthemecolordao2 = lightthemecolordao1.clone(); assertNotNull(lightthemecolordao1); assertNotNull(lightthemecolordao2); assertNotSame(lightthemecolordao2, lightthemecolordao1); assertEquals(lightthemecolordao2, lightthemecolordao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
SubtenantLightThemeImageDao extends AbstractSubtenantLightThemeImageDao { @Override @SuppressWarnings({ "resource", "unused" }) public SubtenantLightThemeImageDao clone() { try { return new SubtenantLightThemeImageDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } SubtenantLightThemeImageDao(); SubtenantLightThemeImageDao(ApiClientWrapper client); SubtenantLightThemeImageDao(ConnectionOptions options); SubtenantLightThemeImageDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) SubtenantLightThemeImageDao clone(); @Override @NotImplemented SubtenantLightThemeImage update(); @Override @NotImplemented SubtenantLightThemeImage update(SubtenantLightThemeImage modelToUpdate); @Override @NotImplemented void delete(); @Override @NotImplemented void delete(SubtenantLightThemeImage modelToDelete); @Override @NotImplemented SubtenantLightThemeImage read(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { SubtenantLightThemeImageDao subtenantlightthemeimagedao1 = new SubtenantLightThemeImageDao(); SubtenantLightThemeImageDao subtenantlightthemeimagedao2 = subtenantlightthemeimagedao1.clone(); assertNotNull(subtenantlightthemeimagedao1); assertNotNull(subtenantlightthemeimagedao2); assertNotSame(subtenantlightthemeimagedao2, subtenantlightthemeimagedao1); assertEquals(subtenantlightthemeimagedao2, subtenantlightthemeimagedao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
LightThemeImageListDao extends AbstractModelListDao<LightThemeImage, LightThemeImageListOptions> implements ModelListDao<LightThemeImage, LightThemeImageListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public LightThemeImageListDao clone() { try { return new LightThemeImageListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } LightThemeImageListDao(); LightThemeImageListDao(ApiClientWrapper client); LightThemeImageListDao(ConnectionOptions options); LightThemeImageListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) LightThemeImageListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<LightThemeImageDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) LightThemeImageDao getNewModelDao(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { LightThemeImageListDao lightthemeimagelistdao1 = new LightThemeImageListDao(); LightThemeImageListDao lightthemeimagelistdao2 = lightthemeimagelistdao1.clone(); assertNotNull(lightthemeimagelistdao1); assertNotNull(lightthemeimagelistdao2); assertNotSame(lightthemeimagelistdao2, lightthemeimagelistdao1); assertEquals(lightthemeimagelistdao2, lightthemeimagelistdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
DarkThemeImageListDao extends AbstractModelListDao<DarkThemeImage, DarkThemeImageListOptions> implements ModelListDao<DarkThemeImage, DarkThemeImageListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public DarkThemeImageListDao clone() { try { return new DarkThemeImageListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } DarkThemeImageListDao(); DarkThemeImageListDao(ApiClientWrapper client); DarkThemeImageListDao(ConnectionOptions options); DarkThemeImageListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) DarkThemeImageListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<DarkThemeImageDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) DarkThemeImageDao getNewModelDao(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { DarkThemeImageListDao darkthemeimagelistdao1 = new DarkThemeImageListDao(); DarkThemeImageListDao darkthemeimagelistdao2 = darkthemeimagelistdao1.clone(); assertNotNull(darkthemeimagelistdao1); assertNotNull(darkthemeimagelistdao2); assertNotSame(darkthemeimagelistdao2, darkthemeimagelistdao1); assertEquals(darkthemeimagelistdao2, darkthemeimagelistdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
SubtenantDarkThemeImageDao extends AbstractSubtenantDarkThemeImageDao { @Override @SuppressWarnings({ "resource", "unused" }) public SubtenantDarkThemeImageDao clone() { try { return new SubtenantDarkThemeImageDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } SubtenantDarkThemeImageDao(); SubtenantDarkThemeImageDao(ApiClientWrapper client); SubtenantDarkThemeImageDao(ConnectionOptions options); SubtenantDarkThemeImageDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) SubtenantDarkThemeImageDao clone(); @Override @NotImplemented SubtenantDarkThemeImage update(); @Override @NotImplemented SubtenantDarkThemeImage update(SubtenantDarkThemeImage modelToUpdate); @Override @NotImplemented void delete(); @Override @NotImplemented void delete(SubtenantDarkThemeImage modelToDelete); @Override @NotImplemented SubtenantDarkThemeImage read(); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { SubtenantDarkThemeImageDao subtenantdarkthemeimagedao1 = new SubtenantDarkThemeImageDao(); SubtenantDarkThemeImageDao subtenantdarkthemeimagedao2 = subtenantdarkthemeimagedao1.clone(); assertNotNull(subtenantdarkthemeimagedao1); assertNotNull(subtenantdarkthemeimagedao2); assertNotSame(subtenantdarkthemeimagedao2, subtenantdarkthemeimagedao1); assertEquals(subtenantdarkthemeimagedao2, subtenantdarkthemeimagedao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
### Question:
LightThemeImageDao extends AbstractLightThemeImageDao { @Override @SuppressWarnings({ "resource", "unused" }) public LightThemeImageDao clone() { try { return new LightThemeImageDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } LightThemeImageDao(); LightThemeImageDao(ApiClientWrapper client); LightThemeImageDao(ConnectionOptions options); LightThemeImageDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) LightThemeImageDao clone(); @Override @NotImplemented LightThemeImage update(); @Override @NotImplemented LightThemeImage update(LightThemeImage modelToUpdate); @Override void delete(String id); @Override LightThemeImage read(String id); }### Answer:
@SuppressWarnings("resource") @Test public void testClone() { try { LightThemeImageDao lightthemeimagedao1 = new LightThemeImageDao(); LightThemeImageDao lightthemeimagedao2 = lightthemeimagedao1.clone(); assertNotNull(lightthemeimagedao1); assertNotNull(lightthemeimagedao2); assertNotSame(lightthemeimagedao2, lightthemeimagedao1); assertEquals(lightthemeimagedao2, lightthemeimagedao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.