Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: GridFile extends File { @Override public URI toURI() { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer: @Test(expectedExceptions = UnsupportedOperationException.class) public void testToURI() { fs.getFile("nonsuch.txt").toURI(); }
### Question: GridFile extends File { @Override public boolean setReadOnly() { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer: @Test(expectedExceptions = UnsupportedOperationException.class) public void testSetReadOnly() { fs.getFile("nonsuch.txt").setReadOnly(); }
### Question: GridFile extends File { @Override public boolean setWritable(boolean writable, boolean ownerOnly) { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer: @Test(expectedExceptions = UnsupportedOperationException.class) public void testSetWritable() { fs.getFile("nonsuch.txt").setWritable(true); } @Test(expectedExceptions = UnsupportedOperationException.class) public void testSetWritable2() { fs.getFile("nonsuch.txt").setWritable(true, true); }
### Question: GridFile extends File { @Override public boolean setReadable(boolean readable, boolean ownerOnly) { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer: @Test(expectedExceptions = UnsupportedOperationException.class) public void testSetReadable() { fs.getFile("nonsuch.txt").setReadable(true); } @Test(expectedExceptions = UnsupportedOperationException.class) public void testSetReadable2() { fs.getFile("nonsuch.txt").setReadable(true, true); }
### Question: GridFile extends File { @Override public boolean setExecutable(boolean executable, boolean ownerOnly) { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer: @Test(expectedExceptions = UnsupportedOperationException.class) public void testSetExecutable() { fs.getFile("nonsuch.txt").setExecutable(true); } @Test(expectedExceptions = UnsupportedOperationException.class) public void testSetExecutable2() { fs.getFile("nonsuch.txt").setExecutable(true, true); }
### Question: GridFile extends File { @Override public long getTotalSpace() { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer: @Test(expectedExceptions = UnsupportedOperationException.class) public void testGetTotalSpace() { fs.getFile("nonsuch.txt").getTotalSpace(); }
### Question: GridFile extends File { @Override public long getFreeSpace() { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer: @Test(expectedExceptions = UnsupportedOperationException.class) public void testGetFreeSpace() { fs.getFile("nonsuch.txt").getFreeSpace(); }
### Question: GridFile extends File { @Override public long getUsableSpace() { throw new UnsupportedOperationException("Not implemented"); } GridFile(String pathname, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(String parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); GridFile(File parent, String child, Cache<String, Metadata> metadataCache, int chunkSize, GridFilesystem fs); @Override String getName(); @Override String getPath(); @Override String getAbsolutePath(); @Override File getAbsoluteFile(); @Override String getCanonicalPath(); @Override File getCanonicalFile(); @Override boolean isAbsolute(); @Override boolean renameTo(File dest); @Override void deleteOnExit(); @Override long length(); int getChunkSize(); @Override boolean createNewFile(); @Override boolean delete(); @Override boolean mkdir(); @Override boolean mkdirs(); @Override boolean exists(); @Override String getParent(); @Override File getParentFile(); @Override long lastModified(); @Override boolean setLastModified(long time); @Override String[] list(); @Override String[] list(FilenameFilter filter); @Override File[] listFiles(); @Override File[] listFiles(FilenameFilter filter); @Override File[] listFiles(FileFilter filter); @Override boolean isDirectory(); @Override boolean isFile(); @Override boolean equals(Object obj); @Override boolean canRead(); @Override boolean canWrite(); @Override boolean isHidden(); @Override boolean canExecute(); @Override int compareTo(File file); @Override int hashCode(); @Override String toString(); @Override URL toURL(); @Override URI toURI(); @Override boolean setReadOnly(); @Override boolean setWritable(boolean writable, boolean ownerOnly); @Override boolean setWritable(boolean writable); @Override boolean setReadable(boolean readable, boolean ownerOnly); @Override boolean setReadable(boolean readable); @Override boolean setExecutable(boolean executable, boolean ownerOnly); @Override boolean setExecutable(boolean executable); @Override long getTotalSpace(); @Override long getFreeSpace(); @Override long getUsableSpace(); }### Answer: @Test(expectedExceptions = UnsupportedOperationException.class) public void testGetUsableSpace() { fs.getFile("nonsuch.txt").getUsableSpace(); }
### Question: CacheHealthImpl implements CacheHealth { @Override public HealthStatus getStatus() { if (!isComponentHealthy() \|\| cache.getAdvancedCache().getAvailability() == AvailabilityMode.DEGRADED_MODE) { return HealthStatus.DEGRADED; } DistributionManager distributionManager = SecurityActions.getDistributionManager(cache); if (distributionManager != null && distributionManager.isRehashInProgress()) { return HealthStatus.HEALTHY_REBALANCING; } return HealthStatus.HEALTHY; } CacheHealthImpl(Cache<?, ?> cache); @Override String getCacheName(); @Override HealthStatus getStatus(); }### Answer: @Test public void testHealthyStatus() { CacheImpl<Object, Object> cache = spy(new CacheImpl<>("test")); DistributionManager distributionManagerMock = mock(DistributionManager.class); doReturn(false).when(distributionManagerMock).isRehashInProgress(); doReturn(distributionManagerMock).when(cache).getDistributionManager(); doReturn(ComponentStatus.RUNNING).when(cache).getStatus(); doReturn(AvailabilityMode.AVAILABLE).when(cache).getAvailability(); CacheHealth cacheHealth = new CacheHealthImpl(cache); HealthStatus status = cacheHealth.getStatus(); assertEquals(status, HealthStatus.HEALTHY); } @Test public void testUnhealthyStatusWithFailedComponent() { CacheImpl<Object, Object> cache = spy(new CacheImpl<>("test")); doReturn(ComponentStatus.FAILED).when(cache).getStatus(); CacheHealth cacheHealth = new CacheHealthImpl(cache); HealthStatus status = cacheHealth.getStatus(); assertEquals(status, HealthStatus.DEGRADED); } @Test public void testUnhealthyStatusWithTerminatedComponent() { CacheImpl<Object, Object> cache = spy(new CacheImpl<>("test")); doReturn(ComponentStatus.TERMINATED).when(cache).getStatus(); CacheHealth cacheHealth = new CacheHealthImpl(cache); HealthStatus status = cacheHealth.getStatus(); assertEquals(status, HealthStatus.DEGRADED); } @Test public void testUnhealthyStatusWithStoppingComponent() { CacheImpl<Object, Object> cache = spy(new CacheImpl<>("test")); doReturn(ComponentStatus.STOPPING).when(cache).getStatus(); CacheHealth cacheHealth = new CacheHealthImpl(cache); HealthStatus status = cacheHealth.getStatus(); assertEquals(status, HealthStatus.DEGRADED); } @Test public void testUnhealthyStatusWithDegradedPartition() { CacheImpl<Object, Object> cache = spy(new CacheImpl<>("test")); doReturn(ComponentStatus.RUNNING).when(cache).getStatus(); doReturn(AvailabilityMode.DEGRADED_MODE).when(cache).getAvailability(); CacheHealth cacheHealth = new CacheHealthImpl(cache); HealthStatus status = cacheHealth.getStatus(); assertEquals(status, HealthStatus.DEGRADED); } @Test public void testRebalancingStatusOnRebalance() { CacheImpl<Object, Object> cache = spy(new CacheImpl<>("test")); DistributionManager distributionManagerMock = mock(DistributionManager.class); doReturn(true).when(distributionManagerMock).isRehashInProgress(); doReturn(distributionManagerMock).when(cache).getDistributionManager(); doReturn(ComponentStatus.RUNNING).when(cache).getStatus(); doReturn(AvailabilityMode.AVAILABLE).when(cache).getAvailability(); CacheHealth cacheHealth = new CacheHealthImpl(cache); HealthStatus status = cacheHealth.getStatus(); assertEquals(status, HealthStatus.HEALTHY_REBALANCING); }
### Question: QueueAsyncInvocationStage extends SimpleAsyncInvocationStage implements BiConsumer<Object, Throwable>, InvocationCallback { InvocationCallback queuePoll() { InvocationCallback element; synchronized (this) { if (tail != head) { element = elements[head & mask]; head++; } else { element = null; frozen = true; } } return element; } QueueAsyncInvocationStage(InvocationContext ctx, VisitableCommand command, CompletableFuture<?> valueFuture, InvocationCallback function); @Override Object addCallback(InvocationContext ctx, VisitableCommand command, InvocationCallback function); @Override void accept(Object rv, Throwable throwable); @Override Object apply(InvocationContext rCtx, VisitableCommand rCommand, Object rv, Throwable throwable); @Override String toString(); }### Answer: @Test(dataProvider = "offsets") public void testExpandCapacity(int splitOffset) throws Throwable { CompletableFuture<Object> future = new CompletableFuture<>(); QueueAsyncInvocationStage stage = new QueueAsyncInvocationStage(null, null, future, makeCallback(0)); assertCallback(0, stage.queuePoll()); addAndPoll(stage, splitOffset); int count = 2 * QueueAsyncInvocationStage.QUEUE_INITIAL_CAPACITY; addAndPoll(stage, count); }
### Question: UnpooledOffHeapMemoryAllocator implements OffHeapMemoryAllocator { public static long estimateSizeOverhead(long size) { return (size + 8 + 15) & ~15; } @Override long allocate(long memoryLength); @Override void deallocate(long memoryAddress, long size); @Override long getAllocatedAmount(); static long estimateSizeOverhead(long size); static long offHeapEntrySize(boolean evictionEnabled, boolean writeMetadataSize, int keySize, int valueSize); static long offHeapEntrySize(boolean evictionEnabled, boolean writeMetadataSize, int keySize, int valueSize, int metadataSize, int internalMetadataSize); }### Answer: @Test(dataProvider = "roundings") public void testRoundings(long original, long expected) { assertEquals(expected, UnpooledOffHeapMemoryAllocator.estimateSizeOverhead(original)); }
### Question: BaseCacheResource { private CompletionStage<RestResponse> putInCache(NettyRestResponse.Builder responseBuilder, AdvancedCache<Object, Object> cache, Object key, byte[] data, Long ttl, Long idleTime) { Configuration config = SecurityActions.getCacheConfiguration(cache); final Metadata metadata = CacheOperationsHelper.createMetadata(config, ttl, idleTime); responseBuilder.header("etag", calcETAG(data)); CompletionStage<Object> stage; if (config.indexing().enabled()) { stage = CompletableFuture.supplyAsync(() -> cache.putAsync(key, data, metadata), invocationHelper.getExecutor()) .thenCompose(Function.identity()); } else { stage = cache.putAsync(key, data, metadata); } return stage.thenApply(o -> responseBuilder.build()); } BaseCacheResource(InvocationHelper invocationHelper); }### Answer: @Test public void testIntegerKeysXmlToTextValues() { Integer key = 123; String keyContentType = "application/x-java-object;type=java.lang.Integer"; String valueContentType = "application/xml; charset=UTF-8"; String value = "<root>test</root>"; putInCache("default", key, keyContentType, value, valueContentType); RestResponse response = get("default", key, keyContentType, "text/plain"); ResponseAssertion.assertThat(response).hasReturnedText(value); } @Test public void testIntKeysAndJSONToTextValues() { Integer key = 1234; String keyContentType = "application/x-java-object;type=java.lang.Integer"; String value = "{\"a\": 1}"; putInCache("default", key, keyContentType, value, APPLICATION_JSON_TYPE); RestResponse response = get("default", key, keyContentType, TEXT_PLAIN_TYPE); ResponseAssertion.assertThat(response).hasReturnedText(value); } @Test public void testIntKeysTextToXMLValues() { Integer key = 12345; String keyContentType = "application/x-java-object;type=java.lang.Integer"; String value = "<foo>bar</foo>"; putInCache("default", key, keyContentType, value, TEXT_PLAIN_TYPE); RestResponse response = get("default", key, keyContentType, APPLICATION_XML_TYPE); ResponseAssertion.assertThat(response).hasReturnedText(value); } @Test public void testInvalidXMLConversion() throws Exception { String key = "invalid-xml-key"; String invalidXML = "foo"; putInCache("default", key, invalidXML, TEXT_PLAIN_TYPE); CompletionStage<RestResponse> response = client.cache("default").get(key, APPLICATION_XML_TYPE); ResponseAssertion.assertThat(response).containsReturnedText("<string>foo</string>"); }
### Question: CounterResource implements ResourceHandler { private CompletionStage<RestResponse> createCounter(RestRequest request) throws RestResponseException { NettyRestResponse.Builder responseBuilder = new NettyRestResponse.Builder(); String counterName = request.variables().get("counterName"); String contents = request.contents().asString(); if (contents == null \|\| contents.length() == 0) { responseBuilder.status(HttpResponseStatus.BAD_REQUEST); responseBuilder.entity("Configuration not provided"); return completedFuture(responseBuilder.build()); } CounterConfiguration configuration = createCounterConfiguration(contents); if (configuration == null) { responseBuilder.status(HttpResponseStatus.BAD_REQUEST).entity("Invalid configuration"); return completedFuture(responseBuilder.build()); } return counterManager.defineCounterAsync(counterName, configuration).thenApply(r -> responseBuilder.build()); } CounterResource(InvocationHelper invocationHelper); @Override Invocations getInvocations(); }### Answer: @Test public void testWeakCounterLifecycle() { CounterConfiguration counterConfig = CounterConfiguration.builder(CounterType.WEAK) .initialValue(5).storage(Storage.VOLATILE).concurrencyLevel(6).build(); createCounter("sample-counter", counterConfig); RestCounterClient counterClient = client.counter("sample-counter"); RestResponse response = join(counterClient.configuration(APPLICATION_JSON_TYPE)); Json jsonNode = Json.read(response.getBody()); Json config = jsonNode.at("weak-counter"); assertEquals(config.at("initial-value").asInteger(), 5); assertEquals(config.at("storage").asString(), "VOLATILE"); assertEquals(config.at("concurrency-level").asInteger(), 6); response = join(counterClient.delete()); assertThat(response).isOk(); response = join(counterClient.configuration()); assertThat(response).isNotFound(); } @Test public void testWeakCounterOps() { String name = "weak-test"; createCounter(name, CounterConfiguration.builder(CounterType.WEAK).initialValue(5).build()); RestCounterClient counterClient = client.counter(name); CompletionStage<RestResponse> response = counterClient.increment(); assertThat(response).hasNoContent(); waitForCounterToReach(name, 6); response = counterClient.increment(); assertThat(response).hasNoContent(); waitForCounterToReach(name, 7); response = counterClient.decrement(); assertThat(response).hasNoContent(); waitForCounterToReach(name, 6); response = counterClient.decrement(); assertThat(response).hasNoContent(); waitForCounterToReach(name, 5); response = counterClient.add(10); assertThat(response).hasNoContent(); waitForCounterToReach(name, 15); response = counterClient.reset(); assertThat(response).hasNoContent(); waitForCounterToReach(name, 5); } @Test public void testStrongCounterOps() { String name = "strong-test"; createCounter(name, CounterConfiguration.builder(CounterType.BOUNDED_STRONG).lowerBound(0).upperBound(100) .initialValue(0).build()); RestCounterClient counterClient = client.counter(name); CompletionStage<RestResponse> response = counterClient.increment(); assertThat(response).hasReturnedText("1"); response = counterClient.increment(); assertThat(response).hasReturnedText("2"); response = counterClient.decrement(); assertThat(response).hasReturnedText("1"); response = counterClient.decrement(); assertThat(response).hasReturnedText("0"); response = counterClient.add(35); assertThat(response).hasReturnedText("35"); waitForCounterToReach(name, 35); response = counterClient.compareAndSet(5, 32); assertThat(response).hasReturnedText("false"); response = counterClient.compareAndSet(35, 50); assertThat(response).hasReturnedText("true"); waitForCounterToReach(name, 50); response = counterClient.compareAndSwap(50, 90); assertThat(response).hasReturnedText("50"); response = counterClient.get(); assertThat(response).hasReturnedText("90"); }
### Question: StringPropertyReplacer { public static String replaceProperties(final String string) { return replaceProperties(string, null); } static String replaceProperties(final String string); static String replaceProperties(final String string, final Properties props); static void replaceProperties(Map<String, String> map, Properties properties); static final String NEWLINE; }### Answer: @Test public void testReplaceProperties() { Properties properties = new Properties(); properties.put("one", "1"); properties.put("two", "2"); assertEquals("V1", StringPropertyReplacer.replaceProperties("V${one}", properties)); assertEquals("VX", StringPropertyReplacer.replaceProperties("V${void:X}", properties)); assertEquals("V1", StringPropertyReplacer.replaceProperties("V${void,one}", properties)); assertEquals("VX", StringPropertyReplacer.replaceProperties("V${void1,void2:X}", properties)); assertEquals(System.getenv("PATH"), StringPropertyReplacer.replaceProperties("${env.PATH}", properties)); assertEquals(File.separator, StringPropertyReplacer.replaceProperties("${/}")); assertEquals(File.pathSeparator, StringPropertyReplacer.replaceProperties("${:}")); }
### Question: XSiteResource implements ResourceHandler { private CompletionStage<RestResponse> backupStatus(RestRequest request) { return statusOperation(request, SITES_STATUS); } XSiteResource(InvocationHelper invocationHelper); @Override Invocations getInvocations(); static final String AFTER_FAILURES_FIELD; static final String MIN_WAIT_FIELD; }### Answer: @Test public void testInvalidSite() { RestClient client = clientPerSite.get(LON); RestCacheClient cache = client.cache(CACHE_1); assertStatus(404, cache.backupStatus("invalid-site")); }
### Question: XSiteResource implements ResourceHandler { private CompletionStage<RestResponse> pushStateStatus(RestRequest request) { return statusOperation(request, PUSH_STATE_STATUS); } XSiteResource(InvocationHelper invocationHelper); @Override Invocations getInvocations(); static final String AFTER_FAILURES_FIELD; static final String MIN_WAIT_FIELD; }### Answer: @Test public void testPushState() { RestCacheClient cache = getCacheClient(LON); RestCacheClient backupCache = getCacheClient(NYC); String key = "key"; String value = "value"; Function<String, Integer> keyOnBackup = k -> responseStatus(backupCache.get(key)); takeBackupOffline(LON, NYC); assertEquals(OFFLINE, getBackupStatus(LON, NYC)); assertEquals(ONLINE, getBackupStatus(LON, SFO)); assertNoContent(cache.put(key, value)); assertEquals(404, (int) keyOnBackup.apply(key)); assertSuccessful(cache.pushSiteState(NYC)); assertEquals(ONLINE, getBackupStatus(LON, NYC)); eventuallyEquals("OK", () -> pushStateStatus(cache, NYC)); assertEquals(200, responseStatus(backupCache.get(key))); } @Test public void testPushAllCaches() { RestClient restClientLon = clientPerSite.get(LON); RestClient restClientSfo = clientPerSite.get(SFO); RestCacheClient cache1Lon = restClientLon.cache(CACHE_1); RestCacheClient cache2Lon = restClientLon.cache(CACHE_2); RestCacheClient cache1Sfo = restClientSfo.cache(CACHE_1); RestCacheClient cache2Sfo = restClientSfo.cache(CACHE_2); assertSuccessful(restClientLon.cacheManager(CACHE_MANAGER).takeOffline(SFO)); Json backupStatuses = jsonResponseBody(restClientLon.cacheManager(CACHE_MANAGER).backupStatuses()); assertEquals("offline", backupStatuses.at(SFO).at("status").asString()); int entries = 10; IntStream.range(0, entries).forEach(i -> { String key = String.valueOf(i); String value = "value"; assertNoContent(cache1Lon.put(key, value)); assertNoContent(cache2Lon.put(key, value)); }); assertEquals(0, getCacheSize(cache1Sfo)); assertEquals(0, getCacheSize(cache2Sfo)); assertSuccessful(restClientLon.cacheManager(CACHE_MANAGER).pushSiteState(SFO)); assertEquals(ONLINE, getBackupStatus(LON, SFO)); eventuallyEquals("OK", () -> pushStateStatus(cache1Lon, SFO)); eventuallyEquals("OK", () -> pushStateStatus(cache2Lon, SFO)); assertEquals(entries, getCacheSize(cache1Sfo)); assertEquals(entries, getCacheSize(cache2Sfo)); }
### Question: XSiteResource implements ResourceHandler { private CompletionStage<RestResponse> cancelPushState(RestRequest restRequest) { return executeXSiteCacheOp(restRequest, CANCEL_PUSH_STATE); } XSiteResource(InvocationHelper invocationHelper); @Override Invocations getInvocations(); static final String AFTER_FAILURES_FIELD; static final String MIN_WAIT_FIELD; }### Answer: @Test public void testCancelPushState() throws Exception { RestCacheClient cache = getCacheClient(LON); RestCacheClient backupCache = getCacheClient(NYC); takeBackupOffline(LON, NYC); assertEquals(OFFLINE, getBackupStatus(LON, NYC)); int entries = 50; IntStream.range(0, entries).forEach(i -> assertNoContent(cache.put(String.valueOf(i), "value"))); assertEquals(entries, getCacheSize(cache)); assertEquals(0, getCacheSize(backupCache)); ControlledTransport controllerTransport = ControlledTransport.replace(cache(LON, 0)); controllerTransport.blockBefore(XSiteStatePushCommand.class); assertSuccessful(cache.pushSiteState(NYC)); controllerTransport.waitForCommandToBlock(); assertSuccessful(cache.cancelPushState(NYC)); controllerTransport.stopBlocking(); Json status = jsonResponseBody(cache.pushStateStatus()); assertEquals("CANCELED", status.at(NYC).asString()); assertSuccessful(cache.clearPushStateStatus()); status = jsonResponseBody(cache.pushStateStatus()); assertTrue(status.asMap().isEmpty()); assertSuccessful(cache.cancelReceiveState(NYC)); }
### Question: PathInterpreter { static Map<String, String> resolveVariables(String expression, String str) { if (expression == null \|\| str == null) return Collections.emptyMap(); Map<String, String> resolvedVariables = new HashMap<>(); StringBuilder variableBuilder = new StringBuilder(); State state = State.TEXT; int j = 0; int expressionLength = expression.length(); for (int i = 0; i < expressionLength; i++) { char e = expression.charAt(i); switch (e) { case '{': if (state == END_VAR) return Collections.emptyMap(); state = VAR; break; case '}': if (state != VAR) return Collections.emptyMap(); state = END_VAR; if (i != expressionLength - 1) break; default: switch (state) { case VAR: variableBuilder.append(e); break; case END_VAR: String replacement; boolean ec = i == expressionLength - 1; if (ec) { replacement = str.substring(j); } else { int k = str.indexOf(e, j); if (k == -1) return Collections.emptyMap(); replacement = str.substring(j, str.indexOf(e, j)); } resolvedVariables.put(variableBuilder.toString(), replacement); j += replacement.length(); if (j == str.length() && ec) return resolvedVariables; variableBuilder.setLength(0); state = TEXT; case TEXT: if (str.charAt(j) != e) return Collections.emptyMap(); j++; } } } return resolvedVariables; } }### Answer: @Test public void testSingleVariable() { Map<String, String> res = resolveVariables("{id}", "5435"); assertEquals(1, res.size()); assertEquals(res.get("id"), "5435"); } @Test public void testSingleVariable2() { Map<String, String> res = resolveVariables("{variable_name}", "a"); assertEquals(1, res.size()); assertEquals(res.get("variable_name"), "a"); } @Test public void testDualVariables() { Map<String, String> res = resolveVariables("{cachemanager}-{cache}", "default-mycache"); assertEquals(2, res.size()); assertEquals(res.get("cachemanager"), "default"); assertEquals(res.get("cache"), "mycache"); } @Test public void testDualVariables2() { Map<String, String> res = resolveVariables("{cachemanager}{cache}", "defaultmycache"); assertEquals(0, res.size()); } @Test public void testDualVariables3() { Map<String, String> res = resolveVariables("{a}:{b}", "value1:value2"); assertEquals(2, res.size()); assertEquals(res.get("a"), "value1"); assertEquals(res.get("b"), "value2"); } @Test public void testPrefixSufix() { Map<String, String> res = resolveVariables("prefix_{variable1}_{variable2}_suffix", "prefix_value1_value2_suffix"); assertEquals(2, res.size()); assertEquals(res.get("variable1"), "value1"); assertEquals(res.get("variable2"), "value2"); } @Test public void testSingleVariableWithPrefix() { Map<String, String> res = resolveVariables("counter-{id}", "counter-2345"); assertEquals(1, res.size()); assertEquals(res.get("id"), "2345"); } @Test public void testNull() { Map<String, String> res1 = resolveVariables(null, "whatever"); Map<String, String> res2 = resolveVariables("{hello}", null); assertEquals(0, res1.size()); assertEquals(0, res2.size()); } @Test public void testNonConformantPath() { Map<String, String> res = resolveVariables("{cachemanager}-{cache}", "default"); assertEquals(0, res.size()); } @Test public void testMalformedExpression() { Map<String, String> res = resolveVariables("{counter {id}}", "whatever"); assertEquals(0, res.size()); } @Test public void testMalformedExpression2() { Map<String, String> res = resolveVariables("{counter }id}-", "whatever"); assertEquals(0, res.size()); }
### Question: RangeSet implements IntSet { @Override public int size() { return size; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testSize() { RangeSet rs = new RangeSet(4); assertEquals(4, rs.size()); }
### Question: ResourceManagerImpl implements ResourceManager { @Override public LookupResult lookupResource(Method method, String path, String action) { List<PathItem> pathItems = Arrays.stream(path.replaceAll(" .map(s -> s.isEmpty() ? "/" : s).map(QueryStringDecoder::decodeComponent).map(PathItem::fromString).collect(Collectors.toList()); return resourceTree.find(method, pathItems, action); } ResourceManagerImpl(); @Override void registerResource(String context, ResourceHandler handler); @Override LookupResult lookupResource(Method method, String path, String action); }### Answer: @Test public void testLookupHandler() { registerHandler("root", "CompaniesHandler", "/companies", "/companies/{company}", "/companies/{company}/{id}"); registerHandler("root", "StocksHandler", "/stocks/{stock}", "/stocks/{stock}/{currency}"); registerHandler("root", "DirectorsHandler", "/directors", "/directors/director", "/directors/director/{personId}"); registerHandler("root", "InfoHandler", "/info", "/info/jvm", "/info/jvm/{format}", "/info/{format}/{encoding}"); assertEquals(NOT_FOUND, resourceManager.lookupResource(GET, "/root/dummy").getStatus()); assertEquals(NOT_FOUND, resourceManager.lookupResource(GET, "/fake/").getStatus()); assertEquals(NOT_FOUND, resourceManager.lookupResource(GET, "/").getStatus()); assertEquals(NOT_FOUND, resourceManager.lookupResource(GET, "/root/stocks").getStatus()); assertEquals(NOT_FOUND, resourceManager.lookupResource(GET, "/root/stocks/2/USD/1").getStatus()); assertInvocation(resourceManager.lookupResource(GET, "/root/stocks/2"), "StocksHandler"); assertInvocation(resourceManager.lookupResource(GET, "/root/stocks/2/USD"), "StocksHandler"); assertInvocation(resourceManager.lookupResource(GET, "/root/directors"), "DirectorsHandler"); assertInvocation(resourceManager.lookupResource(GET, "/root/directors/director"), "DirectorsHandler"); assertInvocation(resourceManager.lookupResource(GET, "/root/directors/director/John"), "DirectorsHandler"); assertEquals(NOT_FOUND, resourceManager.lookupResource(GET, "/root/directors/1345").getStatus()); assertEquals(NOT_FOUND, resourceManager.lookupResource(GET, "/root/directors/director/Tim/123").getStatus()); assertInvocation(resourceManager.lookupResource(GET, "/root/companies"), "CompaniesHandler"); assertInvocation(resourceManager.lookupResource(GET, "/root/info"), "InfoHandler"); assertInvocation(resourceManager.lookupResource(GET, "/root/info/jvm"), "InfoHandler"); assertInvocation(resourceManager.lookupResource(GET, "/root/info/jvm/json"), "InfoHandler"); assertInvocation(resourceManager.lookupResource(GET, "/root/info/json/zip"), "InfoHandler"); } @Test public void testLookupStatuses() { registerHandler("ctx", "handler1", "/items/{item}"); registerHandlerWithAction("ctx", new Method[]{GET}, "handler2", "clear", "/items/{item}/{sub}"); LookupResult lookupResult = resourceManager.lookupResource(GET, "/invalid"); assertEquals(NOT_FOUND, lookupResult.getStatus()); lookupResult = resourceManager.lookupResource(GET, "/ctx/items/1"); assertEquals(FOUND, lookupResult.getStatus()); lookupResult = resourceManager.lookupResource(DELETE, "/ctx/items/1"); assertEquals(INVALID_METHOD, lookupResult.getStatus()); lookupResult = resourceManager.lookupResource(GET, "/ctx/items/1/1", "clear"); assertEquals(FOUND, lookupResult.getStatus()); lookupResult = resourceManager.lookupResource(GET, "/ctx/items/1/1"); assertEquals(INVALID_ACTION, lookupResult.getStatus()); lookupResult = resourceManager.lookupResource(GET, "/ctx/items/1/1", "invalid"); assertEquals(INVALID_ACTION, lookupResult.getStatus()); lookupResult = resourceManager.lookupResource(GET, "/ctx/items/1", "invalid"); assertEquals(INVALID_ACTION, lookupResult.getStatus()); }
### Question: RangeSet implements IntSet { @Override public boolean isEmpty() { return size <= 0; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testIsEmpty() { RangeSet rs = new RangeSet(0); assertTrue(rs.isEmpty()); rs = new RangeSet(3); assertFalse(rs.isEmpty()); }
### Question: ServiceFinder { public static <T> Collection<T> load(Class<T> contract, ClassLoader... loaders) { Map<String, T> services = new LinkedHashMap<>(); if (loaders.length == 0) { try { ServiceLoader<T> loadedServices = ServiceLoader.load(contract); addServices(loadedServices, services); } catch (Exception e) { } } else { for (ClassLoader loader : loaders) { if (loader == null) throw new NullPointerException(); try { ServiceLoader<T> loadedServices = ServiceLoader.load(contract, loader); addServices(loadedServices, services); } catch (Exception e) { } } } if (services.isEmpty()) { LOG.debugf("No service impls found: %s", contract.getSimpleName()); } return services.values(); } static Collection<T> load(Class<T> contract, ClassLoader... loaders); }### Answer: @Test public void testDuplicateServiceFinder() { ClassLoader mainClassLoader = this.getClass().getClassLoader(); ClassLoader otherClassLoader = new ClonedClassLoader(mainClassLoader); Collection<SampleSPI> spis = ServiceFinder.load(SampleSPI.class, mainClassLoader, otherClassLoader); assertEquals(1, spis.size()); }
### Question: RestRouteSource implements PrefixedRouteSource { @Override public void validate() { if (pathPrefix == null \|\| !pathPrefix.matches("\\w+")) { throw new IllegalArgumentException("Path is incorrect"); } } RestRouteSource(String pathPrefix); @Override String getRoutePrefix(); @Override String toString(); @Override void validate(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldValidatePath() { new RestRouteSource(null).validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateWithWhiteCharacters() { new RestRouteSource("12312 234").validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateStartingSlash() { new RestRouteSource("/test").validate(); } @Test public void shouldPassOnCorrectPath() { new RestRouteSource("correctPath").validate(); }
### Question: RestServerRouteDestination implements RouteDestination { @Override public void validate() { if (name == null \|\| "".equals(name)) { throw new IllegalArgumentException("Name can not be null"); } if (restServer == null) { throw new IllegalArgumentException("REST resource can not be null"); } } RestServerRouteDestination(String name, RestServer restServer); String getName(); RestServer getRestServer(); @Override String toString(); @Override void validate(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldValidateName() { new RestServerRouteDestination(null, new RestServer()).validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateRestResource() { new RestServerRouteDestination("test", null).validate(); }
### Question: SniNettyRouteSource implements SniRouteSource { @Override public void validate() { if (sniHostName == null \|\| "".equals(sniHostName)) { throw new IllegalArgumentException("SNI Host name can not be null"); } if (jdkContext == null) { throw new IllegalArgumentException("JDK SSL Context must not be null"); } } SniNettyRouteSource(String sniHostName, SSLContext sslContext); SniNettyRouteSource(String sniHostName, String keyStoreFileName, char[] keyStorePassword); @Override SSLContext getSslContext(); @Override String getSniHostName(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override void validate(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldValidateSniHostName() throws Exception { new SniNettyRouteSource(null, SSLContext.getDefault()).validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateSSLContext() throws Exception { new SniNettyRouteSource("test", null).validate(); }
### Question: HotRodServerRouteDestination implements RouteDestination { @Override public void validate() { if (name == null \|\| "".equals(name)) { throw new IllegalArgumentException("Name can not be null"); } if (hotrodServer == null) { throw new IllegalArgumentException("Channels can not be null"); } } HotRodServerRouteDestination(String name, HotRodServer hotRodServer); HotRodServer getHotrodServer(); @Override String toString(); @Override void validate(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldValidateName() { new HotRodServerRouteDestination(null, new HotRodServer()).validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateChannelInitializer() { new HotRodServerRouteDestination("test", null).validate(); }
### Question: RangeSet implements IntSet { @Override public boolean contains(Object o) { if (!(o instanceof Integer)) return false; int i = (int) o; return contains(i); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void contains() throws Exception { RangeSet rs = new RangeSet(4); assertFalse(rs.contains(5)); assertTrue(rs.contains(1)); } @Test public void contains1() throws Exception { RangeSet rs = new RangeSet(4); assertFalse(rs.contains(Integer.valueOf(5))); assertTrue(rs.contains(Integer.valueOf(1))); }
### Question: JsonTranscoder extends OneToManyTranscoder { @Override public Object transcode(Object content, MediaType contentType, MediaType destinationType) { if (destinationType.match(APPLICATION_OCTET_STREAM) \|\| destinationType.match(APPLICATION_UNKNOWN)) { return StandardConversions.convertTextToOctetStream(content, contentType); } boolean outputString = destinationType.hasStringType(); Charset contentCharset = contentType.getCharset(); Charset destinationCharset = destinationType.getCharset(); if (destinationType.match(APPLICATION_JSON)) { if (contentType.match(APPLICATION_JSON)) { return convertCharset(content, contentCharset, destinationCharset, outputString); } try { if (content instanceof String \|\| content instanceof byte[]) { return convertTextToJson(content, contentCharset, destinationCharset, outputString); } logger.jsonObjectConversionDeprecated(); if (outputString) { return objectMapper.writeValueAsString(content); } try (ByteArrayOutputStream out = new ByteArrayOutputStream(); OutputStreamWriter osw = new OutputStreamWriter(out, destinationCharset)) { objectMapper.writeValue(osw, content); return out.toByteArray(); } } catch (IOException e) { throw logger.cannotConvertContent(content, contentType, destinationType); } } if (destinationType.match(APPLICATION_OBJECT)) { logger.jsonObjectConversionDeprecated(); try { String destinationClassName = destinationType.getClassType(); Class<?> destinationClass = Object.class; if (destinationClassName != null) destinationClass = Class.forName(destinationClassName); if (content instanceof byte[]) { return objectMapper.readValue((byte[]) content, destinationClass); } return objectMapper.readValue((String) content, destinationClass); } catch (IOException \| ClassNotFoundException e) { throw new CacheException(e); } } if (destinationType.match(TEXT_PLAIN)) { return convertCharset(content, contentCharset, destinationCharset, outputString); } throw logger.unsupportedContent(JsonTranscoder.class.getSimpleName(), content); } JsonTranscoder(); JsonTranscoder(ClassAllowList allowList); JsonTranscoder(ClassLoader classLoader, ClassAllowList allowList); @Override Object transcode(Object content, MediaType contentType, MediaType destinationType); static final String TYPE_PROPERTY; }### Answer: @Test public void testEmptyContent() { byte[] empty = Util.EMPTY_BYTE_ARRAY; assertArrayEquals(empty, (byte[]) transcoder.transcode(empty, APPLICATION_JSON, APPLICATION_JSON.withCharset(US_ASCII))); assertArrayEquals(empty, (byte[]) transcoder.transcode(empty, APPLICATION_UNKNOWN, APPLICATION_JSON)); assertArrayEquals(empty, (byte[]) transcoder.transcode(empty, APPLICATION_OCTET_STREAM, APPLICATION_JSON)); assertArrayEquals(empty, (byte[]) transcoder.transcode(empty, TEXT_PLAIN, APPLICATION_JSON)); assertArrayEquals(empty, (byte[]) transcoder.transcode(empty, APPLICATION_OBJECT, APPLICATION_JSON)); }
### Question: SpringEmbeddedCacheManager implements CacheManager { public EmbeddedCacheManager getNativeCacheManager() { return this.nativeCacheManager; } SpringEmbeddedCacheManager(final EmbeddedCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); EmbeddedCacheManager getNativeCacheManager(); void stop(); }### Answer: @Test public final void getNativeCacheShouldReturnTheEmbeddedCacheManagerSuppliedAtConstructionTime() { withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager()) { @Override public void call() { final SpringEmbeddedCacheManager objectUnderTest = new SpringEmbeddedCacheManager(cm); final EmbeddedCacheManager nativeCacheManagerReturned = objectUnderTest.getNativeCacheManager(); assertSame( "getNativeCacheManager() should have returned the EmbeddedCacheManager supplied at construction time. However, it retuned a different one.", cm, nativeCacheManagerReturned); } }); }
### Question: SpringEmbeddedCacheManager implements CacheManager { @Override public SpringCache getCache(final String name) { return springCaches.computeIfAbsent(name, n -> { final Cache<Object, Object> nativeCache = this.nativeCacheManager.getCache(n); return new SpringCache(nativeCache); }); } SpringEmbeddedCacheManager(final EmbeddedCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); EmbeddedCacheManager getNativeCacheManager(); void stop(); }### Answer: @Test public final void getCacheShouldReturnSameInstanceForSameName() { withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager()) { @Override public void call() { cm.defineConfiguration("same", new ConfigurationBuilder().build()); final SpringEmbeddedCacheManager objectUnderTest = new SpringEmbeddedCacheManager(cm); final String sameCacheName = "same"; final SpringCache firstObtainedSpringCache = objectUnderTest.getCache(sameCacheName); final SpringCache secondObtainedSpringCache = objectUnderTest.getCache(sameCacheName); assertSame( "getCache() should have returned the same SpringCache instance for the same name", firstObtainedSpringCache, secondObtainedSpringCache); } }); } @Test public final void getCacheShouldReturnDifferentInstancesForDifferentNames() { withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager()) { @Override public void call() { cm.defineConfiguration("thisCache", new ConfigurationBuilder().build()); cm.defineConfiguration("thatCache", new ConfigurationBuilder().build()); final SpringEmbeddedCacheManager objectUnderTest = new SpringEmbeddedCacheManager(cm); final String firstCacheName = "thisCache"; final String secondCacheName = "thatCache"; final SpringCache firstObtainedSpringCache = objectUnderTest.getCache(firstCacheName); final SpringCache secondObtainedSpringCache = objectUnderTest.getCache(secondCacheName); assertNotSame( "getCache() should have returned different SpringCache instances for different names", firstObtainedSpringCache, secondObtainedSpringCache); } }); }
### Question: SpringEmbeddedCacheManagerFactoryBean extends AbstractEmbeddedCacheManagerFactory implements FactoryBean<SpringEmbeddedCacheManager>, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override SpringEmbeddedCacheManager getObject(); @Override Class<? extends SpringEmbeddedCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test public void testIfSpringEmbeddedCacheManagerFactoryBeanDeclaresItselfToOnlyProduceSingletons() { objectUnderTest = new SpringEmbeddedCacheManagerFactoryBean(); assertTrue("isSingleton() should always return true. However, it returned false", objectUnderTest.isSingleton()); }
### Question: InfinispanNamedEmbeddedCacheFactoryBean implements FactoryBean<Cache<K, V>>, BeanNameAware, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override Cache<K, V> getObject(); @Override Class<? extends Cache> getObjectType(); @Override boolean isSingleton(); @Override void setBeanName(final String name); @Override void destroy(); void setCacheName(final String cacheName); void setInfinispanEmbeddedCacheManager( final EmbeddedCacheManager infinispanEmbeddedCacheManager); void setConfigurationTemplateMode(final String configurationTemplateMode); void addCustomConfiguration(final ConfigurationBuilder builder); }### Answer: @Test public final void infinispanNamedEmbeddedCacheFactoryBeanShouldDeclareItselfToBeSingleton() { final InfinispanNamedEmbeddedCacheFactoryBean<Object, Object> objectUnderTest = new InfinispanNamedEmbeddedCacheFactoryBean<Object, Object>(); assertTrue( "InfinispanNamedEmbeddedCacheFactoryBean should declare itself to produce a singleton. However, it didn't.", objectUnderTest.isSingleton()); }
### Question: InfinispanEmbeddedCacheManagerFactoryBean extends AbstractEmbeddedCacheManagerFactory implements FactoryBean<EmbeddedCacheManager>, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override EmbeddedCacheManager getObject(); @Override Class<? extends EmbeddedCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test public final void infinispanEmbeddedCacheManagerFactoryBeanShouldDeclareItselfToOnlyProduceSingletons() { final InfinispanEmbeddedCacheManagerFactoryBean objectUnderTest = new InfinispanEmbeddedCacheManagerFactoryBean(); assertTrue("isSingleton() should always return true. However, it returned false", objectUnderTest.isSingleton()); }
### Question: SpringRemoteCacheManagerFactoryBean extends AbstractRemoteCacheManagerFactory implements FactoryBean<SpringRemoteCacheManager>, InitializingBean, DisposableBean { @Override public void afterPropertiesSet() throws Exception { assertCorrectlyConfigured(); this.logger.info("Creating new instance of RemoteCacheManager ..."); final Properties configurationPropertiesToUse = configurationProperties(); org.infinispan.client.hotrod.configuration.ConfigurationBuilder clientBuilder = new org.infinispan.client.hotrod.configuration.ConfigurationBuilder(); clientBuilder.withProperties(configurationPropertiesToUse); long readTimeout; if (configurationPropertiesToUse.containsKey(ConfigurationPropertiesOverrides.OPERATION_READ_TIMEOUT)) readTimeout = Long.parseLong(configurationPropertiesToUse.getProperty(ConfigurationPropertiesOverrides.OPERATION_READ_TIMEOUT)); else readTimeout = 0; long writeTimeout; if (configurationPropertiesToUse.containsKey(ConfigurationPropertiesOverrides.OPERATION_WRITE_TIMEOUT)) writeTimeout = Long.parseLong(configurationPropertiesToUse.getProperty(ConfigurationPropertiesOverrides.OPERATION_WRITE_TIMEOUT)); else writeTimeout = 0; final RemoteCacheManager nativeRemoteCacheManager = new RemoteCacheManager( clientBuilder.build(), this.startAutomatically); this.springRemoteCacheManager = new SpringRemoteCacheManager(nativeRemoteCacheManager, readTimeout, writeTimeout); this.logger.info("Finished creating new instance of RemoteCacheManager"); } @Override void afterPropertiesSet(); @Override SpringRemoteCacheManager getObject(); @Override Class<? extends SpringRemoteCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test(expectedExceptions = IllegalStateException.class) public final void shouldThrowAnIllegalStateExceptionIfBothConfigurationPropertiesAndConfifurationPropertiesFileLocationAreSet() throws Exception { objectUnderTest = new SpringRemoteCacheManagerFactoryBean(); objectUnderTest.setConfigurationProperties(new Properties()); objectUnderTest.setConfigurationPropertiesFileLocation(new ClassPathResource("dummy", getClass())); objectUnderTest.afterPropertiesSet(); } @Test(expectedExceptions = IllegalStateException.class) public final void shouldThrowAnIllegalStateExceptionIfConfigurationPropertiesAsWellAsSettersAreUsedToConfigureTheRemoteCacheManager() throws Exception { objectUnderTest = new SpringRemoteCacheManagerFactoryBean(); objectUnderTest.setConfigurationProperties(new Properties()); objectUnderTest.setMarshaller("test.Marshaller"); objectUnderTest.afterPropertiesSet(); }
### Question: SpringRemoteCacheManagerFactoryBean extends AbstractRemoteCacheManagerFactory implements FactoryBean<SpringRemoteCacheManager>, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override SpringRemoteCacheManager getObject(); @Override Class<? extends SpringRemoteCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test public final void isSingletonShouldAlwaysReturnTrue() { objectUnderTest = new SpringRemoteCacheManagerFactoryBean(); assertTrue( "isSingleton() should always return true since each SpringRemoteCacheManagerFactoryBean will always produce " + "the same SpringRemoteCacheManager instance. However,it returned false.", objectUnderTest.isSingleton()); }
### Question: RangeSet implements IntSet { @Override public PrimitiveIterator.OfInt iterator() { return new RangeSetIterator(size); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void iterator() throws Exception { RangeSet rs = new RangeSet(4); PrimitiveIterator.OfInt iterator = rs.iterator(); assertEquals(0, iterator.nextInt()); assertEquals(1, iterator.nextInt()); assertEquals(2, iterator.nextInt()); assertEquals(3, iterator.nextInt()); }
### Question: SpringRemoteCacheManager implements org.springframework.cache.CacheManager { @Override public SpringCache getCache(final String name) { final RemoteCache<Object, Object> nativeCache = this.nativeCacheManager.getCache(name); if (nativeCache == null) { springCaches.remove(name); return null; } return springCaches.computeIfAbsent(name, n -> new SpringCache(nativeCache, readTimeout, writeTimeout)); } SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager, long readTimeout, long writeTimeout); SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); RemoteCacheManager getNativeCacheManager(); long getReadTimeout(); long getWriteTimeout(); void setReadTimeout(final long readTimeout); void setWriteTimeout(final long writeTimeout); void start(); void stop(); }### Answer: @Test public final void springRemoteCacheManagerShouldProperlyCreateCache() { final Cache defaultCache = objectUnderTest.getCache(TEST_CACHE_NAME); assertNotNull("getCache(" + TEST_CACHE_NAME + ") should have returned a default cache. However, it returned null.", defaultCache); assertEquals("getCache(" + TEST_CACHE_NAME + ") should have returned a cache name \"" + TEST_CACHE_NAME + "\". However, the returned cache has a different name.", TEST_CACHE_NAME, defaultCache.getName()); } @Test public final void getCacheShouldReturnSameInstanceForSameName() { final SpringCache firstObtainedSpringCache = objectUnderTest.getCache(TEST_CACHE_NAME); final SpringCache secondObtainedSpringCache = objectUnderTest.getCache(TEST_CACHE_NAME); assertSame( "getCache() should have returned the same SpringCache instance for the same name", firstObtainedSpringCache, secondObtainedSpringCache); } @Test public final void getCacheShouldReturnDifferentInstancesForDifferentNames() { final SpringCache firstObtainedSpringCache = objectUnderTest.getCache(TEST_CACHE_NAME); final SpringCache secondObtainedSpringCache = objectUnderTest.getCache(OTHER_TEST_CACHE_NAME); assertNotSame( "getCache() should have returned different SpringCache instances for different names", firstObtainedSpringCache, secondObtainedSpringCache); } @Test public final void getCacheShouldReturnNullItWasChangedByRemoteCacheManager() { objectUnderTest.getCache(TEST_CACHE_NAME); remoteCacheManager.administration().removeCache(TEST_CACHE_NAME); assertNull(objectUnderTest.getCache(TEST_CACHE_NAME)); }
### Question: SpringRemoteCacheManager implements org.springframework.cache.CacheManager { @Override public Collection<String> getCacheNames() { return this.nativeCacheManager.getCacheNames(); } SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager, long readTimeout, long writeTimeout); SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); RemoteCacheManager getNativeCacheManager(); long getReadTimeout(); long getWriteTimeout(); void setReadTimeout(final long readTimeout); void setWriteTimeout(final long writeTimeout); void start(); void stop(); }### Answer: @Test public final void getCacheNamesShouldReturnAllCachesDefinedInConfigurationFile() { final Collection<String> cacheNames = objectUnderTest.getCacheNames(); assertTrue("SpringRemoteCacheManager should load all named caches found in the " + "native cache manager. However, it does not know about the cache named " + TEST_CACHE_NAME + " defined in said cache manager.", cacheNames.contains(TEST_CACHE_NAME)); }
### Question: SpringRemoteCacheManager implements org.springframework.cache.CacheManager { public void start() { this.nativeCacheManager.start(); } SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager, long readTimeout, long writeTimeout); SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); RemoteCacheManager getNativeCacheManager(); long getReadTimeout(); long getWriteTimeout(); void setReadTimeout(final long readTimeout); void setWriteTimeout(final long writeTimeout); void start(); void stop(); }### Answer: @Test public final void startShouldStartTheNativeRemoteCacheManager() throws IOException { objectUnderTest.start(); assertTrue("Calling start() on SpringRemoteCacheManager should start the enclosed " + "Infinispan RemoteCacheManager. However, it is still not running.", remoteCacheManager.isStarted()); }
### Question: SpringRemoteCacheManager implements org.springframework.cache.CacheManager { public void stop() { this.nativeCacheManager.stop(); this.springCaches.clear(); } SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager, long readTimeout, long writeTimeout); SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); RemoteCacheManager getNativeCacheManager(); long getReadTimeout(); long getWriteTimeout(); void setReadTimeout(final long readTimeout); void setWriteTimeout(final long writeTimeout); void start(); void stop(); }### Answer: @Test public final void stopShouldStopTheNativeRemoteCacheManager() throws IOException { objectUnderTest.stop(); assertFalse("Calling stop() on SpringRemoteCacheManager should stop the enclosed " + "Infinispan RemoteCacheManager. However, it is still running.", remoteCacheManager.isStarted()); }
### Question: SpringRemoteCacheManager implements org.springframework.cache.CacheManager { public RemoteCacheManager getNativeCacheManager() { return this.nativeCacheManager; } SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager, long readTimeout, long writeTimeout); SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); RemoteCacheManager getNativeCacheManager(); long getReadTimeout(); long getWriteTimeout(); void setReadTimeout(final long readTimeout); void setWriteTimeout(final long writeTimeout); void start(); void stop(); }### Answer: @Test public final void getNativeCacheShouldReturnTheRemoteCacheManagerSuppliedAtConstructionTime() { final RemoteCacheManager nativeCacheManagerReturned = objectUnderTest.getNativeCacheManager(); assertSame( "getNativeCacheManager() should have returned the RemoteCacheManager supplied at construction time. However, it retuned a different one.", remoteCacheManager, nativeCacheManagerReturned); }
### Question: ConfigurationPropertiesOverrides { public boolean isEmpty() { return this.overridingProperties.isEmpty(); } boolean isEmpty(); @Deprecated void setTransportFactory(final String TransportFactory); void setServerList(final Collection<InetSocketAddress> serverList); void setMarshaller(final String marshaller); void setClassAllowList(final String allowListRegex); void setAsyncExecutorFactory(final String asyncExecutorFactory); void setTcpNoDelay(final boolean tcpNoDelay); void setTcpKeepAlive(final boolean tcpKeepAlive); void setRequestBalancingStrategy(final String requestBalancingStrategy); @Deprecated void setKeySizeEstimate(final int keySizeEstimate); @Deprecated void setValueSizeEstimate(final int valueSizeEstimate); void setForceReturnValues(final boolean forceReturnValues); void setReadTimeout(long readTimeout); void setWriteTimeout(long writeTimeout); void setNearCacheMode(String mode); void setNearCacheMaxEntries(int maxEntries); void setNearCacheNamePattern(String pattern); Properties override(final Properties configurationPropertiesToOverride); static final String OPERATION_READ_TIMEOUT; static final String OPERATION_WRITE_TIMEOUT; }### Answer: @Test public final void testIfIsEmptyRecognizesThatConfigurationPropertiesOverridesAreEmpty() { final ConfigurationPropertiesOverrides objectUnderTest = new ConfigurationPropertiesOverrides(); assertTrue( "isEmpty() should have noticed that the ConfigurationPropertiesOverrides instance is indeed empty. However, it didn't.", objectUnderTest.isEmpty()); }
### Question: InfinispanRemoteCacheManagerFactoryBean extends AbstractRemoteCacheManagerFactory implements FactoryBean<RemoteCacheManager>, InitializingBean, DisposableBean { @Override public void afterPropertiesSet() throws Exception { assertCorrectlyConfigured(); this.logger.info("Creating new instance of RemoteCacheManager ..."); final Properties configurationPropertiesToUse = configurationProperties(); org.infinispan.client.hotrod.configuration.ConfigurationBuilder clientBuilder = new org.infinispan.client.hotrod.configuration.ConfigurationBuilder(); clientBuilder.withProperties(configurationPropertiesToUse); this.nativeRemoteCacheManager = new RemoteCacheManager(clientBuilder.build(), this.startAutomatically); this.logger.info("Finished creating new instance of RemoteCacheManager"); } @Override void afterPropertiesSet(); @Override RemoteCacheManager getObject(); @Override Class<? extends RemoteCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test(expectedExceptions = IllegalStateException.class) public final void shouldThrowAnIllegalStateExceptionIfBothConfigurationPropertiesAndConfigurationPropertiesFileLocationAreSet() throws Exception { final InfinispanRemoteCacheManagerFactoryBean objectUnderTest = new InfinispanRemoteCacheManagerFactoryBean(); objectUnderTest.setConfigurationProperties(new Properties()); objectUnderTest.setConfigurationPropertiesFileLocation(new ClassPathResource("dummy", getClass())); objectUnderTest.afterPropertiesSet(); } @Test(expectedExceptions = IllegalStateException.class) public final void shouldThrowAnIllegalStateExceptionIfConfigurationPropertiesAsWellAsSettersAreUsedToConfigureTheRemoteCacheManager() throws Exception { final InfinispanRemoteCacheManagerFactoryBean objectUnderTest = new InfinispanRemoteCacheManagerFactoryBean(); objectUnderTest.setConfigurationProperties(new Properties()); objectUnderTest.setMarshaller("test.Marshaller"); objectUnderTest.afterPropertiesSet(); }
### Question: RangeSet implements IntSet { @Override public Object[] toArray() { Object[] array = new Object[size]; for (int i = 0; i < size; i++) { array[i] = i; } return array; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void toArray() throws Exception { RangeSet rs = new RangeSet(4); Object[] array = rs.toArray(); assertEquals(4, array.length); assertEquals(0, array[0]); assertEquals(1, array[1]); assertEquals(2, array[2]); assertEquals(3, array[3]); } @Test public void toArray1() throws Exception { RangeSet rs = new RangeSet(4); Object[] array = rs.toArray(new Integer[4]); assertEquals(4, array.length); assertEquals(0, array[0]); assertEquals(1, array[1]); assertEquals(2, array[2]); assertEquals(3, array[3]); }
### Question: InfinispanRemoteCacheManagerFactoryBean extends AbstractRemoteCacheManagerFactory implements FactoryBean<RemoteCacheManager>, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override RemoteCacheManager getObject(); @Override Class<? extends RemoteCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test public final void isSingletonShouldAlwaysReturnTrue() { final InfinispanRemoteCacheManagerFactoryBean objectUnderTest = new InfinispanRemoteCacheManagerFactoryBean(); assertTrue( "isSingleton() should always return true since each AbstractRemoteCacheManagerFactory will always produce " + "the same RemoteCacheManager instance. However,it returned false.", objectUnderTest.isSingleton()); }
### Question: InfinispanNamedRemoteCacheFactoryBean implements FactoryBean<RemoteCache<K, V>>, BeanNameAware, InitializingBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override void setBeanName(final String name); @Override RemoteCache<K, V> getObject(); @Override Class<? extends ConcurrentMap> getObjectType(); @Override boolean isSingleton(); void setCacheName(final String cacheName); void setInfinispanRemoteCacheManager(final RemoteCacheManager infinispanRemoteCacheManager); }### Answer: @Test public final void infinispanNamedRemoteCacheFactoryBeanShouldDeclareItselfToBeSingleton() { final InfinispanNamedRemoteCacheFactoryBean<String, Object> objectUnderTest = new InfinispanNamedRemoteCacheFactoryBean<String, Object>(); assertTrue( "InfinispanNamedRemoteCacheFactoryBean should declare itself to produce a singleton. However, it didn't.", objectUnderTest.isSingleton()); }
### Question: RangeSet implements IntSet { @Override public int[] toIntArray() { int[] array = new int[size]; for (int i = 0; i < size; i++) { array[i] = i; } return array; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void toIntArray() throws Exception { RangeSet rs = new RangeSet(4); int[] array = rs.toIntArray(); assertArrayEquals(new int[]{0, 1, 2, 3}, array); }
### Question: RangeSet implements IntSet { @Override public boolean add(Integer integer) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void add() throws Exception { RangeSet rs = new RangeSet(4); rs.add(1); } @Test(expected = UnsupportedOperationException.class) public void add1() throws Exception { RangeSet rs = new RangeSet(4); rs.add(Integer.valueOf(1)); } @Test public void equals1() throws Exception { IntSet intSet = new RangeSet(4); SmallIntSet sis = new SmallIntSet(); sis.add(0); sis.add(1); sis.add(2); assertNotEquals(sis, intSet); assertNotEquals(intSet, sis); sis.add(3); assertEquals(sis, intSet); assertEquals(intSet, sis); } @Test public void equals2() throws Exception { IntSet rs = new RangeSet(4); Set<Integer> hashSet = new HashSet<>(); hashSet.add(0); hashSet.add(1); hashSet.add(2); assertNotEquals(rs, hashSet); assertNotEquals(hashSet, rs); hashSet.add(3); assertEquals(rs, hashSet); assertEquals(hashSet, rs); }
### Question: RangeSet implements IntSet { public void set(int i) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void set() throws Exception { RangeSet rs = new RangeSet(4); rs.set(1); }
### Question: RangeSet implements IntSet { @Override public boolean remove(Object o) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void remove() throws Exception { RangeSet rs = new RangeSet(4); rs.remove(1); } @Test(expected = UnsupportedOperationException.class) public void remove1() throws Exception { RangeSet rs = new RangeSet(4); rs.remove(Integer.valueOf(1)); }
### Question: RangeSet implements IntSet { @Override public boolean containsAll(Collection<?> c) { if (c instanceof IntSet) { return containsAll((IntSet) c); } for (Object o : c) { if (!contains(o)) return false; } return true; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void containsAll() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(4); assertTrue(rs.containsAll(rs2)); RangeSet rs3 = new RangeSet(3); assertTrue(rs.containsAll(rs3)); assertFalse(rs3.containsAll(rs)); }
### Question: RangeSet implements IntSet { @Override public boolean addAll(IntSet set) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void addAll() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(5); rs.addAll(rs2); } @Test(expected = UnsupportedOperationException.class) public void addAll1() throws Exception { RangeSet rs = new RangeSet(4); SmallIntSet sis = new SmallIntSet(); rs.addAll(sis); }
### Question: RangeSet implements IntSet { @Override public boolean removeAll(IntSet set) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void removeAll() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(6); rs.removeAll(rs2); } @Test(expected = UnsupportedOperationException.class) public void removeAll1() throws Exception { RangeSet rs = new RangeSet(5); SmallIntSet sis = new SmallIntSet(); rs.removeAll(sis); } @Test(expected = UnsupportedOperationException.class) public void removeAll2() throws Exception { RangeSet rs = new RangeSet(4); Set<Integer> hashSet = new HashSet<>(); rs.removeAll(hashSet); }
### Question: RangeSet implements IntSet { @Override public boolean retainAll(Collection<?> c) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void retainAll() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(5); rs.retainAll(rs2); } @Test(expected = UnsupportedOperationException.class) public void retainAll1() throws Exception { IntSet rs = new RangeSet(5); SmallIntSet sis = new SmallIntSet(); rs.retainAll(sis); } @Test(expected = UnsupportedOperationException.class) public void retainAll2() throws Exception { RangeSet rs = new RangeSet(4); Set<Integer> hashSet = new HashSet<>(); rs.retainAll(hashSet); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public boolean isEmpty() { return true; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testIsEmpty() { assertTrue(es.isEmpty()); }
### Question: RangeSet implements IntSet { @Override public void clear() { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void clear() throws Exception { RangeSet rs = new RangeSet(5); rs.clear(); }
### Question: RangeSet implements IntSet { @Override public IntStream intStream() { return IntStream.range(0, size); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void intStream() throws Exception { IntSet rs = new RangeSet(5); assertEquals(10, rs.intStream().sum()); }
### Question: RangeSet implements IntSet { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null \|\| !(o instanceof Set)) return false; if (o instanceof RangeSet) { RangeSet integers = (RangeSet) o; return size == integers.size; } else { Set set = (Set) o; return size == set.size() && containsAll(set); } } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void equals() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(5); assertNotEquals(rs, rs2); assertNotEquals(rs2, rs); RangeSet rs3 = new RangeSet(4); assertEquals(rs3, rs); assertEquals(rs, rs3); }
### Question: RangeSet implements IntSet { @Override public boolean removeIf(IntPredicate filter) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void removeIfPrimitive() { RangeSet rs = new RangeSet(4); rs.removeIf((int i) -> i == 3); } @Test(expected = UnsupportedOperationException.class) public void removeIfObject() { RangeSet rs = new RangeSet(4); rs.removeIf((Integer i) -> i == 3); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public int size() { return 1; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testSize() { IntSet rs = new SingletonIntSet(3); assertEquals(1, rs.size()); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public boolean isEmpty() { return false; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testIsEmpty() { IntSet rs = new SingletonIntSet(3); assertFalse(rs.isEmpty()); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public boolean contains(int i) { return value == i; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testContains() throws Exception { IntSet sis = new SingletonIntSet(3); assertFalse(sis.contains(5)); assertTrue(sis.contains(3)); } @Test public void testContains1() throws Exception { IntSet sis = new SingletonIntSet(3); assertFalse(sis.contains(Integer.valueOf(5))); assertTrue(sis.contains(Integer.valueOf(3))); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public boolean contains(int i) { return false; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testContains() throws Exception { assertFalse(es.contains(5)); assertFalse(es.contains(3)); } @Test public void testContains1() throws Exception { assertFalse(es.contains(Integer.valueOf(5))); assertFalse(es.contains(Integer.valueOf(3))); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public PrimitiveIterator.OfInt iterator() { return new SingleIntIterator(); } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testIterator() throws Exception { IntSet sis = new SingletonIntSet(3); PrimitiveIterator.OfInt iterator = sis.iterator(); assertEquals(3, iterator.nextInt()); assertFalse(iterator.hasNext()); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public Object[] toArray() { Object[] array = new Object[1]; array[0] = value; return array; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testToArray() throws Exception { IntSet sis = new SingletonIntSet(3); Object[] array = sis.toArray(); assertEquals(1, array.length); assertEquals(3, array[0]); } @Test public void testToArray1() throws Exception { IntSet sis = new SingletonIntSet(3); Object[] array = sis.toArray(new Integer[1]); assertEquals(1, array.length); assertEquals(3, array[0]); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public int[] toIntArray() { int[] array = new int[1]; array[0] = value; return array; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testToIntArray() throws Exception { IntSet sis = new SingletonIntSet(3); int[] array = sis.toIntArray(); assertArrayEquals(new int[]{3}, array); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public boolean containsAll(IntSet set) { int size = set.size(); return size == 0 \|\| size == 1 && set.contains(value); } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testContainsAll() throws Exception { IntSet sis = new SingletonIntSet(3); IntSet sis2 = new SingletonIntSet(3); assertTrue(sis.containsAll(sis2)); assertTrue(sis2.containsAll(sis)); IntSet sis3 = new RangeSet(4); assertTrue(sis3.containsAll(sis)); assertFalse(sis.containsAll(sis3)); } @Test public void testContainsAll1() throws Exception { IntSet sis = new SingletonIntSet(3); Set<Integer> hashSet = new HashSet<>(Arrays.asList(3)); assertTrue(sis.containsAll(hashSet)); assertTrue(hashSet.containsAll(sis)); hashSet.add(0); assertTrue(hashSet.containsAll(sis)); assertFalse(sis.containsAll(hashSet)); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public IntStream intStream() { return IntStream.of(value); } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testIntStream() throws Exception { IntSet sis = new SingletonIntSet(3); assertEquals(1, sis.intStream().count()); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public boolean equals(Object o) { if (o == this) { return true; } if (o == null \|\| !(o instanceof Set)) return false; if (o instanceof IntSet) { IntSet intSet = (IntSet) o; return intSet.size() == 1 && intSet.contains(value); } else { Set set = (Set) o; return set.size() == 1 && set.contains(value); } } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testEquals() throws Exception { IntSet sis = new SingletonIntSet(3); IntSet sis2 = new SingletonIntSet(4); assertNotEquals(sis, sis2); assertNotEquals(sis2, sis); IntSet sis3 = SmallIntSet.of(3); assertEquals(sis3, sis); assertEquals(sis, sis3); }
### Question: ProcessorInfo { public static int availableProcessors() { if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedAction<Integer>) () -> Integer.valueOf(org.infinispan.commons.jdkspecific.ProcessorInfo.availableProcessors()).intValue()); } return org.infinispan.commons.jdkspecific.ProcessorInfo.availableProcessors(); } private ProcessorInfo(); static int availableProcessors(); static void main(String args[]); }### Answer: @Test @Category(Java11.class) public void testCPUCount() { assertTrue(ProcessorInfo.availableProcessors() <= Runtime.getRuntime().availableProcessors()); }
### Question: Features { public Features(ClassLoader classLoader) { features = new Properties(); try { Collection<URL> featureFiles = FileLookupFactory.newInstance().lookupFileLocations(FEATURES_FILE, classLoader); for (URL url : featureFiles) { try (InputStream is = url.openStream()) { features.load(is); } } if (log.isDebugEnabled()) { features.forEach((key, value) -> log.debugf("Feature %s=%s", key, value)); } } catch (IOException e) { log.debugf(e, "Error while attempting to obtain `%s` resources from the classpath", FEATURES_FILE); throw new CacheConfigurationException(e); } } Features(ClassLoader classLoader); Features(); boolean isAvailable(String featureName); static final String FEATURE_PREFIX; }### Answer: @Test public void testFeatures() { Features features = new Features(); assertFalse(features.isAvailable("A")); assertTrue(features.isAvailable("B")); }
### Question: Features { public boolean isAvailable(String featureName) { String name = FEATURE_PREFIX + featureName; String sysprop = SecurityActions.getProperty(name); if (sysprop != null) { return Boolean.parseBoolean(sysprop); } else { return Boolean.parseBoolean(features.getProperty(name, "true")); } } Features(ClassLoader classLoader); Features(); boolean isAvailable(String featureName); static final String FEATURE_PREFIX; }### Answer: @Test public void featureSysOverride() { Features features = new Features(); assertFalse(features.isAvailable("A")); System.setProperty("org.infinispan.feature.A", "true"); System.setProperty("org.infinispan.feature.B", "false"); boolean a = features.isAvailable("A"); boolean b = features.isAvailable("B"); System.clearProperty("org.infinispan.feature.A"); System.clearProperty("org.infinispan.feature.B"); assertTrue(a); assertFalse(b); }
### Question: JavaSerializationMarshaller extends AbstractMarshaller { @Override public Object objectFromByteBuffer(byte[] buf, int offset, int length) throws IOException, ClassNotFoundException { try (ObjectInputStream ois = new CheckedInputStream(new ByteArrayInputStream(buf), allowList)) { return ois.readObject(); } } JavaSerializationMarshaller(); JavaSerializationMarshaller(ClassAllowList allowList); @Override void initialize(ClassAllowList classAllowList); @Override Object objectFromByteBuffer(byte[] buf, int offset, int length); @Override boolean isMarshallable(Object o); @Override MediaType mediaType(); }### Answer: @Test public void testPrimitiveArrays() throws Exception { JavaSerializationMarshaller marshaller = new JavaSerializationMarshaller(); byte[] bytes = marshaller.objectToByteBuffer(new byte[0]); assertArrayEquals(new byte[0], (byte[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new short[0]); assertArrayEquals(new short[0], (short[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new int[0]); assertArrayEquals(new int[0], (int[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new long[0]); assertArrayEquals(new long[0], (long[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new float[0]); assertArrayEquals(new float[0], (float[]) marshaller.objectFromByteBuffer(bytes), 0); bytes = marshaller.objectToByteBuffer(new double[0]); assertArrayEquals(new double[0], (double[]) marshaller.objectFromByteBuffer(bytes), 0); bytes = marshaller.objectToByteBuffer(new char[0]); assertArrayEquals(new char[0], (char[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new boolean[0]); assertArrayEquals(new boolean[0], (boolean[]) marshaller.objectFromByteBuffer(bytes)); }
### Question: JavaSerializationMarshaller extends AbstractMarshaller { @Override public boolean isMarshallable(Object o) { return o instanceof Serializable; } JavaSerializationMarshaller(); JavaSerializationMarshaller(ClassAllowList allowList); @Override void initialize(ClassAllowList classAllowList); @Override Object objectFromByteBuffer(byte[] buf, int offset, int length); @Override boolean isMarshallable(Object o); @Override MediaType mediaType(); }### Answer: @Test public void testBoxedPrimitivesAndArray() throws Exception { JavaSerializationMarshaller marshaller = new JavaSerializationMarshaller(); isMarshallable(marshaller, Byte.MAX_VALUE); isMarshallable(marshaller, Short.MAX_VALUE); isMarshallable(marshaller, Integer.MAX_VALUE); isMarshallable(marshaller, Long.MAX_VALUE); isMarshallable(marshaller, Float.MAX_VALUE); isMarshallable(marshaller, Double.MAX_VALUE); isMarshallable(marshaller, 'c'); isMarshallable(marshaller, "String"); } @Test public void testMath() throws Exception { JavaSerializationMarshaller marshaller = new JavaSerializationMarshaller(); isMarshallable(marshaller, BigDecimal.TEN); isMarshallable(marshaller, BigInteger.TEN); } @Test public void testDate() throws Exception { JavaSerializationMarshaller marshaller = new JavaSerializationMarshaller(); isMarshallable(marshaller, Instant.now()); }
### Question: MediaTypeResolver { public static String getMediaType(String fileName) { if (fileName == null) return null; int idx = fileName.lastIndexOf("."); if (idx == -1 \|\| idx == fileName.length()) return null; return FILE_MAP.get(fileName.toLowerCase().substring(idx + 1)); } private MediaTypeResolver(); static String getMediaType(String fileName); }### Answer: @Test public void testResolver() { assertNull(MediaTypeResolver.getMediaType(null)); assertNull(MediaTypeResolver.getMediaType("noextension")); assertNull(MediaTypeResolver.getMediaType("124.")); assertEquals("application/javascript", MediaTypeResolver.getMediaType("file.js")); assertEquals("image/jpeg", MediaTypeResolver.getMediaType("file.jpg")); assertEquals("image/jpeg", MediaTypeResolver.getMediaType("file.jpeg")); assertEquals("image/jpeg", MediaTypeResolver.getMediaType("file.jpe")); assertEquals("text/css", MediaTypeResolver.getMediaType("file.css")); assertEquals("text/html", MediaTypeResolver.getMediaType("file.htm")); assertEquals("text/html", MediaTypeResolver.getMediaType("file.html")); assertEquals("application/java-archive", MediaTypeResolver.getMediaType("file.JAR")); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public PrimitiveIterator.OfInt iterator() { return EmptyIntIterator.INSTANCE; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testIterator() throws Exception { PrimitiveIterator.OfInt iterator = es.iterator(); assertFalse(iterator.hasNext()); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public Object[] toArray() { return new Object[0]; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testToArray() throws Exception { Object[] array = es.toArray(); assertEquals(0, array.length); } @Test public void testToArray1() throws Exception { Object[] array = es.toArray(new Integer[1]); assertEquals(1, array.length); assertEquals(null, array[0]); array = es.toArray(new Integer[0]); assertEquals(0, array.length); }
### Question: StandardConversions { public static Object convertTextToText(Object source, MediaType sourceType, MediaType destinationType) { if (source == null) return null; if (sourceType == null) throw new NullPointerException("MediaType cannot be null!"); if (!sourceType.match(MediaType.TEXT_PLAIN)) throw CONTAINER.invalidMediaType(TEXT_PLAIN_TYPE, sourceType.toString()); boolean asString = destinationType.hasStringType(); Charset sourceCharset = sourceType.getCharset(); Charset destinationCharset = destinationType.getCharset(); if (sourceCharset.equals(destinationCharset)) return convertTextClass(source, destinationType, asString); byte[] byteContent = source instanceof byte[] ? (byte[]) source : source.toString().getBytes(sourceCharset); return convertTextClass(convertCharset(byteContent, sourceCharset, destinationCharset), destinationType, asString); } static Object convertTextToText(Object source, MediaType sourceType, MediaType destinationType); static byte[] convertTextToOctetStream(Object source, MediaType sourceType); static String convertTextToObject(Object source, MediaType sourceType); static String convertTextToUrlEncoded(Object source, MediaType sourceType); static byte[] convertOctetStreamToText(byte[] source, MediaType destination); static Object convertOctetStreamToJava(byte[] source, MediaType destination, Marshaller marshaller); static byte[] convertJavaToOctetStream(Object source, MediaType sourceMediaType, Marshaller marshaller); static byte[] convertJavaToProtoStream(Object source, MediaType sourceMediaType, ImmutableSerializationContext ctx); static byte[] convertJavaToText(Object source, MediaType sourceMediaType, MediaType destinationMediaType); static Object decodeObjectContent(Object content, MediaType contentMediaType); static byte[] convertCharset(Object content, Charset fromCharset, Charset toCharset); static byte[] decodeOctetStream(Object input, MediaType octetStream); static String bytesToHex(byte[] bytes); static byte[] hexToBytes(String hex); static Object convertUrlEncodedToObject(Object content); static Object convertUrlEncodedToText(Object content, MediaType destinationType); static Object convertUrlEncodedToOctetStream(Object content); static String urlEncode(Object content, MediaType mediaType); static Object urlDecode(Object content); static Object convertOctetStreamToUrlEncoded(Object content, MediaType contentType); }### Answer: @Test public void textToTextConversion() { String source = "All those moments will be lost in time, like tears in rain."; byte[] sourceAs8859 = source.getBytes(ISO_8859_1); byte[] sourceAsASCII = source.getBytes(US_ASCII); Object result = StandardConversions.convertTextToText(sourceAs8859, TEXT_PLAIN.withCharset(ISO_8859_1), TEXT_PLAIN.withCharset(US_ASCII)); assertArrayEquals(sourceAsASCII, (byte[]) result); }
### Question: StandardConversions { public static byte[] convertTextToOctetStream(Object source, MediaType sourceType) { if (source == null) return null; if (sourceType == null) { throw new NullPointerException("MediaType cannot be null!"); } if (source instanceof byte[]) return (byte[]) source; return source.toString().getBytes(sourceType.getCharset()); } static Object convertTextToText(Object source, MediaType sourceType, MediaType destinationType); static byte[] convertTextToOctetStream(Object source, MediaType sourceType); static String convertTextToObject(Object source, MediaType sourceType); static String convertTextToUrlEncoded(Object source, MediaType sourceType); static byte[] convertOctetStreamToText(byte[] source, MediaType destination); static Object convertOctetStreamToJava(byte[] source, MediaType destination, Marshaller marshaller); static byte[] convertJavaToOctetStream(Object source, MediaType sourceMediaType, Marshaller marshaller); static byte[] convertJavaToProtoStream(Object source, MediaType sourceMediaType, ImmutableSerializationContext ctx); static byte[] convertJavaToText(Object source, MediaType sourceMediaType, MediaType destinationMediaType); static Object decodeObjectContent(Object content, MediaType contentMediaType); static byte[] convertCharset(Object content, Charset fromCharset, Charset toCharset); static byte[] decodeOctetStream(Object input, MediaType octetStream); static String bytesToHex(byte[] bytes); static byte[] hexToBytes(String hex); static Object convertUrlEncodedToObject(Object content); static Object convertUrlEncodedToText(Object content, MediaType destinationType); static Object convertUrlEncodedToOctetStream(Object content); static String urlEncode(Object content, MediaType mediaType); static Object urlDecode(Object content); static Object convertOctetStreamToUrlEncoded(Object content, MediaType contentType); }### Answer: @Test public void testTextToOctetStreamConversion() { String source = "Like our owl?"; byte[] result = StandardConversions.convertTextToOctetStream(source, TEXT_PLAIN); assertArrayEquals(source.getBytes(UTF_8), result); }
### Question: StandardConversions { public static String convertTextToObject(Object source, MediaType sourceType) { if (source == null) return null; if (source instanceof String) return source.toString(); if (source instanceof byte[]) { byte[] bytesSource = (byte[]) source; return new String(bytesSource, sourceType.getCharset()); } throw CONTAINER.invalidTextContent(source); } static Object convertTextToText(Object source, MediaType sourceType, MediaType destinationType); static byte[] convertTextToOctetStream(Object source, MediaType sourceType); static String convertTextToObject(Object source, MediaType sourceType); static String convertTextToUrlEncoded(Object source, MediaType sourceType); static byte[] convertOctetStreamToText(byte[] source, MediaType destination); static Object convertOctetStreamToJava(byte[] source, MediaType destination, Marshaller marshaller); static byte[] convertJavaToOctetStream(Object source, MediaType sourceMediaType, Marshaller marshaller); static byte[] convertJavaToProtoStream(Object source, MediaType sourceMediaType, ImmutableSerializationContext ctx); static byte[] convertJavaToText(Object source, MediaType sourceMediaType, MediaType destinationMediaType); static Object decodeObjectContent(Object content, MediaType contentMediaType); static byte[] convertCharset(Object content, Charset fromCharset, Charset toCharset); static byte[] decodeOctetStream(Object input, MediaType octetStream); static String bytesToHex(byte[] bytes); static byte[] hexToBytes(String hex); static Object convertUrlEncodedToObject(Object content); static Object convertUrlEncodedToText(Object content, MediaType destinationType); static Object convertUrlEncodedToOctetStream(Object content); static String urlEncode(Object content, MediaType mediaType); static Object urlDecode(Object content); static Object convertOctetStreamToUrlEncoded(Object content, MediaType contentType); }### Answer: @Test public void testTextToObjectConversion() { String source = "Can the maker repair what he makes?"; String source2 = "I had your job once. I was good at it."; byte[] sourceBytes = source2.getBytes(US_ASCII); Object result = StandardConversions.convertTextToObject(source, APPLICATION_OBJECT); Object result2 = StandardConversions.convertTextToObject(sourceBytes, TEXT_PLAIN.withCharset(US_ASCII)); assertEquals(source, result); assertEquals(source2, result2); }
### Question: StandardConversions { public static String convertTextToUrlEncoded(Object source, MediaType sourceType) { return urlEncode(source, sourceType); } static Object convertTextToText(Object source, MediaType sourceType, MediaType destinationType); static byte[] convertTextToOctetStream(Object source, MediaType sourceType); static String convertTextToObject(Object source, MediaType sourceType); static String convertTextToUrlEncoded(Object source, MediaType sourceType); static byte[] convertOctetStreamToText(byte[] source, MediaType destination); static Object convertOctetStreamToJava(byte[] source, MediaType destination, Marshaller marshaller); static byte[] convertJavaToOctetStream(Object source, MediaType sourceMediaType, Marshaller marshaller); static byte[] convertJavaToProtoStream(Object source, MediaType sourceMediaType, ImmutableSerializationContext ctx); static byte[] convertJavaToText(Object source, MediaType sourceMediaType, MediaType destinationMediaType); static Object decodeObjectContent(Object content, MediaType contentMediaType); static byte[] convertCharset(Object content, Charset fromCharset, Charset toCharset); static byte[] decodeOctetStream(Object input, MediaType octetStream); static String bytesToHex(byte[] bytes); static byte[] hexToBytes(String hex); static Object convertUrlEncodedToObject(Object content); static Object convertUrlEncodedToText(Object content, MediaType destinationType); static Object convertUrlEncodedToOctetStream(Object content); static String urlEncode(Object content, MediaType mediaType); static Object urlDecode(Object content); static Object convertOctetStreamToUrlEncoded(Object content, MediaType contentType); }### Answer: @Test public void testTextToURLEncodedConversion() throws UnsupportedEncodingException { String source = "They're either a benefit or a hazard. If they're a benefit, it's not my problem."; String result = StandardConversions.convertTextToUrlEncoded(source, TEXT_PLAIN.withCharset(UTF_16)); assertEquals(URLEncoder.encode(source, "UTF-16"), result); }
### Question: StandardConversions { public static byte[] convertOctetStreamToText(byte[] source, MediaType destination) { if (source == null) return null; return convertCharset(source, UTF_8, destination.getCharset()); } static Object convertTextToText(Object source, MediaType sourceType, MediaType destinationType); static byte[] convertTextToOctetStream(Object source, MediaType sourceType); static String convertTextToObject(Object source, MediaType sourceType); static String convertTextToUrlEncoded(Object source, MediaType sourceType); static byte[] convertOctetStreamToText(byte[] source, MediaType destination); static Object convertOctetStreamToJava(byte[] source, MediaType destination, Marshaller marshaller); static byte[] convertJavaToOctetStream(Object source, MediaType sourceMediaType, Marshaller marshaller); static byte[] convertJavaToProtoStream(Object source, MediaType sourceMediaType, ImmutableSerializationContext ctx); static byte[] convertJavaToText(Object source, MediaType sourceMediaType, MediaType destinationMediaType); static Object decodeObjectContent(Object content, MediaType contentMediaType); static byte[] convertCharset(Object content, Charset fromCharset, Charset toCharset); static byte[] decodeOctetStream(Object input, MediaType octetStream); static String bytesToHex(byte[] bytes); static byte[] hexToBytes(String hex); static Object convertUrlEncodedToObject(Object content); static Object convertUrlEncodedToText(Object content, MediaType destinationType); static Object convertUrlEncodedToOctetStream(Object content); static String urlEncode(Object content, MediaType mediaType); static Object urlDecode(Object content); static Object convertOctetStreamToUrlEncoded(Object content, MediaType contentType); }### Answer: @Test public void testOctetStreamToTextConversion() { String text = "Have you ever retired a human by mistake?"; byte[] bytes1 = text.getBytes(); byte[] bytes2 = new byte[]{1, 2, 3}; byte[] result1 = StandardConversions.convertOctetStreamToText(bytes1, TEXT_PLAIN.withCharset(US_ASCII)); byte[] result2 = StandardConversions.convertOctetStreamToText(bytes2, TEXT_PLAIN); assertArrayEquals(text.getBytes(US_ASCII), result1); assertArrayEquals(new String(bytes2).getBytes(UTF_8), result2); }
### Question: StandardConversions { public static Object convertOctetStreamToJava(byte[] source, MediaType destination, Marshaller marshaller) { if (source == null) return null; if (!destination.match(MediaType.APPLICATION_OBJECT)) { throw CONTAINER.invalidMediaType(APPLICATION_OBJECT_TYPE, destination.toString()); } String classType = destination.getClassType(); if (classType == null) return source; if (classType.equals("ByteArray")) { return source; } if (destination.hasStringType()) { return new String(source, UTF_8); } try { return marshaller.objectFromByteBuffer(source); } catch (IOException \| IllegalStateException \| ClassNotFoundException e) { throw CONTAINER.conversionNotSupported(source, MediaType.APPLICATION_OCTET_STREAM_TYPE, destination.toString()); } } static Object convertTextToText(Object source, MediaType sourceType, MediaType destinationType); static byte[] convertTextToOctetStream(Object source, MediaType sourceType); static String convertTextToObject(Object source, MediaType sourceType); static String convertTextToUrlEncoded(Object source, MediaType sourceType); static byte[] convertOctetStreamToText(byte[] source, MediaType destination); static Object convertOctetStreamToJava(byte[] source, MediaType destination, Marshaller marshaller); static byte[] convertJavaToOctetStream(Object source, MediaType sourceMediaType, Marshaller marshaller); static byte[] convertJavaToProtoStream(Object source, MediaType sourceMediaType, ImmutableSerializationContext ctx); static byte[] convertJavaToText(Object source, MediaType sourceMediaType, MediaType destinationMediaType); static Object decodeObjectContent(Object content, MediaType contentMediaType); static byte[] convertCharset(Object content, Charset fromCharset, Charset toCharset); static byte[] decodeOctetStream(Object input, MediaType octetStream); static String bytesToHex(byte[] bytes); static byte[] hexToBytes(String hex); static Object convertUrlEncodedToObject(Object content); static Object convertUrlEncodedToText(Object content, MediaType destinationType); static Object convertUrlEncodedToOctetStream(Object content); static String urlEncode(Object content, MediaType mediaType); static Object urlDecode(Object content); static Object convertOctetStreamToUrlEncoded(Object content, MediaType contentType); }### Answer: @Test public void testOctetStreamToJavaConversion() { String value = "It's not an easy thing to meet your maker."; byte[] textStream = value.getBytes(UTF_8); byte[] randomBytes = new byte[]{23, 23, 34, 1, -1, -123}; Marshaller marshaller = new ProtoStreamMarshaller(); MediaType stringType = APPLICATION_OBJECT.withParameter("type", "java.lang.String"); Object result = StandardConversions.convertOctetStreamToJava(textStream, stringType, marshaller); assertEquals(value, result); MediaType byteArrayType = APPLICATION_OBJECT.withParameter("type", "ByteArray"); Object result2 = StandardConversions.convertOctetStreamToJava(textStream, byteArrayType, marshaller); assertArrayEquals(textStream, (byte[]) result2); Object result3 = StandardConversions.convertOctetStreamToJava(randomBytes, byteArrayType, marshaller); assertArrayEquals(randomBytes, (byte[]) result3); thrown.expect(EncodingException.class); MediaType doubleType = APPLICATION_OBJECT.withParameter("type", "java.lang.Double"); StandardConversions.convertOctetStreamToJava(randomBytes, doubleType, marshaller); System.out.println(thrown); }
### Question: StandardConversions { public static byte[] convertJavaToText(Object source, MediaType sourceMediaType, MediaType destinationMediaType) { if (source == null) return null; if (sourceMediaType == null \|\| destinationMediaType == null) { throw new NullPointerException("sourceMediaType and destinationMediaType cannot be null!"); } Object decoded = decodeObjectContent(source, sourceMediaType); if (decoded instanceof byte[]) { return convertCharset(source, StandardCharsets.UTF_8, destinationMediaType.getCharset()); } else { String asString = decoded.toString(); return asString.getBytes(destinationMediaType.getCharset()); } } static Object convertTextToText(Object source, MediaType sourceType, MediaType destinationType); static byte[] convertTextToOctetStream(Object source, MediaType sourceType); static String convertTextToObject(Object source, MediaType sourceType); static String convertTextToUrlEncoded(Object source, MediaType sourceType); static byte[] convertOctetStreamToText(byte[] source, MediaType destination); static Object convertOctetStreamToJava(byte[] source, MediaType destination, Marshaller marshaller); static byte[] convertJavaToOctetStream(Object source, MediaType sourceMediaType, Marshaller marshaller); static byte[] convertJavaToProtoStream(Object source, MediaType sourceMediaType, ImmutableSerializationContext ctx); static byte[] convertJavaToText(Object source, MediaType sourceMediaType, MediaType destinationMediaType); static Object decodeObjectContent(Object content, MediaType contentMediaType); static byte[] convertCharset(Object content, Charset fromCharset, Charset toCharset); static byte[] decodeOctetStream(Object input, MediaType octetStream); static String bytesToHex(byte[] bytes); static byte[] hexToBytes(String hex); static Object convertUrlEncodedToObject(Object content); static Object convertUrlEncodedToText(Object content, MediaType destinationType); static Object convertUrlEncodedToOctetStream(Object content); static String urlEncode(Object content, MediaType mediaType); static Object urlDecode(Object content); static Object convertOctetStreamToUrlEncoded(Object content, MediaType contentType); }### Answer: @Test public void testJavaToTextConversion() { String string = "I've seen things you people wouldn't believe."; Double number = 12.1d; Calendar complex = Calendar.getInstance(); MediaType stringType = APPLICATION_OBJECT.withParameter("type", "java.lang.String"); byte[] result1 = StandardConversions.convertJavaToText(string, stringType, TEXT_PLAIN.withCharset(UTF_16BE)); assertArrayEquals(string.getBytes(UTF_16BE), result1); MediaType doubleType = APPLICATION_OBJECT.withParameter("type", "java.lang.Double"); byte[] result2 = StandardConversions.convertJavaToText(number, doubleType, TEXT_PLAIN.withCharset(US_ASCII)); assertArrayEquals("12.1".getBytes(US_ASCII), result2); MediaType customType = APPLICATION_OBJECT.withParameter("type", complex.getClass().getName()); byte[] bytes = StandardConversions.convertJavaToText(complex, customType, TEXT_PLAIN.withCharset(US_ASCII)); assertEquals(complex.toString(), new String(bytes)); }
### Question: TemperatureNotification implements BluetoothNotification<byte[]> { @Override public void run(byte[] bytes) { float ambientTemp = decodeTemperature(bytes[0], bytes[1]); SensorLog sensorLog = new SensorLog(config.getId(), ImmutableMap.of(TEMP_VALUE_ID, ambientTemp)); processor.onNext(sensorLog); } TemperatureNotification(SensorConfig config, FlowableProcessor<SensorLog> processor); @Override void run(byte[] bytes); static final String TEMP_VALUE_ID; }### Answer: @Test public void producesValidSensorLog() { Faker faker = new Faker(); int temp = faker.number().numberBetween(-50, 50); float decimal = (float)faker.number().randomDouble(5, 0, 1); SensorConfig config = new SensorConfig("someId", "nordic", null); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); TemperatureNotification notification = new TemperatureNotification(config, processor); notification.run(new byte[] { (byte)temp, (byte)(decimal * 256) }); SensorLog createdLog = processor.blockingFirst(); assertThat(createdLog).isNotNull(); assertThat(createdLog.getSensorId()).matches(config.getId()); assertThat(createdLog.getAttributeValue()).containsKey(TemperatureNotification.TEMP_VALUE_ID); assertThat((float)createdLog.getAttributeValue().get(TemperatureNotification.TEMP_VALUE_ID)).isWithin(0.01f).of(temp + decimal); }
### Question: ColorNotification implements BluetoothNotification<byte[]> { @Override public void run(byte[] bytes) { int red = decodeColor(bytes[1], bytes[0]); int green = decodeColor(bytes[3], bytes[2]); int blue = decodeColor(bytes[5], bytes[4]); int clear = decodeColor(bytes[7], bytes[6]); SensorLog sensorLog = new SensorLog(config.getId(), ImmutableMap.of(COLOUR_RED_VALUE_ID, red, COLOUR_GREEN_VALUE_ID, green, COLOUR_BLUE_VALUE_ID, blue, COLOUR_CLEAR_VALUE_ID, clear)); processor.onNext(sensorLog); } ColorNotification(SensorConfig config, FlowableProcessor<SensorLog> processor); @Override void run(byte[] bytes); static final String COLOUR_RED_VALUE_ID; static final String COLOUR_GREEN_VALUE_ID; static final String COLOUR_BLUE_VALUE_ID; static final String COLOUR_CLEAR_VALUE_ID; }### Answer: @Test public void producesValidSensorLog() { Faker faker = new Faker(); int red = faker.number().numberBetween(0, 32768); int green = faker.number().numberBetween(0, 32768); int blue = faker.number().numberBetween(0, 32768); int clear = faker.number().numberBetween(0, 32768); SensorConfig config = new SensorConfig("someId", "sensortag", null); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); ColorNotification notification = new ColorNotification(config, processor); notification.run(new byte[] { (byte)red, (byte)(red >> 8), (byte)green, (byte)(green >> 8), (byte)blue, (byte)(blue >> 8), (byte)clear, (byte)(clear >> 8) }); SensorLog createdLog = processor.blockingFirst(); assertThat(createdLog).isNotNull(); assertThat(createdLog.getSensorId()).matches(config.getId()); assertThat(createdLog.getAttributeValue()).containsExactly( ColorNotification.COLOUR_RED_VALUE_ID, red, ColorNotification.COLOUR_GREEN_VALUE_ID, green, ColorNotification.COLOUR_BLUE_VALUE_ID, blue, ColorNotification.COLOUR_CLEAR_VALUE_ID, clear); }
### Question: HumidityNotification implements BluetoothNotification<byte[]> { @Override public void run(byte[] bytes) { int relativeHumidity = decodeHumidity(bytes[0]); SensorLog sensorLog = new SensorLog(config.getId(), ImmutableMap.of("relative_humidity", relativeHumidity)); processor.onNext(sensorLog); } HumidityNotification(SensorConfig config, FlowableProcessor<SensorLog> processor); @Override void run(byte[] bytes); static final String HUMIDITY_VALUE_ID; }### Answer: @Test public void producesValidSensorLog() { Faker faker = new Faker(); int humidity = faker.number().numberBetween(0, 100); SensorConfig config = new SensorConfig("someId", "", null); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); HumidityNotification notification = new HumidityNotification(config, processor); notification.run(new byte[] { (byte)(humidity & 0xff) }); SensorLog createdLog = processor.blockingFirst(); assertThat(createdLog).isNotNull(); assertThat(createdLog.getSensorId()).matches(config.getId()); assertThat(createdLog.getAttributeValue()).containsExactly(HumidityNotification.HUMIDITY_VALUE_ID, humidity); }
### Question: PressureNotification implements BluetoothNotification<byte[]> { @Override public void run(byte[] bytes) { float pressure = decodePressure(bytes); SensorLog sensorLog = new SensorLog(config.getId(), ImmutableMap.of(PRESSURE_VALUE_ID, pressure)); processor.onNext(sensorLog); } PressureNotification(SensorConfig config, FlowableProcessor<SensorLog> processor); @Override void run(byte[] bytes); static final String PRESSURE_VALUE_ID; }### Answer: @Test public void producesValidSensorLog() { Faker faker = new Faker(); int pressure = faker.number().numberBetween(-100000, 100000); float decimal = (float)faker.number().randomDouble(4, 0, 1); byte[] pressureBytes = Ints.toByteArray(pressure); SensorConfig config = new SensorConfig("someId", "thingy",null); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); PressureNotification notification = new PressureNotification(config, processor); notification.run(new byte[] { pressureBytes[3], pressureBytes[2], pressureBytes[1], pressureBytes[0], (byte)(decimal * 256) }); SensorLog createdLog = processor.blockingFirst(); assertThat(createdLog).isNotNull(); assertThat(createdLog.getSensorId()).matches(config.getId()); assertThat(createdLog.getAttributeValue()).containsKey(PressureNotification.PRESSURE_VALUE_ID); assertThat((float)createdLog.getAttributeValue().get(PressureNotification.PRESSURE_VALUE_ID)).isWithin(0.01f).of(pressure + decimal); }
### Question: AirQualityNotification implements BluetoothNotification<byte[]> { @Override public void run(byte[] bytes) { int eCO2 = decodeECO2(bytes[1], bytes[0]); int tvoc = decodeTVOC(bytes[3], bytes[2]); SensorLog sensorLog = new SensorLog(config.getId(), ImmutableMap.of(CO2_VALUE_ID, eCO2, TVOC_VALUE_ID, tvoc)); processor.onNext(sensorLog); } AirQualityNotification(SensorConfig config, FlowableProcessor<SensorLog> processor); @Override void run(byte[] bytes); static final String CO2_VALUE_ID; static final String TVOC_VALUE_ID; }### Answer: @Test public void producesValidSensorLog() { int eCO2 = 400; byte[] eCO2bytes = Ints.toByteArray(eCO2); int TVOC = 121; byte[] TVOCbytes = Ints.toByteArray(TVOC); SensorConfig config = new SensorConfig("someId", "sensortag", null); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); AirQualityNotification notification = new AirQualityNotification(config, processor); notification.run(new byte[] { eCO2bytes[3], eCO2bytes[2], TVOCbytes[3], TVOCbytes[2] }); SensorLog createdLog = processor.blockingFirst(); assertThat(createdLog).isNotNull(); assertThat(createdLog.getSensorId()).matches(config.getId()); assertThat(createdLog.getAttributeValue()).containsExactly(AirQualityNotification.CO2_VALUE_ID, eCO2, AirQualityNotification.TVOC_VALUE_ID, TVOC); }
### Question: WebSensorTask extends TimerTask { public List<String[]> pollSensor() { setDatesPollInterval(); List<String[]> data = null; Call<List<String[]>> call = webApi.getHcJsonData(getQueryParameters()); try { data = call.execute().body(); for (String[] dataArray: data) { log.info("Time: " + dataArray[0] + " Data: " + dataArray[1]); SensorLog sensorLog = new SensorLog( config.getId(), ImmutableMap.of(config.getStringProperty(WebSensor.CONFIG_KEY_SUB_SENSOR), dataArray[1]), LocalDateTime.ofEpochSecond(Long.valueOf(dataArray[0])/1000, 0, ZoneOffset.UTC) ); processor.onNext(sensorLog); } } catch (IOException e) { e.printStackTrace(); log.warn("This sensor may not be returning data please check the sensor api webpage."); } return data; } WebSensorTask(SensorConfig webSensorConfig, int pollIntervalMinutes, FlowableProcessor<SensorLog> processor, UtsWebApi webApi); void setDatesPollInterval(); List<String[]> pollSensor(); @Override void run(); }### Answer: @Test public void testSensorTask() throws IOException { SensorConfig webSensorConfig1 = new SensorConfig("web", ImmutableMap.of( WebSensor.CONFIG_KEY_FAMILY, "wasp", WebSensor.CONFIG_KEY_SENSOR, "ES_B_05_416_7C15", WebSensor.CONFIG_KEY_SUB_SENSOR, "BAT" )); MockWebServer server = new MockWebServer(); server.enqueue(new MockResponse().setBody("[[1508752848000,91],[1508753270000,92],[1508753692000,92],[1508754114000,87]]")); server.start(); Retrofit retrofit = new Retrofit.Builder() .baseUrl(server.url("").toString()) .addConverterFactory(JacksonConverterFactory.create()) .build(); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); WebSensorTask webSensorTask = new WebSensorTask(webSensorConfig1, 360, processor, retrofit.create(UtsWebApi.class)); webSensorTask.pollSensor(); SensorLog createdLog = null; try { createdLog = processor.timeout(5000, TimeUnit.MILLISECONDS).blockingFirst(); } catch (Exception e) { if (e.getMessage().equals("java.util.concurrent.TimeoutException")) { } else { throw e; } } if (createdLog != null) { assertThat(createdLog.getSensorId()).matches(webSensorConfig1.getId()); assertThat(createdLog.getAttributeValue()).hasSize(1); } }
### Question: OpticalNotification implements BluetoothNotification<byte[]> { @Override public void run(byte[] bytes) { float lux = decodeLux(bytes[1], bytes[0]); SensorLog sensorLog = new SensorLog(config.getId(), ImmutableMap.of(LIGHT_INTENSITY_VALUE_ID, lux)); processor.onNext(sensorLog); } OpticalNotification(SensorConfig config, FlowableProcessor<SensorLog> processor); @Override void run(byte[] bytes); static final String LIGHT_INTENSITY_VALUE_ID; }### Answer: @Test public void producesValidSensorLog() { Faker faker = new Faker(); int mantissa = faker.number().numberBetween(0, 4096); int exponent = faker.number().numberBetween(0, 16); float lux = mantissa * (float)Math.pow(2, exponent) / 100.0f; SensorConfig config = new SensorConfig("someId", "thingy", null); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); OpticalNotification notification = new OpticalNotification(config, processor); notification.run(new byte[] { (byte)(mantissa & 0xff), (byte)((mantissa >> 8 & 0x0f) \| (exponent << 4))}); SensorLog createdLog = processor.blockingFirst(); assertThat(createdLog).isNotNull(); assertThat(createdLog.getSensorId()).matches(config.getId()); assertThat(createdLog.getAttributeValue()).containsKey(OpticalNotification.LIGHT_INTENSITY_VALUE_ID); assertThat((float)createdLog.getAttributeValue().get(OpticalNotification.LIGHT_INTENSITY_VALUE_ID)).isWithin(0.1f).of(lux); }
### Question: TemperatureNotification implements BluetoothNotification<byte[]> { @Override public void run(byte[] bytes) { float objectTemp = decodeTemperature(bytes[1], bytes[0]); float ambientTemp = decodeTemperature(bytes[3], bytes[2]); SensorLog sensorLog = new SensorLog(config.getId(), ImmutableMap.of(OBJECT_TEMP_VALUE_ID, objectTemp, AMBIENT_TEMP_VALUE_ID, ambientTemp)); processor.onNext(sensorLog); } TemperatureNotification(SensorConfig config, FlowableProcessor<SensorLog> processor); @Override void run(byte[] bytes); static final String OBJECT_TEMP_VALUE_ID; static final String AMBIENT_TEMP_VALUE_ID; }### Answer: @Test public void producesValidSensorLog() { Faker faker = new Faker(); int objectTemp = faker.number().numberBetween(-50, 50); float objectTempDecimal = (float)faker.number().randomDouble(4, 0, 1); int ambientTemp = faker.number().numberBetween(-50, 50); float ambientTempDecimal = (float)faker.number().randomDouble(4, 0, 1); int objectTempNorm = ((objectTemp) << 7) \| (int)(objectTempDecimal * 128); int ambientTempNorm = ((ambientTemp) << 7) \| (int)(ambientTempDecimal * 128); SensorConfig config = new SensorConfig("someId", "sensortag",null); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); TemperatureNotification notification = new TemperatureNotification(config, processor); notification.run(new byte[] { (byte)(objectTempNorm & 0xff), (byte)(objectTempNorm >> 8), (byte)(ambientTempNorm & 0xff), (byte)(ambientTempNorm >> 8) }); SensorLog createdLog = processor.blockingFirst(); assertThat(createdLog).isNotNull(); assertThat(createdLog.getSensorId()).matches(config.getId()); assertThat((float)createdLog.getAttributeValue().get(TemperatureNotification.OBJECT_TEMP_VALUE_ID)).isWithin(0.1f).of(objectTemp + objectTempDecimal); assertThat((float)createdLog.getAttributeValue().get(TemperatureNotification.AMBIENT_TEMP_VALUE_ID)).isWithin(0.1f).of(ambientTemp + ambientTempDecimal); }
### Question: HumidityNotification implements BluetoothNotification<byte[]> { @Override public void run(byte[] bytes) { float temperature = decodeTemperature(bytes[1], bytes[0]); float humidity = decodeHumidity(bytes[3], bytes[2]); SensorLog sensorLog = new SensorLog(config.getId(), ImmutableMap.of(HUMIDITY_VALUE_ID, humidity, TEMPERATURE_VALUE_ID, temperature)); processor.onNext(sensorLog); } HumidityNotification(SensorConfig config, FlowableProcessor<SensorLog> processor); @Override void run(byte[] bytes); static final String HUMIDITY_VALUE_ID; static final String TEMPERATURE_VALUE_ID; }### Answer: @Test public void producesValidSensorLog() { Faker faker = new Faker(); double humidity = faker.number().randomDouble(4, 0, 50); int humidityNorm = (int)(humidity * 65536 / 100); double temperature = faker.number().randomDouble(4, -50, 50); int temperatureNorm = (int)((temperature + 40) / 165 * 65536); SensorConfig config = new SensorConfig("someId", "sensortag", null); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); HumidityNotification notification = new HumidityNotification(config, processor); notification.run(new byte[] { (byte)(temperatureNorm & 0xff), (byte)(temperatureNorm >> 8), (byte)(humidityNorm & 0xff), (byte)(humidityNorm >> 8) }); SensorLog createdLog = processor.blockingFirst(); assertThat(createdLog).isNotNull(); assertThat(createdLog.getSensorId()).matches(config.getId()); assertThat(createdLog.getAttributeValue()).containsKey(HumidityNotification.HUMIDITY_VALUE_ID); assertThat(createdLog.getAttributeValue()).containsKey(HumidityNotification.TEMPERATURE_VALUE_ID); assertThat((float)createdLog.getAttributeValue().get(HumidityNotification.HUMIDITY_VALUE_ID)).isWithin(0.1f).of((float)humidity); assertThat((float)createdLog.getAttributeValue().get(HumidityNotification.TEMPERATURE_VALUE_ID)).isWithin(0.1f).of((float)temperature); }
### Question: PressureNotification implements BluetoothNotification<byte[]> { @Override public void run(byte[] bytes) { float pressure = decodePressure(new byte[]{0x00, bytes[5], bytes[4], bytes[3]}); SensorLog sensorLog = new SensorLog(config.getId(), ImmutableMap.of("pressure", pressure)); processor.onNext(sensorLog); } PressureNotification(SensorConfig config, FlowableProcessor<SensorLog> processor); @Override void run(byte[] bytes); static final String PRESSURE_VALUE_ID; }### Answer: @Test public void producesValidSensorLog() { Faker faker = new Faker(); double pressure = faker.number().randomDouble(2, 0, 5000); int pressureNorm = (int)(pressure * 100); SensorConfig config = new SensorConfig("someId", "sensortag",null); ReplayProcessor<SensorLog> processor = ReplayProcessor.create(10); PressureNotification notification = new PressureNotification(config, processor); notification.run(new byte[] { 0, 0, 0, (byte)(pressureNorm & 0xff), (byte)(pressureNorm >> 8 & 0xff), (byte)(pressureNorm >> 16 & 0xff) }); SensorLog createdLog = processor.blockingFirst(); assertThat(createdLog).isNotNull(); assertThat(createdLog.getSensorId()).matches(config.getId()); assertThat(createdLog.getAttributeValue()).containsKey(PressureNotification.PRESSURE_VALUE_ID); assertThat((float)createdLog.getAttributeValue().get(PressureNotification.PRESSURE_VALUE_ID)).isWithin(0.1f).of((float)pressure); }
### Question: ExtensionLoaderFactory { public static <T> T load(final Class<T> service) { return ExtensionLoader.getExtensionLoader(service).load(findClassLoader()); } static T load(final Class<T> service); static T load(final Class<T> service, final String name); static T load(final Class<T> service, final ClassLoader loader); static T load(final Class<T> service, final String name, final ClassLoader loader); static T load(final Class<T> service, final String name, final Object[] args); static T load(final Class<T> service, final String name, final Class<?>[] argsType, final Object[] args); static List<T> loadAll(final Class<T> service); }### Answer: @Test public void testSPI() { HmilyTestSPI hmilyTestSPI = ExtensionLoaderFactory.load(HmilyTestSPI.class); assertThat(hmilyTestSPI.getClass().getName(), is(NoHelloTestSPI.class.getName())); HmilyTestSPI test2 = ExtensionLoaderFactory.load(HmilyTestSPI.class); assertThat(test2.getClass().getName(), is(NoHelloTestSPI.class.getName())); HmilyTestSPI hello1 = ExtensionLoaderFactory.load(HmilyTestSPI.class, "hello"); assertThat(hello1.getClass().getName(), is(HelloWorldTestSPI.class.getName())); HmilyTestSPI hello2 = ExtensionLoaderFactory.load(HmilyTestSPI.class, "hello"); assertThat(hello1.getClass().getName(), is(hello2.getClass().getName())); assertEquals(hello1, hello2); HmilyTestSPI no1 = ExtensionLoaderFactory.load(HmilyTestSPI.class, "no"); assertThat(no1.getClass().getName(), is(NoHelloTestSPI.class.getName())); HmilyTestSPI no2 = ExtensionLoaderFactory.load(HmilyTestSPI.class, "no"); assertNotEquals(no1, no2); }
### Question: ApolloConfigLoader implements ConfigLoader<ApolloConfig> { private void apolloLoad(final Supplier<Context> context, final LoaderHandler<ApolloConfig> handler, final ApolloConfig config) { if (config != null) { check(config); LOGGER.info("loader apollo config: {}", config); String fileExtension = config.getFileExtension(); PropertyLoader propertyLoader = LOADERS.get(fileExtension); if (propertyLoader == null) { throw new ConfigException("apollo.fileExtension setting error, The loader was not found"); } InputStream pull = client.pull(config); Optional.ofNullable(pull) .map(e -> propertyLoader.load("remote.apollo." + fileExtension, e)) .ifPresent(e -> context.get().getOriginal().load(() -> context.get().withSources(e), this::apolloFinish)); handler.finish(context, config); passive(context, null, config); } else { throw new ConfigException("apollo config is null"); } } ApolloConfigLoader(); ApolloConfigLoader(final ApolloClient apolloClient); @Override void load(final Supplier<Context> context, final LoaderHandler<ApolloConfig> handler); @Override void passive(final Supplier<Context> context, final PassiveHandler<Config> handler, final Config config); }### Answer: @Test public void testApolloLoad() { ConfigScan.scan(); ServerConfigLoader loader = new ServerConfigLoader(); ApolloConfigLoader apolloConfigLoader = new ApolloConfigLoader(client); loader.load(ConfigLoader.Context::new, (context, config) -> { if (config != null) { if (StringUtils.isNoneBlank(config.getConfigMode())) { String configMode = config.getConfigMode(); if (configMode.equals("apollo")) { apolloConfigLoader.load(context, this::assertTest); } } } }); }
### Question: NacosConfigLoader implements ConfigLoader<NacosConfig> { private void nacosLoad(final Supplier<Context> context, final LoaderHandler<NacosConfig> handler, final NacosConfig config) { if (config != null) { check(config); LOGGER.info("loader nacos config: {}", config); String fileExtension = config.getFileExtension(); PropertyLoader propertyLoader = LOADERS.get(fileExtension); if (propertyLoader == null) { throw new ConfigException("nacos.fileExtension setting error, The loader was not found"); } InputStream pull = client.pull(config); Optional.ofNullable(pull) .map(e -> propertyLoader.load(config.fileName(), e)) .ifPresent(e -> context.get().getOriginal().load(() -> context.get().withSources(e), this::nacosFinish)); handler.finish(context, config); try { client.addListener(context, (c1, c2) -> this.passive(c1, null, c2), config); } catch (NacosException e) { LOGGER.error("passive nacos remote started error...."); } } else { throw new ConfigException("nacos config is null"); } } NacosConfigLoader(); NacosConfigLoader(final NacosClient client); @Override void load(final Supplier<Context> context, final LoaderHandler<NacosConfig> handler); @Override void passive(final Supplier<Context> context, final PassiveHandler<Config> handler, final Config config); }### Answer: @Test public void testNacosLoad() { ConfigScan.scan(); ServerConfigLoader loader = new ServerConfigLoader(); NacosConfigLoader nacosConfigLoader = new NacosConfigLoader(client); loader.load(ConfigLoader.Context::new, (context, config) -> { if (config != null) { if (StringUtils.isNoneBlank(config.getConfigMode())) { String configMode = config.getConfigMode(); if (configMode.equals("nacos")) { nacosConfigLoader.load(context, this::assertTest); } } } }); }
### Question: LocalConfigLoader implements ConfigLoader<Config> { @Override public void load(final Supplier<Context> context, final LoaderHandler<Config> handler) { ConfigLoader<Config> original = context.get().getOriginal(); original.load(context, handler); } @Override void load(final Supplier<Context> context, final LoaderHandler<Config> handler); }### Answer: @Test public void load() { ConfigScan.scan(); ServerConfigLoader loader = new ServerConfigLoader(); loader.load(ConfigLoader.Context::new, (context, config) -> { System.out.println("config:---->" + config); if (config != null) { if (StringUtils.isNotBlank(config.getConfigMode())) { String configMode = config.getConfigMode(); if (configMode.equals("local")) { new LocalConfigLoader().load(context, (context1, config1) -> System.out.println("config1:-->" + config1)); } } } }); HmilyServer server = ConfigEnv.getInstance().getConfig(HmilyServer.class); HmilyConfig config = ConfigEnv.getInstance().getConfig(HmilyConfig.class); HmilyDatabaseConfig databaseConfig = ConfigEnv.getInstance().getConfig(HmilyDatabaseConfig.class); HmilyFileConfig fileConfig = ConfigEnv.getInstance().getConfig(HmilyFileConfig.class); HmilyMetricsConfig metricsConfig = ConfigEnv.getInstance().getConfig(HmilyMetricsConfig.class); HmilyMongoConfig mongoConfig = ConfigEnv.getInstance().getConfig(HmilyMongoConfig.class); HmilyRedisConfig redisConfig = ConfigEnv.getInstance().getConfig(HmilyRedisConfig.class); HmilyZookeeperConfig zookeeperConfig = ConfigEnv.getInstance().getConfig(HmilyZookeeperConfig.class); System.out.println(server); System.out.println(config); System.out.println(databaseConfig); System.out.println(fileConfig); System.out.println(metricsConfig); System.out.println(mongoConfig); System.out.println(redisConfig); System.out.println(zookeeperConfig); }
### Question: ZookeeperConfigLoader implements ConfigLoader<ZookeeperConfig> { @Override public void load(final Supplier<Context> context, final LoaderHandler<ZookeeperConfig> handler) { LoaderHandler<ZookeeperConfig> zookeeperLoad = (c, config) -> zookeeperLoad(c, handler, config); againLoad(context, zookeeperLoad, ZookeeperConfig.class); } ZookeeperConfigLoader(); ZookeeperConfigLoader(final CuratorZookeeperClient client); @Override void passive(final Supplier<Context> context, final PassiveHandler<Config> handler, final Config config); @Override void load(final Supplier<Context> context, final LoaderHandler<ZookeeperConfig> handler); }### Answer: @Test @Ignore public void realZookeeperLoad() { ZookeeperConfig remoteConfig = new ZookeeperConfig(); remoteConfig.setServerList("127.0.0.1:2181"); CuratorZookeeperClient client = CuratorZookeeperClient.getInstance(remoteConfig); client.persist("/hmily/xiaoyu", FileUtils.readYAML("hmily-zookeeper.yml")); ConfigScan.scan(); ZookeeperConfigLoader configLoader = new ZookeeperConfigLoader(client); ServerConfigLoader loader = new ServerConfigLoader(); loader.load(ConfigLoader.Context::new, (context, config) -> { System.out.println("config:---->" + config); if (config != null) { if (StringUtils.isNotBlank(config.getConfigMode())) { String configMode = config.getConfigMode(); if (configMode.equals("zookeeper")) { configLoader.load(context, (context1, config1) -> { }); } } } }); }
### Question: ZookeeperConfigLoader implements ConfigLoader<ZookeeperConfig> { private void zookeeperLoad(final Supplier<Context> context, final LoaderHandler<ZookeeperConfig> handler, final ZookeeperConfig config) { if (config != null) { check(config); if (Objects.isNull(client)) { client = CuratorZookeeperClient.getInstance(config); } if (config.isUpdate()) { client.persist(config.getPath(), FileUtils.readYAML(config.getUpdateFileName())); } InputStream result = client.pull(config.getPath()); String fileExtension = config.getFileExtension(); PropertyLoader propertyLoader = LOADERS.get(fileExtension); if (propertyLoader == null) { throw new ConfigException("zookeeper.fileExtension setting error, The loader was not found"); } Optional.ofNullable(result) .map(e -> propertyLoader.load("remote.zookeeper." + fileExtension, e)) .ifPresent(e -> context.get().getOriginal().load(() -> context.get().withSources(e), this::zookeeperFinish)); handler.finish(context, config); try { client.addListener(context, (c1, c2) -> this.passive(c1, null, c2), config); } catch (Exception e) { LOGGER.error("passive zookeeper remote started error...."); } } else { throw new ConfigException("zookeeper config is null"); } } ZookeeperConfigLoader(); ZookeeperConfigLoader(final CuratorZookeeperClient client); @Override void passive(final Supplier<Context> context, final PassiveHandler<Config> handler, final Config config); @Override void load(final Supplier<Context> context, final LoaderHandler<ZookeeperConfig> handler); }### Answer: @Test public void testZookeeperLoad() { ConfigScan.scan(); ServerConfigLoader loader = new ServerConfigLoader(); loader.load(ConfigLoader.Context::new, (context, config) -> { System.out.println("config:---->" + config); if (config != null) { if (StringUtils.isNotBlank(config.getConfigMode())) { String configMode = config.getConfigMode(); if (configMode.equals("zookeeper")) { new ZookeeperConfigLoader(client).load(context, this::assertTest); } } } }); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.