@Test public void tcclLoadsSerializableImpl() throws Exception { Class loadedClass = Class.forName(CLASS_NAME_SERIALIZABLE_IMPL, true, Thread.currentThread().getContextClassLoader()); assertThat(loadedClass).isNotNull(); assertThat(loadedClass.getName()).isEqualTo(CLASS_NAME_SERIALIZABLE_IMPL); Object instance = loadedClass.newInstance(); assertThat(instance).isNotNull(); assertThat(Serializable.class.isInstance(loadedClass)); assertThat(loadedClass.getInterfaces()).contains(Serializable.class); }
@Test public void tcclLoadsSerializableImplWithValue() throws Exception { Class loadedClass = Class.forName(CLASS_NAME_SERIALIZABLE_IMPL_WITH_VALUE, true, Thread.currentThread().getContextClassLoader()); assertThat(loadedClass).isNotNull(); assertThat(loadedClass.getName()).isEqualTo(CLASS_NAME_SERIALIZABLE_IMPL_WITH_VALUE); Object instance = loadedClass.newInstance(); assertThat(instance).isNotNull(); assertThat(loadedClass.getSuperclass().getName()).isEqualTo(CLASS_NAME_SERIALIZABLE_IMPL); assertThat(Serializable.class.isInstance(loadedClass)); assertThat(Valuable.class.isInstance(loadedClass)); assertThat(loadedClass.getInterfaces()).contains(Valuable.class); Method setter = loadedClass.getMethod("setValue", Object.class); assertThat(setter).isNotNull(); }
public static void assertFilesEqual(File expected, File actual) { if (expected.isDirectory()) { String[] children = Objects.requireNonNull(expected.list()); assertThat(actual.list()).contains(children); for (String name : children) { assertFilesEqual(new File(expected, name), new File(actual, name)); } } else { assertThat(getContent(actual)).isEqualTo(getContent(expected)); } }
/** * Tests serializing an object loaded with the current context class loader (whose parent is the * loader that loads GemFire and test classes). */ @Test public void handlesClassFromOtherClassLoader() throws Exception { Class loadedClass = Class.forName(CLASS_NAME_SERIALIZABLE_IMPL, true, Thread.currentThread().getContextClassLoader()); Object instance = loadedClass.newInstance(); byte[] bytes = BlobHelper.serializeToBlob(instance); Object object = BlobHelper.deserializeBlob(bytes); assertThat(object).isNotNull(); assertThat(object.getClass().getName()).isEqualTo(CLASS_NAME_SERIALIZABLE_IMPL); assertThat(Serializable.class.isInstance(object)); Class deserializedClass = object.getClass(); assertThat(deserializedClass.getInterfaces()).contains(Serializable.class); }
@Test @WithMockUser public void methodSecurityWhenDefaultProxyThenWiresToInterface() { this.spring.register(DefaultProxyConfig.class, MethodSecurityServiceConfig.class).autowire(); assertThat(this.service.getClass().getInterfaces()) .contains(MethodSecurityService.class); assertThatThrownBy(() -> this.service.preAuthorize()) .isInstanceOf(AccessDeniedException.class); }
@Test public void stringifyArray() throws Exception { List<String> multiple = new ArrayList<>(); multiple.add("a"); multiple.add("b"); gfJsonArray.put(multiple); gfJsonArray.put(1, multiple); gfJsonArray.put("c"); assertThat(GfJsonArray.toStringArray(gfJsonArray)).contains("[\"a\",\"b\"]", "[\"a\",\"b\"]", "c"); }
@Test public void generatesCorrectOfflineDiskStores() { Set<PersistentID> ids = generateTestIDs(2); DiskBackupStatusImpl status = new DiskBackupStatusImpl(); status.generateOfflineDiskStores(ids); String[] storedIds = status.getOfflineDiskStores(); assertThat(storedIds.length).isEqualTo(2); assertThat(storedIds).contains("DirectoryForId0", "DirectoryForId1"); }
@Test public void generatesCorrectBackupUpDiskStores() { Map<DistributedMember, Set<PersistentID>> backedUpDiskStores = new HashMap<>(); DistributedMember member1 = generateTestMember("member1"); Set<PersistentID> idSet1 = generateTestIDs(1); backedUpDiskStores.put(member1, idSet1); DistributedMember member2 = generateTestMember("member2"); Set<PersistentID> idSet2 = generateTestIDs(2); backedUpDiskStores.put(member2, idSet2); DiskBackupStatusImpl status = new DiskBackupStatusImpl(); status.generateBackedUpDiskStores(backedUpDiskStores); Map<String, String[]> storedDiskStores = status.getBackedUpDiskStores(); assertThat(storedDiskStores).containsOnlyKeys("member1", "member2"); assertThat(storedDiskStores.get("member1").length).isEqualTo(1); assertThat(storedDiskStores.get("member2").length).isEqualTo(2); assertThat(storedDiskStores.get("member2")).contains("DirectoryForId0", "DirectoryForId1"); }
@Test public void displayValuesReturnsDisplayValueForEveryBannerHeader() { for (Banner.BannerHeader bannerHeader : Banner.BannerHeader.values()) { assertThat(Banner.BannerHeader.displayValues()).contains(bannerHeader.displayValue()); } }
@Test public void supported_schemes() { assertThat(new DefaultHttpDownloader(new MapSettings().asConfig()).getSupportedSchemes()).contains("http"); }
@Test public void cacheListenerClassAndJsonWithCommaAndSpace() { String json1 = "{'k1' : 'v1', 'k2' : 'v2'}"; String json2 = "{'k2' : 'v2'}"; GfshParseResult result = parser.parse( "create region --name=region --cache-listener=\"my.abc" + json1 + ",my.def" + json2 + "\""); ClassName[] listeners = (ClassName[]) result.getParamValue("cache-listener"); assertThat(listeners).hasSize(2).contains(new ClassName("my.abc", json1), new ClassName("my.def", json2)); }
@Test public void cacheListenerClassOnly() { GfshParseResult result = parser.parse("create region --name=region --cache-listener=my.abc,my.def"); ClassName[] listeners = (ClassName[]) result.getParamValue("cache-listener"); assertThat(listeners).hasSize(2).contains(new ClassName("my.abc"), new ClassName("my.def")); }
@Test public void cacheListenerClassAndProps() { String json1 = "{'k1':'v1'}"; String json2 = "{'k2':'v2'}"; GfshParseResult result = parser .parse("create region --name=region --cache-listener=my.abc" + json1 + ",my.def" + json2); ClassName[] listeners = (ClassName[]) result.getParamValue("cache-listener"); assertThat(listeners).hasSize(2).contains(new ClassName("my.abc", json1), new ClassName("my.def", json2)); }
@Test public void cacheListenerClassAndJsonWithComma() { String json1 = "{'k1':'v1','k2':'v2'}"; String json2 = "{'k2':'v2'}"; GfshParseResult result = parser .parse("create region --name=region --cache-listener=my.abc" + json1 + ",my.def" + json2); ClassName[] listeners = (ClassName[]) result.getParamValue("cache-listener"); assertThat(listeners).hasSize(2).contains(new ClassName("my.abc", json1), new ClassName("my.def", json2)); }
@Test public void shouldBeAbleToCatchDiscardedElementInCaseOfConditional() { TestPublisher<Integer> publisher = TestPublisher.createCold(); Integer[] discarded = new Integer[1]; Flux<String> switchTransformed = publisher.flux() .switchOnFirst((first, innerFlux) -> innerFlux.map(String::valueOf)) .filter(t -> true) .doOnDiscard(Integer.class, e -> discarded[0] = e); publisher.next(1); StepVerifier.create(switchTransformed, 0) .thenCancel() .verify(Duration.ofSeconds(10)); publisher.assertCancelled(); publisher.assertWasRequested(); Assertions.assertThat(discarded).contains(1); }
public void test_EMPTY_DOUBLE_OBJECT_ARRAY() { assertThat(DoubleArrayMath.EMPTY_DOUBLE_OBJECT_ARRAY).contains(); }
/** * test. * */ @Test public void test() { assertThat(ESender.values()).hasSize(2).contains(ESender.CLIENT, ESender.SERVER); assertThat(ESender.valueOf("SERVER")).isEqualTo(ESender.SERVER); assertThat(ESender.valueOf("CLIENT")).isEqualTo(ESender.CLIENT); }
@Test public void shouldBeAbleToConfigureInprocessTelemetryChannel() throws IllegalConfigurationException { EnvironmentTestUtils.addEnvironment(context, "azure.application-insights.instrumentation-key: 00000000-0000-0000-0000-000000000000", "azure.application-insights.channel.in-process.developer-mode=false", "azure.application-insights.channel.in-process.flush-interval-in-seconds=123", "azure.application-insights.channel.in-process.max-telemetry-buffer-capacity=10"); context.register(PropertyPlaceholderAutoConfiguration.class, ApplicationInsightsTelemetryAutoConfiguration.class); context.refresh(); TelemetryConfiguration telemetryConfiguration = context.getBean(TelemetryConfiguration.class); TelemetryChannel channel = telemetryConfiguration.getChannel(); assertThat(channel).isInstanceOf(InProcessTelemetryChannel.class); assertThat(channel.isDeveloperMode()).isFalse(); assertThat(channel).extracting("telemetryBuffer").extracting("transmitBufferTimeoutInSeconds").contains(123); assertThat(channel).extracting("telemetryBuffer").extracting("maxTelemetriesInBatch").contains(10); }
@Test @DisplayName("start a container with one port") public void shouldStartContainerWithOnePort() { String containerId = defaultDockerClient.startContainer(WANTED_IMAGE, emptyMap(), new PortBinding(8081, 8080)); InspectContainerResponse startedContainer = dockerClient.inspectContainerCmd(containerId).exec(); Ports ports = startedContainer.getHostConfig().getPortBindings(); assertThat(ports).isNotNull(); Map<ExposedPort, Ports.Binding[]> portBindings = ports.getBindings(); assertThat(portBindings).hasSize(1) .containsKeys(new ExposedPort(8080)); assertThat(portBindings.get(new ExposedPort(8080))).hasSize(1) .extracting(Ports.Binding::getHostPortSpec) .contains("8081"); }
@Test public void shouldReadValue() { VaultProperties vaultProperties = Settings.createVaultProperties(); VaultPropertySource propertySource = new VaultPropertySource( new VaultConfigTemplate(prepare().getVaultOperations(), vaultProperties), false, GenericSecretBackendMetadata.create("secret", "myapp")); propertySource.init(); assertThat(propertySource.getPropertyNames()).contains("key"); assertThat(propertySource.getProperty("key")).isEqualTo("value"); } }