method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
ResponseAssertionsFromMatchingServiceValidator { public void validate(ValidatedResponse validatedResponse, ValidatedAssertions validatedAssertions) { if (!validatedResponse.isSuccess()) return; for (Assertion assertion : validatedAssertions.getAssertions()) { assertionValidator.validate(assertion, validatedResponse.getInResponseTo(), hubEntityId); if (assertion.getAuthnStatements().isEmpty()) { throw new SamlValidationException(missingAuthnStatement()); } if (assertion.getAuthnStatements().get(0).getAuthnContext() == null) { throw new SamlValidationException(authnContextMissingError()); } } } ResponseAssertionsFromMatchingServiceValidator(AssertionValidator assertionValidator, String hubEntityId); void validate(ValidatedResponse validatedResponse, ValidatedAssertions validatedAssertions); }### Answer:
@Test public void validate_shouldNotThrowExceptionIfResponseIsANoMatch() throws Exception { String requestId = "some-request-id"; final Response response = aResponse() .withStatus(aStatus().withStatusCode(aStatusCode().withValue(StatusCode.RESPONDER).build()).build()) .withInResponseTo(requestId) .build(); validator.validate(new ValidatedResponse(response), new ValidatedAssertions(singletonList(anAssertion().buildUnencrypted()))); }
|
### Question:
HealthCheckResponseFromMatchingServiceValidator { public void validate(Response response) { IssuerValidator.validate(response); RequestIdValidator.validate(response); validateResponse(response); } void validate(Response response); }### Answer:
@Test public void validateResponse_shouldDoNothingIfStatusIsRequesterErrorAndHasNoSubStatus() throws Exception { Response response = aResponse().withNoDefaultAssertion().withStatus( aStatus().withStatusCode( aStatusCode().withValue(StatusCode.REQUESTER).withSubStatusCode(null ).build() ).build() ).build(); validator.validate(response); }
|
### Question:
AttributeQueryAttributeFactory { public Attribute createAttribute(final UserAccountCreationAttribute userAccountCreationAttribute) { final Attribute attribute = openSamlXmlObjectFactory.createAttribute(); attribute.setName(userAccountCreationAttribute.getAttributeName()); attribute.setNameFormat(Attribute.UNSPECIFIED); return attribute; } @Inject AttributeQueryAttributeFactory(OpenSamlXmlObjectFactory openSamlXmlObjectFactory); Attribute createAttribute(final UserAccountCreationAttribute userAccountCreationAttribute); }### Answer:
@Test public void createAttribute_shouldPopulateAttributeNameFromUserAccountCreationAttributeValue(){ UserAccountCreationAttribute userAccountCreationAttribute = UserAccountCreationAttribute.CURRENT_ADDRESS; Attribute attribute = attributeQueryAttributeFactory.createAttribute(userAccountCreationAttribute); assertThat(attribute.getName()).isEqualTo("currentaddress"); }
@Test public void createAttribute_shouldPopulateAttributeNameFormatWithUnspecifiedFormat(){ UserAccountCreationAttribute userAccountCreationAttribute = UserAccountCreationAttribute.CURRENT_ADDRESS; Attribute attribute = attributeQueryAttributeFactory.createAttribute(userAccountCreationAttribute); assertThat(attribute.getNameFormat()).isEqualTo("urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified"); }
@Test public void createAttribute_shouldNotSetFriendlyName(){ UserAccountCreationAttribute userAccountCreationAttribute = UserAccountCreationAttribute.CURRENT_ADDRESS; Attribute attribute = attributeQueryAttributeFactory.createAttribute(userAccountCreationAttribute); assertThat(attribute.getFriendlyName()).isNull(); }
|
### Question:
SamlEntityDescriptorValidator { public void validate(EntityDescriptor descriptor) { if (Strings.isNullOrEmpty(descriptor.getEntityID())) { SamlValidationSpecificationFailure failure = SamlTransformationErrorFactory.missingOrEmptyEntityID(); throw new SamlTransformationErrorException(failure.getErrorMessage(), failure.getLogLevel()); } if (descriptor.getCacheDuration() == null && descriptor.getValidUntil() == null) { SamlValidationSpecificationFailure failure = SamlTransformationErrorFactory.missingCacheDurationAndValidUntil(); throw new SamlTransformationErrorException(failure.getErrorMessage(), failure.getLogLevel()); } validateRoleDescriptor(descriptor); } void validate(EntityDescriptor descriptor); }### Answer:
@Test public void decorate_shouldDoNothingWhenEntityDescriptorIsValid() throws Exception { EntityDescriptor entityDescriptor = anEntityDescriptor().withIdpSsoDescriptor(IdpSsoDescriptorBuilder.anIdpSsoDescriptor().withSingleSignOnService(anEndpoint().buildSingleSignOnService()).build()).build(); validator.validate(entityDescriptor); }
@Test public void decorate_shouldNotThrowExceptionWhenEntityDescriptorIsNotSignedButNotRequired() throws Exception { EntityDescriptor entityDescriptor = anEntityDescriptor().withoutSigning().build(); validator.validate(entityDescriptor); }
|
### Question:
IdpMetadataPublicKeyStore implements SigningKeyStore { @Override public List<PublicKey> getVerifyingKeysForEntity(String entityId) { Optional<EntityDescriptor> entityDescriptor = getEntityDescriptor(entityId); if (entityDescriptor.isPresent()) { final List<PublicKey> publicKeys = getPublicKeys(entityDescriptor.get(), UsageType.SIGNING); if (!publicKeys.isEmpty()) { return publicKeys; } } throw new NoKeyConfiguredForEntityException(entityId); } @Inject IdpMetadataPublicKeyStore(MetadataResolver metadataResolver); @Override List<PublicKey> getVerifyingKeysForEntity(String entityId); }### Answer:
@Test public void shouldReturnTheSigningKeysForAnEntity() throws Exception { IdpMetadataPublicKeyStore idpMetadataPublicKeyStore = new IdpMetadataPublicKeyStore(metadataResolver); PublicKey expectedPublicKey = getX509Key(TestCertificateStrings.STUB_IDP_PUBLIC_PRIMARY_CERT); assertThat(idpMetadataPublicKeyStore.getVerifyingKeysForEntity(TestEntityIds.STUB_IDP_ONE)).containsExactly(expectedPublicKey); }
@Test(expected = NoKeyConfiguredForEntityException.class) public void shouldRaiseAnExceptionWhenThereIsNoEntityDescriptor() throws Exception { IdpMetadataPublicKeyStore idpMetadataPublicKeyStore = new IdpMetadataPublicKeyStore(metadataResolver); idpMetadataPublicKeyStore.getVerifyingKeysForEntity("my-invented-entity-id"); }
@Test(expected = NoKeyConfiguredForEntityException.class) public void shouldRaiseAnExceptionWhenAttemptingToRetrieveAnSPSSOFromMetadata() throws Exception { IdpMetadataPublicKeyStore idpMetadataPublicKeyStore = new IdpMetadataPublicKeyStore(metadataResolver); idpMetadataPublicKeyStore.getVerifyingKeysForEntity("https: }
|
### Question:
DestinationValidator { public void validate(String destination) { if(destination == null) throw new SamlValidationException(destinationMissing(expectedUri)); URI destinationURI = URI.create(destination); URI destinationURIWithoutPort; destinationURIWithoutPort = uriWithoutPort(destinationURI, destinationURI.getPath()); if (!expectedUri.equals(destinationURIWithoutPort)) throw new SamlValidationException(destinationEmpty(expectedUri, destination)); } DestinationValidator(URI expectedDestinationHost, String expectedEndpoint); void validate(String destination); }### Answer:
@Test public void validate_shouldNotThrowExceptionIfUriMatches() throws Exception { validator.validate("http: }
@Test public void validate_shouldBeValidIfPortSpecifiedOnDestinationButNotForSamlProxy() throws Exception { validator.validate("http: }
|
### Question:
RelayStateValidator { public void validate(String relayState) { if (relayState == null){ return; } if (relayState.length() > MAXIMUM_NUMBER_OF_CHARACTERS) { SamlValidationSpecificationFailure failure = SamlTransformationErrorFactory.invalidRelayState(relayState); throw new SamlTransformationErrorException(failure.getErrorMessage(), failure.getLogLevel()); } for (String invalidCharacter : INVALID_CHARACTERS) { if (relayState.contains(invalidCharacter)) { SamlValidationSpecificationFailure failure = SamlTransformationErrorFactory.relayStateContainsInvalidCharacter(invalidCharacter, relayState); throw new SamlTransformationErrorException(failure.getErrorMessage(), failure.getLogLevel()); } } } void validate(String relayState); }### Answer:
@Test public void validate_shouldCheckRelayStateLengthIsLessThanEightyOneCharactersOrRaiseException() { final String aStringMoreThanEightyCharacters = "a".repeat(82); SamlTransformationErrorManagerTestHelper.validateFail( () -> relayStateValidator.validate(aStringMoreThanEightyCharacters), SamlTransformationErrorFactory.invalidRelayState(aStringMoreThanEightyCharacters) ); }
@Test public void validate_shouldCheckRelayStateForValidStringAndNotThrowAnException() { String aStringLessThanEightyCharacters = "short string"; relayStateValidator.validate(aStringLessThanEightyCharacters); }
@Test public void validate_shouldCheckForInvalidCharacters() { final String aString = "aStringWith"; for (final String i : asList(">", "<", "'", "\"", "%", "&", ";")) { SamlTransformationErrorManagerTestHelper.validateFail( () -> relayStateValidator.validate(aString + i), SamlTransformationErrorFactory.relayStateContainsInvalidCharacter(i, aString + i) ); } }
|
### Question:
ConfigValidationException extends RuntimeException { public static ConfigValidationException createFileReadError(String filePath) { return new ConfigValidationException(format("Error reading config service data from file ''{0}''.", filePath)); } private ConfigValidationException(String message); static ConfigValidationException createFileReadError(String filePath); static ConfigValidationException createDuplicateEntityIdException(String entityId); static ConfigValidationException createMissingMatchingEntityIdException(String transactionEntityId); static ConfigValidationException createAbsentMatchingServiceConfigException(String matchingServiceEntityId, String transactionEntityId); static ConfigValidationException createAbsentOnboardingTransactionConfigException(String transactionEntityId, String idpEntityId); static ConfigValidationException createInvalidCertificatesException(List<InvalidCertificateDto> invalidCertificates); static ConfigValidationException createIDPLevelsOfAssuranceUnsupportedException(Collection<IdentityProviderConfig> badIDPConfigs); static ConfigValidationException createTransactionsRequireUnsupportedLevelOfAssurance(Collection<TransactionConfig> badTransactionConfigs); static ConfigValidationException createIncompatiblePairsOfTransactionsAndIDPs(Map<TransactionConfig, List<IdentityProviderConfig>> incompatibleIdps); }### Answer:
@Test public void createFileReadError() throws Exception { ConfigValidationException exception = ConfigValidationException.createFileReadError("/tmp/foo"); assertThat(exception.getMessage()).isEqualTo("Error reading config service data from file '/tmp/foo'."); }
|
### Question:
ConfigValidationException extends RuntimeException { public static ConfigValidationException createDuplicateEntityIdException(String entityId) { return new ConfigValidationException(format("Duplicate entity id found: {0}", entityId)); } private ConfigValidationException(String message); static ConfigValidationException createFileReadError(String filePath); static ConfigValidationException createDuplicateEntityIdException(String entityId); static ConfigValidationException createMissingMatchingEntityIdException(String transactionEntityId); static ConfigValidationException createAbsentMatchingServiceConfigException(String matchingServiceEntityId, String transactionEntityId); static ConfigValidationException createAbsentOnboardingTransactionConfigException(String transactionEntityId, String idpEntityId); static ConfigValidationException createInvalidCertificatesException(List<InvalidCertificateDto> invalidCertificates); static ConfigValidationException createIDPLevelsOfAssuranceUnsupportedException(Collection<IdentityProviderConfig> badIDPConfigs); static ConfigValidationException createTransactionsRequireUnsupportedLevelOfAssurance(Collection<TransactionConfig> badTransactionConfigs); static ConfigValidationException createIncompatiblePairsOfTransactionsAndIDPs(Map<TransactionConfig, List<IdentityProviderConfig>> incompatibleIdps); }### Answer:
@Test public void createDuplicateEntityIdException() throws Exception { ConfigValidationException exception = ConfigValidationException.createDuplicateEntityIdException("entity-id"); assertThat(exception.getMessage()).isEqualTo("Duplicate entity id found: entity-id"); }
|
### Question:
ConfigValidationException extends RuntimeException { public static ConfigValidationException createAbsentMatchingServiceConfigException(String matchingServiceEntityId, String transactionEntityId) { return new ConfigValidationException(format("Matching service configuration for {0} not found, used by transaction {1}", matchingServiceEntityId, transactionEntityId)); } private ConfigValidationException(String message); static ConfigValidationException createFileReadError(String filePath); static ConfigValidationException createDuplicateEntityIdException(String entityId); static ConfigValidationException createMissingMatchingEntityIdException(String transactionEntityId); static ConfigValidationException createAbsentMatchingServiceConfigException(String matchingServiceEntityId, String transactionEntityId); static ConfigValidationException createAbsentOnboardingTransactionConfigException(String transactionEntityId, String idpEntityId); static ConfigValidationException createInvalidCertificatesException(List<InvalidCertificateDto> invalidCertificates); static ConfigValidationException createIDPLevelsOfAssuranceUnsupportedException(Collection<IdentityProviderConfig> badIDPConfigs); static ConfigValidationException createTransactionsRequireUnsupportedLevelOfAssurance(Collection<TransactionConfig> badTransactionConfigs); static ConfigValidationException createIncompatiblePairsOfTransactionsAndIDPs(Map<TransactionConfig, List<IdentityProviderConfig>> incompatibleIdps); }### Answer:
@Test public void createAbsentMatchingServiceConfigException() throws Exception { ConfigValidationException exception = ConfigValidationException.createAbsentMatchingServiceConfigException("msa-entity-id", "transaction-entity-id"); assertThat(exception.getMessage()).isEqualTo("Matching service configuration for msa-entity-id not found, used by transaction transaction-entity-id"); }
|
### Question:
ConfigValidationException extends RuntimeException { public static ConfigValidationException createAbsentOnboardingTransactionConfigException(String transactionEntityId, String idpEntityId) { return new ConfigValidationException(format("IDP {0} has onboardingTransactionEntityId {1}. No transaction with entityId {1} exists.", idpEntityId, transactionEntityId)); } private ConfigValidationException(String message); static ConfigValidationException createFileReadError(String filePath); static ConfigValidationException createDuplicateEntityIdException(String entityId); static ConfigValidationException createMissingMatchingEntityIdException(String transactionEntityId); static ConfigValidationException createAbsentMatchingServiceConfigException(String matchingServiceEntityId, String transactionEntityId); static ConfigValidationException createAbsentOnboardingTransactionConfigException(String transactionEntityId, String idpEntityId); static ConfigValidationException createInvalidCertificatesException(List<InvalidCertificateDto> invalidCertificates); static ConfigValidationException createIDPLevelsOfAssuranceUnsupportedException(Collection<IdentityProviderConfig> badIDPConfigs); static ConfigValidationException createTransactionsRequireUnsupportedLevelOfAssurance(Collection<TransactionConfig> badTransactionConfigs); static ConfigValidationException createIncompatiblePairsOfTransactionsAndIDPs(Map<TransactionConfig, List<IdentityProviderConfig>> incompatibleIdps); }### Answer:
@Test public void createAbsentOnboardingTransactionConfigException() throws Exception { ConfigValidationException exception = ConfigValidationException.createAbsentOnboardingTransactionConfigException("transaction-entity-id", "idp-entity-id"); assertThat(exception.getMessage()).isEqualTo("IDP idp-entity-id has onboardingTransactionEntityId transaction-entity-id. No transaction with entityId transaction-entity-id exists."); }
|
### Question:
ConfigValidationException extends RuntimeException { public static ConfigValidationException createInvalidCertificatesException(List<InvalidCertificateDto> invalidCertificates) { return new ConfigValidationException(invalidCertificates.stream().map(certificate -> MessageFormat.format( "Invalid certificate found.\nEntity Id: {0}\nCertificate Type: {1}\nFederation Type: {2}\nReason: {3}\nDescription: {4}", certificate.getEntityId(), certificate.getCertificateType(), certificate.getFederationType(), certificate.getReason(), certificate.getDescription())).collect(Collectors.joining("\n"))); } private ConfigValidationException(String message); static ConfigValidationException createFileReadError(String filePath); static ConfigValidationException createDuplicateEntityIdException(String entityId); static ConfigValidationException createMissingMatchingEntityIdException(String transactionEntityId); static ConfigValidationException createAbsentMatchingServiceConfigException(String matchingServiceEntityId, String transactionEntityId); static ConfigValidationException createAbsentOnboardingTransactionConfigException(String transactionEntityId, String idpEntityId); static ConfigValidationException createInvalidCertificatesException(List<InvalidCertificateDto> invalidCertificates); static ConfigValidationException createIDPLevelsOfAssuranceUnsupportedException(Collection<IdentityProviderConfig> badIDPConfigs); static ConfigValidationException createTransactionsRequireUnsupportedLevelOfAssurance(Collection<TransactionConfig> badTransactionConfigs); static ConfigValidationException createIncompatiblePairsOfTransactionsAndIDPs(Map<TransactionConfig, List<IdentityProviderConfig>> incompatibleIdps); }### Answer:
@Test public void createInvalidCertificatesException() throws Exception { InvalidCertificateDto invalidCertificateDto = new InvalidCertificateDto("entity-id", CertPathValidatorException.BasicReason.EXPIRED, CertificateUse.ENCRYPTION, FederationEntityType.IDP, "description"); ConfigValidationException exception = ConfigValidationException.createInvalidCertificatesException(singletonList(invalidCertificateDto)); assertThat(exception.getMessage()).isEqualTo("Invalid certificate found.\n" + "Entity Id: entity-id\n" + "Certificate Type: ENCRYPTION\n" + "Federation Type: IDP\n" + "Reason: EXPIRED\n" + "Description: description"); }
|
### Question:
ConfigValidationException extends RuntimeException { public static ConfigValidationException createIDPLevelsOfAssuranceUnsupportedException(Collection<IdentityProviderConfig> badIDPConfigs) { return new ConfigValidationException(badIDPConfigs.stream().map(idpConfig -> MessageFormat.format( "Unsupported level of assurance in IDP config.\nEntity Id: {0}\nLevels: {1}\n", idpConfig.getEntityId(), idpConfig.getSupportedLevelsOfAssurance())) .collect(Collectors.joining("\n"))); } private ConfigValidationException(String message); static ConfigValidationException createFileReadError(String filePath); static ConfigValidationException createDuplicateEntityIdException(String entityId); static ConfigValidationException createMissingMatchingEntityIdException(String transactionEntityId); static ConfigValidationException createAbsentMatchingServiceConfigException(String matchingServiceEntityId, String transactionEntityId); static ConfigValidationException createAbsentOnboardingTransactionConfigException(String transactionEntityId, String idpEntityId); static ConfigValidationException createInvalidCertificatesException(List<InvalidCertificateDto> invalidCertificates); static ConfigValidationException createIDPLevelsOfAssuranceUnsupportedException(Collection<IdentityProviderConfig> badIDPConfigs); static ConfigValidationException createTransactionsRequireUnsupportedLevelOfAssurance(Collection<TransactionConfig> badTransactionConfigs); static ConfigValidationException createIncompatiblePairsOfTransactionsAndIDPs(Map<TransactionConfig, List<IdentityProviderConfig>> incompatibleIdps); }### Answer:
@Test public void createIDPLevelsOfAssuranceUnsupportedException() throws Exception { ConfigValidationException exception = ConfigValidationException.createIDPLevelsOfAssuranceUnsupportedException(singletonList(anIdentityProviderConfigData().build())); assertThat(exception.getMessage()).isEqualTo("Unsupported level of assurance in IDP config.\nEntity Id: default-idp-entity-id\nLevels: [LEVEL_2]\n"); }
|
### Question:
ConfigValidationException extends RuntimeException { public static ConfigValidationException createTransactionsRequireUnsupportedLevelOfAssurance(Collection<TransactionConfig> badTransactionConfigs) { return new ConfigValidationException(badTransactionConfigs.stream() .map(entityData -> MessageFormat.format( "Unsupported level of assurance in transaction config.\nEntity Id: {0}\nLevels of assurance: {1}\n", entityData.getEntityId(), entityData.getLevelsOfAssurance())) .collect(Collectors.joining("\n"))); } private ConfigValidationException(String message); static ConfigValidationException createFileReadError(String filePath); static ConfigValidationException createDuplicateEntityIdException(String entityId); static ConfigValidationException createMissingMatchingEntityIdException(String transactionEntityId); static ConfigValidationException createAbsentMatchingServiceConfigException(String matchingServiceEntityId, String transactionEntityId); static ConfigValidationException createAbsentOnboardingTransactionConfigException(String transactionEntityId, String idpEntityId); static ConfigValidationException createInvalidCertificatesException(List<InvalidCertificateDto> invalidCertificates); static ConfigValidationException createIDPLevelsOfAssuranceUnsupportedException(Collection<IdentityProviderConfig> badIDPConfigs); static ConfigValidationException createTransactionsRequireUnsupportedLevelOfAssurance(Collection<TransactionConfig> badTransactionConfigs); static ConfigValidationException createIncompatiblePairsOfTransactionsAndIDPs(Map<TransactionConfig, List<IdentityProviderConfig>> incompatibleIdps); }### Answer:
@Test public void createTransactionsRequireUnsupportedLevelOfAssurance() throws Exception { ConfigValidationException exception = ConfigValidationException.createTransactionsRequireUnsupportedLevelOfAssurance(singletonList(aTransactionConfigData().build())); assertThat(exception.getMessage()).isEqualTo("Unsupported level of assurance in transaction config.\n" + "Entity Id: default-transaction-entity-id\n" + "Levels of assurance: [LEVEL_1, LEVEL_2]\n"); }
|
### Question:
ConfigValidationException extends RuntimeException { public static ConfigValidationException createIncompatiblePairsOfTransactionsAndIDPs(Map<TransactionConfig, List<IdentityProviderConfig>> incompatibleIdps) { return new ConfigValidationException(incompatibleIdps.keySet().stream().map(transactionEntity -> MessageFormat.format( "Transaction unsupported by IDP(s).\nTransaction: {0}\nIDP(s): {1}\n", transactionEntity.getEntityId(), incompatibleIdps.get(transactionEntity).stream().map(IdentityProviderConfig::getEntityId).collect(Collectors.toList())) ).collect(Collectors.joining("\n"))); } private ConfigValidationException(String message); static ConfigValidationException createFileReadError(String filePath); static ConfigValidationException createDuplicateEntityIdException(String entityId); static ConfigValidationException createMissingMatchingEntityIdException(String transactionEntityId); static ConfigValidationException createAbsentMatchingServiceConfigException(String matchingServiceEntityId, String transactionEntityId); static ConfigValidationException createAbsentOnboardingTransactionConfigException(String transactionEntityId, String idpEntityId); static ConfigValidationException createInvalidCertificatesException(List<InvalidCertificateDto> invalidCertificates); static ConfigValidationException createIDPLevelsOfAssuranceUnsupportedException(Collection<IdentityProviderConfig> badIDPConfigs); static ConfigValidationException createTransactionsRequireUnsupportedLevelOfAssurance(Collection<TransactionConfig> badTransactionConfigs); static ConfigValidationException createIncompatiblePairsOfTransactionsAndIDPs(Map<TransactionConfig, List<IdentityProviderConfig>> incompatibleIdps); }### Answer:
@Test public void createIncompatiblePairsOfTransactionsAndIDPs() throws Exception { Map<TransactionConfig, List<IdentityProviderConfig>> incompatiblePairs = Map.of(aTransactionConfigData().build(), singletonList(anIdentityProviderConfigData().build())); ConfigValidationException exception = ConfigValidationException.createIncompatiblePairsOfTransactionsAndIDPs(incompatiblePairs); assertThat(exception.getMessage()).isEqualTo("Transaction unsupported by IDP(s).\n" + "Transaction: default-transaction-entity-id\n" + "IDP(s): [default-idp-entity-id]\n"); }
|
### Question:
IdentityProviderConfigOnboardingTransactionValidator { public void validate(IdentityProviderConfig identityProviderConfig) { for (String onboardingTransactionEntityId : identityProviderConfig.getOnboardingTransactionEntityIds()) { transactionConfigRepository.getData(onboardingTransactionEntityId) .orElseThrow(() -> createAbsentOnboardingTransactionConfigException( onboardingTransactionEntityId, identityProviderConfig.getEntityId())); } } IdentityProviderConfigOnboardingTransactionValidator(
final LocalConfigRepository<TransactionConfig> transactionConfigRepository); void validate(IdentityProviderConfig identityProviderConfig); }### Answer:
@Test public void validate_shouldNotThrowExceptionWhenOnboardingTransactionEntityIdExists() { String transactionEntityID = "transactionEntityID"; IdentityProviderConfig identityProviderConfig = anIdentityProviderConfigData().withOnboarding(List.of(transactionEntityID)).build(); TransactionConfig transactionConfigEntity = aTransactionConfigData().build(); when(transactionConfigRepository.getData(transactionEntityID)).thenReturn(Optional.ofNullable(transactionConfigEntity)); identityProviderConfigOnboardingTransactionValidator.validate(identityProviderConfig); }
@Test public void validate_shouldNotThrowExceptionWhenOnboardingTransactionEntityIsNotSpecified() { IdentityProviderConfig identityProviderConfig = anIdentityProviderConfigData().withoutOnboarding().build(); identityProviderConfigOnboardingTransactionValidator.validate(identityProviderConfig); }
@Test public void validate_shouldThrowExceptionWhenOnboardingTransactionDoesNotExist() { String transactionEntityID = "transactionEntityID"; String idpEntityId = "idpEntityId"; IdentityProviderConfig identityProviderConfig = anIdentityProviderConfigData() .withEntityId(idpEntityId) .withOnboarding(List.of(transactionEntityID)) .build(); when(transactionConfigRepository.getData(transactionEntityID)) .thenReturn(Optional.empty()); try { identityProviderConfigOnboardingTransactionValidator.validate(identityProviderConfig); fail("fail"); } catch (ConfigValidationException e) { final ConfigValidationException expectedException = createAbsentOnboardingTransactionConfigException(transactionEntityID, idpEntityId); assertThat(expectedException.getMessage()).isEqualTo(e.getMessage()); } }
|
### Question:
DuplicateEntityIdConfigValidator { public void validate(Collection<? extends EntityIdentifiable> configDataCollection) { Set<String> knownEntityIds = new HashSet<>(configDataCollection.size()); for (EntityIdentifiable datum : configDataCollection) { String entityId = datum.getEntityId(); if (knownEntityIds.contains(entityId)) { throw ConfigValidationException.createDuplicateEntityIdException(entityId); } knownEntityIds.add(entityId); } } void validate(Collection<? extends EntityIdentifiable> configDataCollection); }### Answer:
@Test public void validate_shouldThrowExceptionIfTwoEntitiesHaveSameEntityId() throws Exception { String entityId = "transaction-entity-id"; Collection<EntityIdentifiable> configs = new ArrayList<>(); configs.add(aTransactionConfigData().withEntityId(entityId).build()); configs.add(anIdentityProviderConfigData().withEntityId(entityId).build()); try { this.validator.validate(configs); fail("fail"); } catch (ConfigValidationException e) { assertThat(e.getMessage()).isEqualTo(ConfigValidationException.createDuplicateEntityIdException(entityId).getMessage()); } }
|
### Question:
CertificateService { public Set<Certificate> getAllCertificates() { return Stream.concat(connectedServiceConfigRepository.stream(), matchingServiceConfigRepository.stream()) .flatMap(this::getAllCertificates) .collect(Collectors.toSet()); } @Inject CertificateService(
ManagedEntityConfigRepository<TransactionConfig> connectedServiceConfigRepository,
ManagedEntityConfigRepository<MatchingServiceConfig> matchingServiceConfigRepository,
CertificateValidityChecker certificateValidityChecker); Set<Certificate> getAllCertificates(); Certificate encryptionCertificateFor(String entityId); List<Certificate> signatureVerificationCertificatesFor(String entityId); }### Answer:
@Test public void getAllCertificatesReturnsAllTransactionAndMatchingServiceCertificate() { final TransactionConfig transactionOneConfig = aTransactionConfigData().withEntityId(RP_ONE_ENTITY_ID) .withEnabled(true) .build(); final TransactionConfig transactionTwoConfig = aTransactionConfigData().withEntityId(RP_TWO_ENTITY_ID) .withEnabled(true) .build(); final MatchingServiceConfig matchingServiceOneConfig = aMatchingServiceConfig().withEntityId(RP_MSA_ONE_ENTITY_ID) .build(); Set<Certificate> expectedCertificateSet = new HashSet<>(); expectedCertificateSet.addAll(transactionOneConfig.getAllCertificates()); expectedCertificateSet.addAll(transactionTwoConfig.getAllCertificates()); expectedCertificateSet.addAll(matchingServiceOneConfig.getAllCertificates()); List<TransactionConfig> transactionConfigs = new ArrayList<>(); transactionConfigs.add(transactionOneConfig); transactionConfigs.add(transactionTwoConfig); List<MatchingServiceConfig> matchingServiceConfigs = new ArrayList<>(); matchingServiceConfigs.add(matchingServiceOneConfig); when(connectedServiceConfigRepository.stream()).thenReturn(transactionConfigs.stream()); when(matchingServiceConfigRepository.stream()).thenReturn(matchingServiceConfigs.stream()); final Set<Certificate> actualCertificateSet = certificateService.getAllCertificates(); assertThat(actualCertificateSet.size()).isEqualTo(6); assertThat(actualCertificateSet).containsAll(expectedCertificateSet); }
|
### Question:
ExtendedStackTraceClassContext extends ExtendedStackTrace { @Override public synchronized ExtendedStackTraceElement[] get() { if (est == null) { final StackTraceElement[] st = t.getStackTrace(); if (st != null) { est = new ExtendedStackTraceElement[st.length - 1]; for (int i = 1, k = 2; i < st.length; i++, k++) { if (skipCTX(classContext[k])) { i--; } else { final StackTraceElement ste = st[i]; final Class<?> clazz; if (skipSTE(st[i])) { k--; clazz = null; } else { clazz = classContext[k]; } est[i - 1] = new BasicExtendedStackTraceElement(ste, clazz); } } } } return est; } ExtendedStackTraceClassContext(); @Override synchronized ExtendedStackTraceElement[] get(); }### Answer:
@Test public void testLambdaInCallStack() throws Exception { ((Runnable) (() -> { new ExtendedStackTraceClassContext().get(); })).run(); }
@Test public void testNoLambdaInCallStack() throws Exception { new ExtendedStackTraceClassContext().get(); }
|
### Question:
SingleConsumerNonblockingProducerDelayQueue extends SingleConsumerNonblockingProducerQueue<E> { @Override public E take() throws InterruptedException { E e = q.peek(); long delayNanos; if (e == null || getDelay(e) > 0) { sync.register(); try { e = q.peek(); delayNanos = getDelay(e); while (delayNanos > 0) { sync.awaitNanos(delayNanos); e = q.peek(); delayNanos = getDelay(e); } return q.poll(); } finally { sync.unregister(); } } else { e = q.poll(); assert e != null; return e; } } SingleConsumerNonblockingProducerDelayQueue(); @Override E poll(); @Override E take(); @Override E poll(long timeout, TimeUnit unit); }### Answer:
@Test public void testTake() throws Exception { q.offer(DelayedValue.instance(SEQUENCED, 2, 100)); q.offer(DelayedValue.instance(SEQUENCED, 1, 50)); q.offer(DelayedValue.instance(SEQUENCED, 3, 150)); DelayedValue dv; final long start = System.nanoTime(); dv = q.take(); assertThat(dv.getValue(), is(1)); dv = q.take(); assertThat(dv.getValue(), is(2)); dv = q.take(); assertThat(dv.getValue(), is(3)); final long elapsedMillis = TimeUnit.MILLISECONDS.convert(System.nanoTime() - start, TimeUnit.NANOSECONDS); assertTrue("elapsed: " + elapsedMillis, elapsedMillis > 140 && elapsedMillis < 300); }
|
### Question:
AsyncCompletionStage extends FiberAsync<V, ExecutionException> { public static <V> V get(CompletionStage<V> future) throws ExecutionException, InterruptedException, SuspendExecution { if (Fiber.isCurrentFiber()) return new AsyncCompletionStage<V>(future).run(); else return future.toCompletableFuture().get(); } private AsyncCompletionStage(CompletionStage<V> future); static V get(CompletionStage<V> future); static V get(CompletionStage<V> future, long timeout, TimeUnit unit); static V get(CompletionStage<V> future, Timeout timeout); }### Answer:
@Test public void simpleTest1() throws Exception { final CompletableFuture<String> fut = new CompletableFuture<String>(); final Fiber<String> fiber = new Fiber<>(scheduler, () -> { try { return AsyncCompletionStage.get(fut); } catch (ExecutionException e) { throw new RuntimeException(e); } }).start(); new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(200); fut.complete("hi!"); } catch (InterruptedException e) { } } }).start(); assertThat(fiber.get(), equalTo("hi!")); }
@Test public void testException() throws Exception { final CompletableFuture<String> fut = new CompletableFuture<String>(); final Fiber<String> fiber = new Fiber<>(scheduler, () -> { try { String res = AsyncCompletionStage.get(fut); fail(); return res; } catch (ExecutionException e) { throw Exceptions.rethrow(e.getCause()); } }).start(); new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(200); fut.completeExceptionally(new RuntimeException("haha!")); } catch (InterruptedException e) { } } }).start(); try { fiber.get(); fail(); } catch (ExecutionException e) { assertThat(e.getCause().getMessage(), equalTo("haha!")); } }
|
### Question:
SingleConsumerQueue extends AbstractCollection<E> implements Iterable<E>, Queue<E>, BasicSingleConsumerQueue<E> { @Override public boolean offer(E e) { return enq(e); } @Override abstract boolean enq(E element); @Override abstract E poll(); @Override abstract E peek(); @Override abstract QueueIterator<E> iterator(); @Override abstract int size(); abstract List<E> snapshot(); @Override abstract int capacity(); @Override boolean hasNext(); @Override abstract boolean isEmpty(); @Override boolean add(E e); @Override final boolean removeAll(Collection<?> c); @Override final boolean retainAll(Collection<?> c); @Override final void clear(); @Override boolean offer(E e); @Override E remove(); @Override E element(); @Override String toString(); }### Answer:
@Test public void testOffer() { queue.offer("one"); queue.offer("two"); queue.offer("three"); assertThat(queue.isEmpty(), is(false)); assertThat(queue.size(), is(3)); assertThat(list(queue), is(equalTo(list("one", "two", "three")))); }
|
### Question:
SingleConsumerQueue extends AbstractCollection<E> implements Iterable<E>, Queue<E>, BasicSingleConsumerQueue<E> { @Override public abstract E poll(); @Override abstract boolean enq(E element); @Override abstract E poll(); @Override abstract E peek(); @Override abstract QueueIterator<E> iterator(); @Override abstract int size(); abstract List<E> snapshot(); @Override abstract int capacity(); @Override boolean hasNext(); @Override abstract boolean isEmpty(); @Override boolean add(E e); @Override final boolean removeAll(Collection<?> c); @Override final boolean retainAll(Collection<?> c); @Override final void clear(); @Override boolean offer(E e); @Override E remove(); @Override E element(); @Override String toString(); }### Answer:
@Test public void testPoll() { int j = 1; int k = 1; for (int i = 0; i < 8; i++) { queue.offer("x" + (j++)); queue.offer("x" + (j++)); String s = queue.poll(); assertThat(s, equalTo("x" + (k++))); } assertThat(queue.size(), is(8)); assertThat(list(queue), is(equalTo(list("x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16")))); for (int i = 0; i < 8; i++) { String s = queue.poll(); assertThat(s, equalTo("x" + (k++))); } testEmptyQueue(); }
|
### Question:
Val implements Future<V> { public final void set(V value) { if (f != null) throw new IllegalStateException("Cannot set a value because a function has been set"); set0(value); } Val(final SuspendableCallable<V> f); Val(FiberScheduler scheduler, final SuspendableCallable<V> f); Val(); final void set(V value); final void setException(Throwable t); @Override boolean isDone(); @Override @Suspendable V get(); @Override @Suspendable V get(long timeout, TimeUnit unit); @Suspendable V get(Timeout timeout); @Override boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); }### Answer:
@Test(expected = IllegalStateException.class) public void whenValIsSetTwiceThenThrowException() throws Exception { final Val<String> val = new Val<>(); val.set("hello"); val.set("goodbye"); }
|
### Question:
ReflectionUtil { public static Type getGenericParameterType(Class<?> cls, Class<?> genericSuper, int paramIndex) { if (!genericSuper.isAssignableFrom(cls)) throw new IllegalArgumentException("Class " + cls.getName() + " does not implement or extend " + genericSuper.getName()); Type res = getGenericParameterType0(cls, genericSuper, paramIndex); return !(res instanceof TypeVariable) ? res : null; } private ReflectionUtil(); static T accessible(T obj); static Class<?>[] getTypes(Object... vals); static boolean isAssignable(Class<?>[] classArray, Class<?>[] toClassArray, final boolean autoboxing); static Constructor<T> getMatchingConstructor(final Class<T> cls, final Class<?>... parameterTypes); static boolean isAssignable(Class<?> cls, final Class<?> toClass, final boolean autoboxing); static Class<?> primitiveToWrapper(final Class<?> cls); static Class<?> wrapperToPrimitive(final Class<?> cls); static Type getGenericParameterType(Class<?> cls, Class<?> genericSuper, int paramIndex); static Class<?> getClass(Type type); static Class<?>[] getParameterTypes(Member m); }### Answer:
@Test public void testGetGenericParameter1() { Class<?> res = (Class<?>) ReflectionUtil.getGenericParameterType(D.class, A.class, 0); assertEquals(res, String.class); }
@Test public void testGetGenericParameter3() { Class<?> res = (Class<?>) ReflectionUtil.getGenericParameterType(E.class, A.class, 0); assertEquals(res, String.class); }
@Test public void testGetGenericParameterInterface1() { Class<?> res = (Class<?>) ReflectionUtil.getGenericParameterType(ID.class, IA.class, 0); assertEquals(res, String.class); }
@Test public void testGetGenericParameterInterface3() { Class<?> res = (Class<?>) ReflectionUtil.getGenericParameterType(IE.class, IA.class, 0); assertEquals(res, String.class); }
|
### Question:
TreePathConverter { public static TreePath deserialize(final JsonReader reader) throws IOException { try { return TreePath.create(reader.readString()); } catch(final IOException e) { throw new IOException("Can't parse JSON TreePath at position " + reader.positionInStream(), e); } } static void serializeNullable(final TreePath value, final JsonWriter sw); static void serialize(final TreePath value, final JsonWriter sw); static TreePath deserialize(final JsonReader reader); static ArrayList<TreePath> deserializeCollection(final JsonReader reader); static void deserializeCollection(final JsonReader reader, final Collection<TreePath> res); static ArrayList<TreePath> deserializeNullableCollection(final JsonReader reader); static void deserializeNullableCollection(final JsonReader reader, final Collection<TreePath> res); static final JsonReader.ReadObject<TreePath> Reader; static final JsonWriter.WriteObject<TreePath> Writer; }### Answer:
@Test public void testDeserializationErrors() throws IOException { final String malformedTreePathJson = "\"opr.s\u0161t.uvz\""; final JsonReader jr = new JsonReader(malformedTreePathJson.getBytes("UTF-8"), null); jr.getNextToken(); thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Invalid value for part: s\u0161t. Only [A-Za-z0-9] allowed for labels"); TreePathConverter.deserialize(jr); }
|
### Question:
MapServiceLocator implements ServiceLocator { @Override public <T> T resolve(final Class<T> clazz) { final Object component = resolve(clazz, true); return clazz.cast(component); } MapServiceLocator(); MapServiceLocator(final Map<Class<?>, Object> initialComponents); @Override T resolve(final Class<T> clazz); MapServiceLocator register(final Class<T> target, final Object service); }### Answer:
@Test public void withDefaultLoggerAndEC() throws Exception { final Map<Class<?>, Object> initialComponents = new HashMap<Class<?>, Object>(); final ExecutorService executorService = Executors.newSingleThreadExecutor(); initialComponents.put(ExecutorService.class, executorService); final Logger logger = LoggerFactory.getLogger("test-logger"); initialComponents.put(Logger.class, logger); final MapServiceLocator mapServiceLocator = new MapServiceLocator(initialComponents); assertSame("Executor matches", executorService, mapServiceLocator.resolve(ExecutorService.class)); assertSame("Logger matches", logger, mapServiceLocator.resolve(Logger.class)); }
|
### Question:
Bootstrap { public static ServiceLocator init( final Properties properties, final Map<Class<?>, Object> initialComponents) throws IOException { return init(properties, new MapServiceLocator(initialComponents)); } static ServiceLocator getLocator(); static ServiceLocator init(
final Properties properties,
final Map<Class<?>, Object> initialComponents); static ServiceLocator init(final Properties properties); static ServiceLocator init(final InputStream propertiesStream); static ServiceLocator init(final String propertiesPath); static String getVersion(); static String getReleaseDate(); static void main(final String[] args); }### Answer:
@Test public void withDefaultLoggerAndEC() throws Exception { final ServiceLocator locator = Bootstrap.init(getClass().getResourceAsStream("/projectprops/mockproject.properties")); final Properties ps = locator.resolve(Properties.class); assertEquals("Project id matches", ps.getProperty("project-id"), "0e13d168-1e2d-6ced-82f0-b9e693acde3e"); }
@Test public void withCustomLoggerAndEC() throws Exception { final String loggerName = "testLogger"; final Logger logger = LoggerFactory.getLogger(loggerName); final Map<Class<?>, Object> initialComponents = new HashMap<Class<?>, Object>(); final ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor(); initialComponents.put(ExecutorService.class, newSingleThreadExecutor); initialComponents.put(Logger.class, logger); final Properties p = new Properties(); p.load(getClass().getResourceAsStream("/projectprops/mockproject.properties")); final ServiceLocator locator = Bootstrap.init(p, initialComponents); assertSame("Logger instance matches.", locator.resolve(Logger.class), logger); assertSame("ExecutionService matches.", locator.resolve(ExecutorService.class), newSingleThreadExecutor); }
|
### Question:
Hello { public static String sayHello(String who) throws Exception { return "Hello " + who; } static String sayHello(String who); }### Answer:
@Test public void say_hello_test() throws Exception { Hello.sayHello("foo"); Thread.sleep(4000); }
@Test public void say_hello_test() throws Exception { Hello.sayHello("foo"); Thread.sleep(2000); }
|
### Question:
RankingService { public static int ratingChange(int place) { if (place < 1 || place > 4) return 0; return RATING_CHANGES[place - 1]; } @PostConstruct void initPlayers(); @GET @Produces(MediaType.APPLICATION_JSON) Collection<Player> topNPlayers(@QueryParam("limit") @DefaultValue("5") Integer numPlayers); @POST @RolesAllowed({ "admin" }) @Path("/{playerId}") void recordGame(@PathParam("playerId") String id, @QueryParam("place") int place, @HeaderParam("Authorization") String token); static int ratingChange(int place); static final int RATING_INITIAL; }### Answer:
@Test public void ratingChangeTest() { assertEquals(0, ratingChange(-1)); assertEquals(0, ratingChange(0)); assertEquals(28, ratingChange(1)); assertEquals(14, ratingChange(2)); assertEquals(-5, ratingChange(3)); assertEquals(-12, ratingChange(4)); assertEquals(0, ratingChange(5)); }
|
### Question:
ReflectionClassFactory implements XTypeFactory { @Override public XClass fromTypeMirror(TypeMirror typeMirror) { throw new UnsupportedOperationException("javax.lang.model.type.TypeMirror is only supported when processing annotations at compile time."); } ReflectionClassFactory(); @Override XClass fromClass(Class<?> c); @Override XClass fromTypeMirror(TypeMirror typeMirror); }### Answer:
@Test public void testFromTypeMirror() { expectedException.expect(UnsupportedOperationException.class); expectedException.expectMessage("javax.lang.model.type.TypeMirror is only supported when processing annotations at compile time."); ReflectionClassFactory typeFactory = new ReflectionClassFactory(); DeclaredType typeMirrorMock = mock(DeclaredType.class); typeFactory.fromTypeMirror(typeMirrorMock); }
|
### Question:
SerializationContextImpl implements SerializationContext { @Override public void unregisterProtoFile(String fileName) { log.debugf("Unregistering proto file : %s", fileName); writeLock.lock(); try { FileDescriptor fileDescriptor = fileDescriptors.remove(fileName); if (fileDescriptor != null) { unregisterFileDescriptorTypes(fileDescriptor); } else { throw new IllegalArgumentException("File " + fileName + " does not exist"); } } finally { writeLock.unlock(); } } SerializationContextImpl(Configuration configuration); @Override Configuration getConfiguration(); @Override Map<String, FileDescriptor> getFileDescriptors(); @Override Map<String, GenericDescriptor> getGenericDescriptors(); @Override void registerProtoFiles(FileDescriptorSource source); @Override void unregisterProtoFile(String fileName); @Override void unregisterProtoFiles(Set<String> fileNames); @Override Descriptor getMessageDescriptor(String fullTypeName); @Override EnumDescriptor getEnumDescriptor(String fullTypeName); @Override void registerMarshaller(BaseMarshaller<?> marshaller); @Override void unregisterMarshaller(BaseMarshaller<?> marshaller); @Override void registerMarshallerProvider(MarshallerProvider marshallerProvider); @Override void unregisterMarshallerProvider(MarshallerProvider marshallerProvider); @Override boolean canMarshall(Class<?> javaClass); @Override boolean canMarshall(String fullTypeName); @Override BaseMarshaller<T> getMarshaller(String fullTypeName); @Override BaseMarshaller<T> getMarshaller(Class<T> clazz); BaseMarshallerDelegate<T> getMarshallerDelegate(String descriptorFullName); BaseMarshallerDelegate<T> getMarshallerDelegate(Class<T> javaClass); @Deprecated @Override String getTypeNameById(Integer typeId); @Deprecated @Override Integer getTypeIdByName(String fullTypeName); @Override GenericDescriptor getDescriptorByName(String fullTypeName); @Override GenericDescriptor getDescriptorByTypeId(Integer typeId); }### Answer:
@Test public void testUnregisterMissingFiles() { exception.expect(IllegalArgumentException.class); exception.expectMessage("File test.proto does not exist"); SerializationContext ctx = createContext(); ctx.unregisterProtoFile("test.proto"); }
|
### Question:
AnnotationParser { private void expect(AnnotationTokens token) { if (lexer.token == token) { lexer.nextToken(); } else { long pos = AnnotationElement.line(lexer.pos) > AnnotationElement.line(lexer.lastPos) ? lexer.lastPos : lexer.pos; throw new AnnotationParserException(String.format("Error: %s: %s expected", AnnotationElement.positionToString(pos), token.text)); } } AnnotationParser(String input, boolean expectDocNoise); List<AnnotationElement.Annotation> parse(); }### Answer:
@Test public void testAnnotationsMustStartOnAnEmptyLine() { exception.expect(AnnotationParserException.class); exception.expectMessage("Error: 4,7: Annotations must start on an empty line"); testAnnotationParsing( "some garbage \n" + "\n" + "more garbage\n" + " aaa @Abc\n" + "\n", true, "@Abc(\n)\n"); }
@Test public void testUnexpectedShmoo() { exception.expect(AnnotationParserException.class); exception.expectMessage("Error: 1,1: Unexpected character: x"); testAnnotationParsing( "xx\n" + " @Abc \n" + "\n", false, "@Abc(\n)\n"); }
|
### Question:
ReservedProcessor { void scan(XClass javaClass) { reservedNumbers = new TreeSet<>(); reservedNames = new TreeMap<>(); scanReserved(javaClass, new HashSet<>()); } }### Answer:
@Test public void testDuplicateReservedNumber() { expectedException.expect(ProtoSchemaBuilderException.class); expectedException.expectMessage("Found duplicate @ProtoReserved number 1 in org.infinispan.protostream.annotations.impl.ReservedProcessorTest.DuplicateNumber"); XClass classToTest = new ReflectionClassFactory().fromClass(DuplicateNumber.class); new ReservedProcessor().scan(classToTest); }
@Test public void testDuplicateReservedName() { expectedException.expect(ProtoSchemaBuilderException.class); expectedException.expectMessage("Found duplicate @ProtoReserved name \"triceratops\" in org.infinispan.protostream.annotations.impl.ReservedProcessorTest.DuplicateName"); XClass classToTest = new ReflectionClassFactory().fromClass(DuplicateName.class); new ReservedProcessor().scan(classToTest); }
|
### Question:
ReflectionClassFactory implements XTypeFactory { @Override public XClass fromClass(Class<?> c) { if (c == null) { return null; } XClass xclass = classCache.get(c); if (xclass == null) { xclass = new ReflectionClass(c); classCache.put(c, xclass); } return xclass; } ReflectionClassFactory(); @Override XClass fromClass(Class<?> c); @Override XClass fromTypeMirror(TypeMirror typeMirror); }### Answer:
@Test public void testFromClass() { ReflectionClassFactory typeFactory = new ReflectionClassFactory(); XClass integerClass = typeFactory.fromClass(Integer.class); assertSame("java.lang.Integer", integerClass.getName()); assertFalse(integerClass.isArray()); }
|
### Question:
Wordpath { public Vertex combine(int from, int length) { this.connect(from, length); if (wordnet.isNotContains(from, length)) { return wordnet.put(from, length); } else { return wordnet.getVertex(from, length); } } Wordpath(Wordnet wordnet); Wordnet getWordnet(); Iterable<Vertex> getBestPathWithBE(); Iterator<Vertex> iteratorVertex(); Vertex combine(int from, int length); void combine(Vertex vertex); void findunloadVertext(Consumer<Vertex> consumer); int wordCount(); int wordCountInPath(); WordPointer wordPointer(); boolean willCutOtherWords(int from, int len); @Override String toString(); BitSet getBitSet(); void reset(); }### Answer:
@Test public void combine() throws Exception { String line = "我的中国心"; Wordpath wordPath = new Wordpath(new Wordnet(line.toCharArray())); wordPath.combine(0, 2); wordPath.combine(2, 3); Assert.assertEquals("我的 | 中国心", wordPath.toString()); }
|
### Question:
Prodecer { public void send(){ String context = "hello" + new Date() ; _logger.info("正在向队列发送消息：{}",context); this.rabbitMqTemplate.convertAndSend(RabbitMqConfig.queueName,context); } void send(); }### Answer:
@Test public void send() throws Exception { }
|
### Question:
FileObjectUtils { public static boolean exists(final FileObject fileObject) throws FileSystemException { return fileObject != null && fileObject.exists(); } private FileObjectUtils(); static boolean exists(final FileObject fileObject); static AbstractFileObject getAbstractFileObject(final FileObject fileObject); static byte[] getContentAsByteArray(final FileObject file); static String getContentAsString(final FileObject file, final Charset charset); static String getContentAsString(final FileObject file, final String charset); static boolean isInstanceOf(final FileObject fileObject, final Class<?> wantedClass); static Properties readProperties(final FileObject fileObject); static Properties readProperties(final FileObject fileObject, final Properties properties); static void writeContent(final FileObject file, final OutputStream output); static void writeContent(final FileObject srcFile, final FileObject destFile); }### Answer:
@Test public void testExistsNotNull() throws FileSystemException { Assert.assertTrue(FileObjectUtils.exists(VFS.getManager().toFileObject(SystemUtils.getJavaIoTmpDir()))); }
@Test public void testNotExistsNotNull() throws FileSystemException { Assert.assertFalse( FileObjectUtils.exists(VFS.getManager().toFileObject(new File("This file can't possibly exist, right?")))); }
@Test public void testNotExistsNull() throws FileSystemException { Assert.assertFalse(FileObjectUtils.exists(null)); }
|
### Question:
OrFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public List<FileFilter> getFileFilters() { return Collections.unmodifiableList(this.fileFilters); } OrFileFilter(); OrFileFilter(final FileFilter... filters); OrFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@Test public void testOrFileFilterFileFilter() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final OrFileFilter testee = new OrFileFilter(filter1, filter2, filter3); assertContainsOnly(testee.getFileFilters(), filter1, filter2, filter3); }
@Test public void testOrFileFilterList() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final List<FileFilter> list = new ArrayList<>(); list.add(filter1); list.add(filter2); list.add(filter3); final OrFileFilter testee = new OrFileFilter(list); assertContainsOnly(testee.getFileFilters(), filter1, filter2, filter3); }
|
### Question:
OrFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public void addFileFilter(final FileFilter fileFilter) { this.fileFilters.add(fileFilter); } OrFileFilter(); OrFileFilter(final FileFilter... filters); OrFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@Test public void testAddFileFilter() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final OrFileFilter testee = new OrFileFilter(); testee.addFileFilter(filter1); testee.addFileFilter(filter2); testee.addFileFilter(filter3); assertContainsOnly(testee.getFileFilters(), filter1, filter2, filter3); }
|
### Question:
OrFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public boolean removeFileFilter(final FileFilter fileFilter) { return this.fileFilters.remove(fileFilter); } OrFileFilter(); OrFileFilter(final FileFilter... filters); OrFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@Test public void testRemoveFileFilter() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final OrFileFilter testee = new OrFileFilter(filter1, filter2, filter3); testee.removeFileFilter(filter2); assertContainsOnly(testee.getFileFilters(), filter1, filter3); }
|
### Question:
OrFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public void setFileFilters(final List<FileFilter> fileFilters) { this.fileFilters.clear(); this.fileFilters.addAll(fileFilters); } OrFileFilter(); OrFileFilter(final FileFilter... filters); OrFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@Test public void testSetFileFilters() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final List<FileFilter> list = new ArrayList<>(); list.add(filter1); list.add(filter2); list.add(filter3); final OrFileFilter testee = new OrFileFilter(); testee.setFileFilters(list); assertContainsOnly(testee.getFileFilters(), filter1, filter2, filter3); }
|
### Question:
OrFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public boolean accept(final FileSelectInfo fileInfo) throws FileSystemException { for (final FileFilter fileFilter : fileFilters) { if (fileFilter.accept(fileInfo)) { return true; } } return false; } OrFileFilter(); OrFileFilter(final FileFilter... filters); OrFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@Test public void testAccept() throws FileSystemException { final FileSelectInfo any = createFileSelectInfo(new File("anyfile")); Assert.assertFalse(new OrFileFilter().accept(any)); Assert.assertTrue(new OrFileFilter(new True()).accept(any)); Assert.assertTrue(new OrFileFilter(new True(), new True()).accept(any)); Assert.assertTrue(new OrFileFilter(new False(), new True()).accept(any)); Assert.assertTrue(new OrFileFilter(new True(), new False()).accept(any)); Assert.assertFalse(new OrFileFilter(new False()).accept(any)); Assert.assertFalse(new OrFileFilter(new False(), new False()).accept(any)); }
|
### Question:
NotFileFilter implements FileFilter, Serializable { @Override public boolean accept(final FileSelectInfo fileInfo) throws FileSystemException { return !filter.accept(fileInfo); } NotFileFilter(final FileFilter filter); @Override boolean accept(final FileSelectInfo fileInfo); @Override String toString(); }### Answer:
@Test public void testAccept() throws FileSystemException { final FileSelectInfo any = createFileSelectInfo(new File("test1.txt")); Assert.assertFalse(new NotFileFilter(TrueFileFilter.TRUE).accept(any)); Assert.assertTrue(new NotFileFilter(FalseFileFilter.FALSE).accept(any)); }
|
### Question:
SymbolicLinkFileFilter implements FileFilter, Serializable { @Override public boolean accept(final FileSelectInfo fileInfo) throws FileSystemException { if (!fileInfo.getFile().exists()) { return false; } return fileInfo.getFile().isSymbolicLink(); } protected SymbolicLinkFileFilter(); @Override boolean accept(final FileSelectInfo fileInfo); static final FileFilter SYMBOLIC; static final FileFilter ACTUAL; }### Answer:
@Test public void testAcceptActual() throws FileSystemException { final FileFilter testee = SymbolicLinkFileFilter.ACTUAL; Assert.assertTrue(targetFileInfo.getBaseFolder().exists()); Assert.assertTrue(targetFileInfo.getFile().exists()); Assert.assertTrue(targetFileInfo.toString(), testee.accept(targetFileInfo)); Assert.assertTrue(notExistingFileInfo.toString(), testee.accept(notExistingFileInfo)); }
@Test public void testAcceptSymbolic() throws FileSystemException { final FileFilter testee = SymbolicLinkFileFilter.SYMBOLIC; Assert.assertTrue(linkFileInfo.toString(), testee.accept(linkFileInfo)); Assert.assertFalse(notExistingFileInfo.toString(), testee.accept(notExistingFileInfo)); }
|
### Question:
HiddenFileFilter implements FileFilter, Serializable { @Override public boolean accept(final FileSelectInfo fileInfo) throws FileSystemException { if (!fileInfo.getFile().exists()) { return false; } return fileInfo.getFile().isHidden(); } protected HiddenFileFilter(); @Override boolean accept(final FileSelectInfo fileInfo); static final FileFilter HIDDEN; static final FileFilter VISIBLE; }### Answer:
@Test public void testAcceptHidden() throws FileSystemException { final FileFilter testee = HiddenFileFilter.HIDDEN; Assert.assertFalse(testee.accept(visibleFileInfo)); Assert.assertFalse(testee.accept(notExistingFileInfo)); }
@Test public void testAcceptVisible() throws FileSystemException { final FileFilter testee = HiddenFileFilter.VISIBLE; Assert.assertTrue(testee.accept(visibleFileInfo)); Assert.assertTrue(testee.accept(notExistingFileInfo)); }
|
### Question:
CanWriteFileFilter implements FileFilter, Serializable { @Override public boolean accept(final FileSelectInfo fileInfo) throws FileSystemException { try (final FileObject file = fileInfo.getFile()) { final FileSystem fileSystem = file.getFileSystem(); if (file.exists()) { if (!fileSystem.hasCapability(Capability.WRITE_CONTENT)) { return false; } return file.isWriteable(); } if (!fileSystem.hasCapability(Capability.CREATE)) { return false; } return file.getParent().isWriteable(); } } protected CanWriteFileFilter(); @Override boolean accept(final FileSelectInfo fileInfo); static final FileFilter CAN_WRITE; static final FileFilter CANNOT_WRITE; }### Answer:
@Test public void testAcceptCanWrite() throws FileSystemException { Assert.assertTrue(CanWriteFileFilter.CAN_WRITE.accept(writeableFileInfo)); Assert.assertFalse(CanWriteFileFilter.CAN_WRITE.accept(readOnlyFileInfo)); Assert.assertTrue(CanWriteFileFilter.CAN_WRITE.accept(notExistingFileInfo)); }
@Test public void testAcceptCannotWrite() throws FileSystemException { Assert.assertFalse(CanWriteFileFilter.CANNOT_WRITE.accept(writeableFileInfo)); Assert.assertTrue(CanWriteFileFilter.CANNOT_WRITE.accept(readOnlyFileInfo)); Assert.assertFalse(CanWriteFileFilter.CANNOT_WRITE.accept(notExistingFileInfo)); }
|
### Question:
CanReadFileFilter implements FileFilter, Serializable { @Override public boolean accept(final FileSelectInfo fileInfo) throws FileSystemException { return fileInfo.getFile().isReadable(); } protected CanReadFileFilter(); @Override boolean accept(final FileSelectInfo fileInfo); static final FileFilter CAN_READ; static final FileFilter CANNOT_READ; static final FileFilter READ_ONLY; }### Answer:
@Test public void testAcceptCanRead() throws FileSystemException { Assert.assertTrue(CanReadFileFilter.CAN_READ.accept(writeableFileInfo)); Assert.assertTrue(CanReadFileFilter.CAN_READ.accept(readOnlyFileInfo)); Assert.assertFalse(CanReadFileFilter.CAN_READ.accept(notExistingFileInfo)); }
@Test public void testAcceptCannotRead() throws FileSystemException { Assert.assertFalse(CanReadFileFilter.CANNOT_READ.accept(writeableFileInfo)); Assert.assertFalse(CanReadFileFilter.CANNOT_READ.accept(readOnlyFileInfo)); Assert.assertTrue(CanReadFileFilter.CANNOT_READ.accept(notExistingFileInfo)); }
@Test public void testAcceptReadOnly() throws FileSystemException { Assert.assertFalse(CanReadFileFilter.READ_ONLY.accept(writeableFileInfo)); Assert.assertTrue(CanReadFileFilter.READ_ONLY.accept(readOnlyFileInfo)); Assert.assertFalse(CanReadFileFilter.READ_ONLY.accept(notExistingFileInfo)); }
|
### Question:
EmptyFileFilter implements FileFilter, Serializable { @Override public boolean accept(final FileSelectInfo fileInfo) throws FileSystemException { try (final FileObject file = fileInfo.getFile()) { if (!file.exists()) { return true; } if (file.getType() == FileType.FOLDER) { final FileObject[] files = file.getChildren(); return files == null || files.length == 0; } try (final FileContent content = file.getContent();) { return content.isEmpty(); } } } protected EmptyFileFilter(); @Override boolean accept(final FileSelectInfo fileInfo); static final FileFilter EMPTY; static final FileFilter NOT_EMPTY; }### Answer:
@Test public void testAcceptEmpty() throws FileSystemException { final FileFilter testee = EmptyFileFilter.EMPTY; Assert.assertFalse(testee.accept(notEmptyFileInfo)); Assert.assertTrue(testee.accept(emptyFileInfo)); Assert.assertFalse(testee.accept(notEmptyDirInfo)); Assert.assertTrue(testee.accept(emptyDirInfo)); Assert.assertTrue(testee.accept(notExistingFileInfo)); }
@Test public void testAcceptNotEmpty() throws FileSystemException { final FileFilter testee = EmptyFileFilter.NOT_EMPTY; Assert.assertTrue(testee.accept(notEmptyFileInfo)); Assert.assertFalse(testee.accept(emptyFileInfo)); Assert.assertTrue(testee.accept(notEmptyDirInfo)); Assert.assertFalse(testee.accept(emptyDirInfo)); Assert.assertFalse(testee.accept(notExistingFileInfo)); }
|
### Question:
CanExecuteFileFilter implements FileFilter, Serializable { @Override public boolean accept(final FileSelectInfo fileInfo) throws FileSystemException { return fileInfo.getFile().isExecutable(); } protected CanExecuteFileFilter(); @Override boolean accept(final FileSelectInfo fileInfo); static final FileFilter CAN_EXECUTE; static final FileFilter CANNOT_EXECUTE; }### Answer:
@Test public void testAcceptCanExecute() throws FileSystemException { Assert.assertTrue(CanExecuteFileFilter.CAN_EXECUTE.accept(executableFileInfo)); Assert.assertTrue(CanExecuteFileFilter.CAN_EXECUTE.accept(notExecutableFileInfo)); Assert.assertFalse(CanExecuteFileFilter.CAN_EXECUTE.accept(notExistingFileInfo)); }
@Test public void testAcceptCannotExecute() throws FileSystemException { Assert.assertFalse(CanExecuteFileFilter.CANNOT_EXECUTE.accept(executableFileInfo)); Assert.assertFalse(CanExecuteFileFilter.CANNOT_EXECUTE.accept(notExecutableFileInfo)); Assert.assertTrue(CanExecuteFileFilter.CANNOT_EXECUTE.accept(notExistingFileInfo)); }
|
### Question:
AndFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public List<FileFilter> getFileFilters() { return Collections.unmodifiableList(this.fileFilters); } AndFileFilter(); AndFileFilter(final FileFilter... filters); AndFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@Test public void testAndFileFilterFileFilter() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final AndFileFilter testee = new AndFileFilter(filter1, filter2, filter3); assertContainsOnly(testee.getFileFilters(), filter1, filter2, filter3); }
@Test public void testAndFileFilterList() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final List<FileFilter> list = new ArrayList<>(); list.add(filter1); list.add(filter2); list.add(filter3); final AndFileFilter testee = new AndFileFilter(list); assertContainsOnly(testee.getFileFilters(), filter1, filter2, filter3); }
|
### Question:
AndFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public void addFileFilter(final FileFilter fileFilter) { this.fileFilters.add(fileFilter); } AndFileFilter(); AndFileFilter(final FileFilter... filters); AndFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@Test public void testAddFileFilter() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final AndFileFilter testee = new AndFileFilter(); testee.addFileFilter(filter1); testee.addFileFilter(filter2); testee.addFileFilter(filter3); assertContainsOnly(testee.getFileFilters(), filter1, filter2, filter3); }
|
### Question:
AndFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public boolean removeFileFilter(final FileFilter fileFilter) { return this.fileFilters.remove(fileFilter); } AndFileFilter(); AndFileFilter(final FileFilter... filters); AndFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@Test public void testRemoveFileFilter() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final AndFileFilter testee = new AndFileFilter(filter1, filter2, filter3); testee.removeFileFilter(filter2); assertContainsOnly(testee.getFileFilters(), filter1, filter3); }
|
### Question:
AndFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public void setFileFilters(final List<FileFilter> fileFilters) { this.fileFilters.clear(); this.fileFilters.addAll(fileFilters); } AndFileFilter(); AndFileFilter(final FileFilter... filters); AndFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@Test public void testSetFileFilters() { final FileFilter filter1 = new DummyFilter(); final FileFilter filter2 = new DummyFilter(); final FileFilter filter3 = new DummyFilter(); final List<FileFilter> list = new ArrayList<>(); list.add(filter1); list.add(filter2); list.add(filter3); final AndFileFilter testee = new AndFileFilter(); testee.setFileFilters(list); assertContainsOnly(testee.getFileFilters(), filter1, filter2, filter3); }
|
### Question:
AndFileFilter implements FileFilter, ConditionalFileFilter, Serializable { @Override public boolean accept(final FileSelectInfo fileInfo) throws FileSystemException { if (this.fileFilters.isEmpty()) { return false; } for (final FileFilter fileFilter : fileFilters) { if (!fileFilter.accept(fileInfo)) { return false; } } return true; } AndFileFilter(); AndFileFilter(final FileFilter... filters); AndFileFilter(final List<FileFilter> fileFilters); @Override boolean accept(final FileSelectInfo fileInfo); @Override void addFileFilter(final FileFilter fileFilter); @Override List<FileFilter> getFileFilters(); @Override boolean removeFileFilter(final FileFilter fileFilter); @Override void setFileFilters(final List<FileFilter> fileFilters); @Override String toString(); }### Answer:
@SuppressWarnings("deprecation") @Test public void testAccept() throws FileSystemException { final FileSelectInfo any = createFileSelectInfo(new File("anyfile")); Assert.assertFalse(new AndFileFilter().accept(any)); Assert.assertTrue(new AndFileFilter(new True()).accept(any)); Assert.assertTrue(new AndFileFilter(new True(), new True()).accept(any)); Assert.assertFalse(new AndFileFilter(new False()).accept(any)); Assert.assertFalse(new AndFileFilter(new False(), new False()).accept(any)); Assert.assertFalse(new AndFileFilter(new False(), new True()).accept(any)); Assert.assertFalse(new AndFileFilter(new True(), new False()).accept(any)); }
@Test public void testAcceptChecked() throws FileSystemException { final FileSelectInfo any = createFileSelectInfo(new File("anyfile")); Assert.assertFalse(new AndFileFilter().accept(any)); Assert.assertTrue(new AndFileFilter(new True()).accept(any)); Assert.assertTrue(new AndFileFilter(new True(), new True()).accept(any)); Assert.assertFalse(new AndFileFilter(new False()).accept(any)); Assert.assertFalse(new AndFileFilter(new False(), new False()).accept(any)); Assert.assertFalse(new AndFileFilter(new False(), new True()).accept(any)); Assert.assertFalse(new AndFileFilter(new True(), new False()).accept(any)); }
|
### Question:
UrlFileNameParser extends AbstractFileNameParser { @Override public FileName parseUri(final VfsComponentContext context, final FileName base, final String uri) throws FileSystemException { if (isUrlBased(base, uri)) { return url.parseUri(context, base, uri); } return generic.parseUri(context, base, uri); } UrlFileNameParser(); @Override boolean encodeCharacter(final char ch); @Override FileName parseUri(final VfsComponentContext context, final FileName base, final String uri); }### Answer:
@Test public void testJira739() throws Exception { final String uriStr = "maprfs: final URI uri = new URI(uriStr); final FileName fileName = new UrlFileNameParser().parseUri(null, null, uriStr); Assert.assertEquals(uriStr, fileName.getURI()); Assert.assertEquals(uri.getScheme(), fileName.getScheme()); }
|
### Question:
DefaultFileContent implements FileContent { @Override public OutputStream getOutputStream() throws FileSystemException { return getOutputStream(false); } DefaultFileContent(final AbstractFileObject file, final FileContentInfoFactory fileContentInfoFactory); @Override FileObject getFile(); @Override long getSize(); @Override long getLastModifiedTime(); @Override void setLastModifiedTime(final long modTime); @Override boolean hasAttribute(final String attrName); @Override Map<String, Object> getAttributes(); void resetAttributes(); @Override String[] getAttributeNames(); @Override Object getAttribute(final String attrName); @Override void setAttribute(final String attrName, final Object value); @Override void removeAttribute(final String attrName); @Override Certificate[] getCertificates(); @Override InputStream getInputStream(); @Override InputStream getInputStream(final int bufferSize); @Override RandomAccessContent getRandomAccessContent(final RandomAccessMode mode); @Override OutputStream getOutputStream(); @Override OutputStream getOutputStream(final boolean bAppend); @Override OutputStream getOutputStream(final int bufferSize); @Override OutputStream getOutputStream(final boolean bAppend, final int bufferSize); @Override void close(); @Override boolean isOpen(); boolean isOpenGlobal(); @Override FileContentInfo getContentInfo(); @Override long write(final FileContent fileContent); @Override long write(final FileObject file); @Override long write(final OutputStream output); @Override long write(final OutputStream output, final int bufferSize); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testOutputStreamBufferSizeNegativeWithAppendFlag() throws Exception { final File temp = File.createTempFile("temp-file-name", ".tmp"); final FileSystemManager fileSystemManager = VFS.getManager(); try (FileObject file = fileSystemManager.resolveFile(temp.getAbsolutePath())) { file.getContent().getOutputStream(true, -1); } }
|
### Question:
FileSystemException extends IOException { public String[] getInfo() { return info; } FileSystemException(final String code); FileSystemException(final String code, final Object info0); FileSystemException(final String code, final Object info0, final Throwable throwable); FileSystemException(final String code, final Object... info); FileSystemException(final String code, final Throwable throwable); @Deprecated FileSystemException(final String code, final Object[] info, final Throwable throwable); FileSystemException(final String code, final Throwable throwable, final Object... info); FileSystemException(final Throwable throwable); static T requireNonNull(final T obj, final String code); static T requireNonNull(final T obj, final String code, final Object... info); @Override String getMessage(); String getCode(); String[] getInfo(); }### Answer:
@Test public void testMasksPasswordOfUrlsWithBasicAuthentication() { final FileSystemException fse = new FileSystemException("vfs.provider/rename.error", "file: "http: assertEquals("file: assertEquals("http: }
@Test public void testDoesNotModifyUrlsWithoutPassword() { final FileSystemException fse = new FileSystemException("vfs.provider/delete.error", "http: assertEquals("http: }
@Test public void testProperDetectionOfUrl() { final FileSystemException fse = new FileSystemException("vfs.provider/delete.error", "zip:http: assertEquals("zip:http: }
|
### Question:
FileObjectUtils { public static Properties readProperties(final FileObject fileObject) throws FileSystemException, IOException { return readProperties(fileObject, new Properties()); } private FileObjectUtils(); static boolean exists(final FileObject fileObject); static AbstractFileObject getAbstractFileObject(final FileObject fileObject); static byte[] getContentAsByteArray(final FileObject file); static String getContentAsString(final FileObject file, final Charset charset); static String getContentAsString(final FileObject file, final String charset); static boolean isInstanceOf(final FileObject fileObject, final Class<?> wantedClass); static Properties readProperties(final FileObject fileObject); static Properties readProperties(final FileObject fileObject, final Properties properties); static void writeContent(final FileObject file, final OutputStream output); static void writeContent(final FileObject srcFile, final FileObject destFile); }### Answer:
@Test public void testReadProperties() throws FileSystemException, IOException { assertProperties(FileObjectUtils .readProperties(VFS.getManager().toFileObject(new File("src/test/resources/test.properties")))); }
@Test public void testReadPropertiesInto() throws FileSystemException, IOException { final Properties p = new Properties(); p.setProperty("extraKey", "extraValue"); assertProperties(FileObjectUtils .readProperties(VFS.getManager().toFileObject(new File("src/test/resources/test.properties")), p)); Assert.assertEquals("extraValue", p.getProperty("extraKey")); }
|
### Question:
PatternFileSelector implements FileSelector { @Override public String toString() { return this.pattern.toString(); } PatternFileSelector(final Pattern pattern); PatternFileSelector(final String regex); PatternFileSelector(final String regex, final int flags); @Override boolean includeFile(final FileSelectInfo fileInfo); @Override String toString(); @Override boolean traverseDescendents(final FileSelectInfo fileInfo); }### Answer:
@Test public void testFileExtensions() throws Exception { final FileObject[] foArray = BaseFolder.findFiles(Selectors.SELECT_FILES); Assert.assertTrue(foArray.length > 0); final String regExPrefix = ".*\\."; final Set<String> extensionSet = new HashSet<>(); for (final FileObject fo : foArray) { extensionSet.add(regExPrefix + fo.getName().getExtension()); } final String message = String.format("Extensions: %s; files: %s", extensionSet.toString(), Arrays.asList(foArray).toString()); assertEquals(message, ExtensionCount, extensionSet.size()); for (final String extension : extensionSet) { final FileSelector selector = new PatternFileSelector(extension); final FileObject[] list = BaseFolder.findFiles(selector); assertEquals(FilesPerExtensionCount, list.length); } for (final FileObject fo : foArray) { final FileSelector selector = new PatternFileSelector(regExPrefix + fo.getName().getExtension()); final FileObject[] list = BaseFolder.findFiles(selector); assertEquals(FilesPerExtensionCount, list.length); } }
|
### Question:
AIMDLimit extends AbstractLimit { public static Builder newBuilder() { return new Builder(); } private AIMDLimit(Builder builder); static Builder newBuilder(); @Override String toString(); }### Answer:
@Test public void testDefault() { AIMDLimit limiter = AIMDLimit.newBuilder().initialLimit(10).build(); Assert.assertEquals(10, limiter.getLimit()); }
@Test public void increaseOnSuccess() { AIMDLimit limiter = AIMDLimit.newBuilder().initialLimit(20).build(); limiter.onSample(0, TimeUnit.MILLISECONDS.toNanos(1), 10, false); Assert.assertEquals(21, limiter.getLimit()); }
@Test public void decreaseOnDrops() { AIMDLimit limiter = AIMDLimit.newBuilder().initialLimit(30).build(); limiter.onSample(0, 0, 0, true); Assert.assertEquals(27, limiter.getLimit()); }
|
### Question:
SpectatorMetricRegistry implements MetricRegistry { @Override public void gauge(String id, Supplier<Number> supplier, String... tagNameValuePairs) { Id metricId = suffixBaseId(id).withTags(tagNameValuePairs); PolledMeter.remove(registry, metricId); PolledMeter.using(registry) .withId(metricId) .monitorValue(supplier, ignore -> supplier.get().doubleValue()); } SpectatorMetricRegistry(Registry registry, Id baseId); @Override SampleListener distribution(String id, String... tagNameValuePairs); @Override void gauge(String id, Supplier<Number> supplier, String... tagNameValuePairs); @Override Counter counter(String id, String... tagNameValuePairs); }### Answer:
@Test public void testGuage() { DefaultRegistry registry = new DefaultRegistry(); SpectatorMetricRegistry metricRegistry = new SpectatorMetricRegistry(registry, registry.createId("foo")); metricRegistry.gauge("bar", () -> 10); PolledMeter.update(registry); Assert.assertEquals(10.0, registry.gauge(registry.createId("foo.bar")).value(), 0); }
@Test public void testUnregister() { DefaultRegistry registry = new DefaultRegistry(); SpectatorMetricRegistry metricRegistry = new SpectatorMetricRegistry(registry, registry.createId("foo")); metricRegistry.gauge("bar", () -> 10); metricRegistry.gauge("bar", () -> 20); PolledMeter.update(registry); Assert.assertEquals(20.0, registry.gauge(registry.createId("foo.bar")).value(), 0); }
|
### Question:
AbstractPartitionedLimiter extends AbstractLimiter<ContextT> { Partition getPartition(String name) { return partitions.get(name); } AbstractPartitionedLimiter(Builder<?, ContextT> builder); @Override Optional<Listener> acquire(ContextT context); }### Answer:
@Test public void limitAllocatedToBins() { AbstractPartitionedLimiter<String> limiter = (AbstractPartitionedLimiter<String>) TestPartitionedLimiter.newBuilder() .partitionResolver(Function.identity()) .partition("batch", 0.3) .partition("live", 0.7) .limit(FixedLimit.of(10)) .build(); Assert.assertEquals(3, limiter.getPartition("batch").getLimit()); Assert.assertEquals(7, limiter.getPartition("live").getLimit()); }
|
### Question:
BlockingLimiter implements Limiter<ContextT> { public static <ContextT> BlockingLimiter<ContextT> wrap(Limiter<ContextT> delegate) { return new BlockingLimiter<>(delegate, MAX_TIMEOUT); } private BlockingLimiter(Limiter<ContextT> limiter, Duration timeout); static BlockingLimiter<ContextT> wrap(Limiter<ContextT> delegate); static BlockingLimiter<ContextT> wrap(Limiter<ContextT> delegate, Duration timeout); @Override Optional<Listener> acquire(ContextT context); @Override String toString(); static final Duration MAX_TIMEOUT; }### Answer:
@Test(expected = IllegalArgumentException.class) public void failOnHighTimeout() { SettableLimit limit = SettableLimit.startingAt(1); BlockingLimiter<Void> limiter = BlockingLimiter.wrap(SimpleLimiter.newBuilder().limit(limit).build(), Duration.ofDays(1)); }
|
### Question:
Strings { @Contract("!null->!null; null->null") public static String upper(@Nullable final String string) { return string == null ? null : string.toUpperCase(); } @SuppressWarnings({"StringEquality", "SimplifiableIfStatement"}) static boolean eq(final String str1, final String str2); @SuppressWarnings({"StringEquality", "SimplifiableIfStatement"}) static boolean eq(final String str1, final String str2, final boolean caseSensitive); @NotNull static String ensureStartsWith(@NotNull final String str, final char c); @NotNull static String ensureEndsWith(@NotNull final String str, final char c); @NotNull static String removeEnding(@NotNull final String str, @NotNull final String ending); @NotNull static String rtrim(@NotNull final String str); @NotNull static String replace(@NotNull final String where, @NotNull final String what, @NotNull final String with); @NotNull static String repeat(@NotNull final String what, @Nullable final String delimiter, int count); @Contract("null,_->false") static boolean matches(@Nullable final CharSequence string, @NotNull final Pattern pattern); @Contract("null,_,_->false") static boolean matches(@Nullable final CharSequence string, @NotNull final String pattern, boolean caseSensitive); @Contract("!null->!null; null->null") static String upper(@Nullable final String string); @Contract("!null->!null; null->null") static String lower(@Nullable final String string); @Contract("!null->!null; null->null") static String minimizeSpaces(@Nullable final String string); @Contract("!null,_->!null; null,_->null") static String lastPart(@Nullable final String string, final char delimiter); }### Answer:
@Test public void upper_basic() { assertThat(upper("aaA")).isEqualTo("AAA"); assertThat(upper("i")).isEqualTo("I"); assertThat(upper("M")).isEqualTo("M"); assertThat(upper(null)).isNull(); assertThat(upper("XXX")).isSameAs("XXX"); }
|
### Question:
Strings { @Contract("!null->!null; null->null") public static String lower(@Nullable final String string) { return string == null ? null : string.toLowerCase(); } @SuppressWarnings({"StringEquality", "SimplifiableIfStatement"}) static boolean eq(final String str1, final String str2); @SuppressWarnings({"StringEquality", "SimplifiableIfStatement"}) static boolean eq(final String str1, final String str2, final boolean caseSensitive); @NotNull static String ensureStartsWith(@NotNull final String str, final char c); @NotNull static String ensureEndsWith(@NotNull final String str, final char c); @NotNull static String removeEnding(@NotNull final String str, @NotNull final String ending); @NotNull static String rtrim(@NotNull final String str); @NotNull static String replace(@NotNull final String where, @NotNull final String what, @NotNull final String with); @NotNull static String repeat(@NotNull final String what, @Nullable final String delimiter, int count); @Contract("null,_->false") static boolean matches(@Nullable final CharSequence string, @NotNull final Pattern pattern); @Contract("null,_,_->false") static boolean matches(@Nullable final CharSequence string, @NotNull final String pattern, boolean caseSensitive); @Contract("!null->!null; null->null") static String upper(@Nullable final String string); @Contract("!null->!null; null->null") static String lower(@Nullable final String string); @Contract("!null->!null; null->null") static String minimizeSpaces(@Nullable final String string); @Contract("!null,_->!null; null,_->null") static String lastPart(@Nullable final String string, final char delimiter); }### Answer:
@Test public void lower_basic() { assertThat(lower("Aaa")).isEqualTo("aaa"); assertThat(lower("Iii")).isEqualTo("iii"); assertThat(lower("xxx")).isEqualTo("xxx"); assertThat(lower(null)).isNull(); assertThat(lower("xxx")).isSameAs("xxx"); }
|
### Question:
Numbers { public static boolean valuesAreEqual(@Nullable final Number x, @Nullable final Number y) { if (x == y) return true; if (x == null || y == null) return false; return x.getClass() == y.getClass() ? x.equals(y) : x.toString().equals(y.toString()); } static boolean valuesAreEqual(@Nullable final Number x, @Nullable final Number y); @SuppressWarnings("unchecked") @Contract(value = "_,!null -> !null; _,null -> null", pure = true) static N convertNumber(final Class<N> numberClass, final Number number); @Contract(value = "!null -> !null; null -> null", pure = true) static Number convertNumberSmartly(final BigDecimal decimal); static int parseIntSafe(@Nullable final String str); static long parseLongSafe(@Nullable final String str); static final Byte BYTE_ZERO; static final BigDecimal DECIMAL_ZERO; static final BigDecimal DECIMAL_MIN_LONG; static final BigDecimal DECIMAL_MAX_LONG; }### Answer:
@Test public void valuesAreEqual_basic() { assertThat(valuesAreEqual(123, 123L)).isTrue(); assertThat(valuesAreEqual(123, BigInteger.valueOf(123L))).isTrue(); assertThat(valuesAreEqual(123.45f, new BigDecimal("123.45"))).isTrue(); }
@Test public void valuesAreEqual_nulls() { assertThat(valuesAreEqual(null, null)).isTrue(); assertThat(valuesAreEqual(111, null)).isFalse(); assertThat(valuesAreEqual(null, 222)).isFalse(); }
|
### Question:
Numbers { public static int parseIntSafe(@Nullable final String str) { if (str == null) { return 0; } try { final String s = str.trim(); if (s.isEmpty()) return 0; if (s.charAt(0) == '+') return Integer.parseInt(s.substring(1)); return Integer.parseInt(s); } catch (NumberFormatException e) { return 0; } } static boolean valuesAreEqual(@Nullable final Number x, @Nullable final Number y); @SuppressWarnings("unchecked") @Contract(value = "_,!null -> !null; _,null -> null", pure = true) static N convertNumber(final Class<N> numberClass, final Number number); @Contract(value = "!null -> !null; null -> null", pure = true) static Number convertNumberSmartly(final BigDecimal decimal); static int parseIntSafe(@Nullable final String str); static long parseLongSafe(@Nullable final String str); static final Byte BYTE_ZERO; static final BigDecimal DECIMAL_ZERO; static final BigDecimal DECIMAL_MIN_LONG; static final BigDecimal DECIMAL_MAX_LONG; }### Answer:
@TestWithParams(params = "INT_CASES") public void parseIntSafe_with(String str, int result) { final int value = parseIntSafe(str); assertThat(value).isEqualTo(result); }
|
### Question:
Numbers { public static long parseLongSafe(@Nullable final String str) { if (str == null) { return 0; } try { final String s = str.trim(); if (s.isEmpty()) return 0L; if (s.charAt(0) == '+') return Long.parseLong(s.substring(1)); return Long.parseLong(s); } catch (NumberFormatException e) { return 0; } } static boolean valuesAreEqual(@Nullable final Number x, @Nullable final Number y); @SuppressWarnings("unchecked") @Contract(value = "_,!null -> !null; _,null -> null", pure = true) static N convertNumber(final Class<N> numberClass, final Number number); @Contract(value = "!null -> !null; null -> null", pure = true) static Number convertNumberSmartly(final BigDecimal decimal); static int parseIntSafe(@Nullable final String str); static long parseLongSafe(@Nullable final String str); static final Byte BYTE_ZERO; static final BigDecimal DECIMAL_ZERO; static final BigDecimal DECIMAL_MIN_LONG; static final BigDecimal DECIMAL_MAX_LONG; }### Answer:
@TestWithParams(params = "LONG_CASES") public void parseLongSafe_with(String str, long result) { final long value = parseLongSafe(str); assertThat(value).isEqualTo(result); }
|
### Question:
Version implements Comparable<Version>, Serializable { @NotNull public Version truncate(final int n) { if (elements.length <= n) return this; if (n < 0) throw new IllegalArgumentException("Negative desired size: " + n); int m = n; while (m > 0 && elements[m-1] == 0) m--; if (m == 0) return ZERO; final int[] newElements = new int[m]; System.arraycopy(this.elements, 0, newElements, 0, m); return new Version(newElements); } private Version(@NotNull final int[] elements); static Version of(@NotNull final String string); static Version of(@NotNull final int... elements); static Version of(@NotNull final Integer[] elements); int get(int index); int size(); @NotNull Version truncate(final int n); @NotNull Version truncateNegatives(); int compareTo(@NotNull final Version that); int compareTo(final int... that); boolean isOrGreater(final int... than); boolean isOrGreater(@NotNull final Version than); boolean less(final int... than); boolean less(@NotNull final Version than); @Override boolean equals(final Object o); @Override int hashCode(); @NotNull String toString(); @NotNull String toString(int minimumElements, int maximumElements); @NotNull int[] toArray(); static final Version ZERO; }### Answer:
@Test public void truncate_ZERO() { Version z = Version.ZERO; Version z1 = z.truncate(1); assertThat(z1).isSameAs(z); }
|
### Question:
Version implements Comparable<Version>, Serializable { @NotNull public Version truncateNegatives() { final int n = elements.length; for (int k = 0; k < n; k++) if (elements[k] < 0) return truncate(k); return this; } private Version(@NotNull final int[] elements); static Version of(@NotNull final String string); static Version of(@NotNull final int... elements); static Version of(@NotNull final Integer[] elements); int get(int index); int size(); @NotNull Version truncate(final int n); @NotNull Version truncateNegatives(); int compareTo(@NotNull final Version that); int compareTo(final int... that); boolean isOrGreater(final int... than); boolean isOrGreater(@NotNull final Version than); boolean less(final int... than); boolean less(@NotNull final Version than); @Override boolean equals(final Object o); @Override int hashCode(); @NotNull String toString(); @NotNull String toString(int minimumElements, int maximumElements); @NotNull int[] toArray(); static final Version ZERO; }### Answer:
@Test public void truncateNegatives_ZERO() { assertThat(Version.ZERO.truncateNegatives()).isSameAs(Version.ZERO); }
|
### Question:
Rewriters { public static StringOperator replace(@NotNull final String what, @NotNull final String with) { return new StringOperator() { @Override public String apply(final String arg) { return Strings.replace(arg, what, with); } }; } static StringOperator replace(@NotNull final String what, @NotNull final String with); static StringOperator replace(@NotNull final Map<String,String> map); }### Answer:
@Test public void replace_1_basic() { assertThat(Rewriters.replace("YYY","TTT").apply("XXX YYY ZZZ")).isEqualTo("XXX TTT ZZZ"); }
@Test public void replace_1_same() { String str = "ABCDE"; assertThat(Rewriters.replace("YYY","TTT").apply(str)).isSameAs(str); }
@Test public void replace_map_1() { assertThat(Rewriters.replace(Collections.singletonMap("YYY", "TTT")).apply("XXX YYY ZZZ")) .isEqualTo("XXX TTT ZZZ"); }
@Test public void replace_map_2x2() { Map<String,String> map = new HashMap<String, String>(); map.put("AAA", "X"); map.put("BBB", "YYYYY"); String original = "AAAAAABBBBBB"; String expected = "XXYYYYYYYYYY"; assertThat(Rewriters.replace(map).apply(original)).isEqualTo(expected); }
@Test public void replace_map_same() { String original = "1234567890"; assertThat(Rewriters.replace(Collections.singletonMap("YYY", "TTT")).apply(original)) .isSameAs(original); }
|
### Question:
SqlScript { @NotNull public List<? extends SqlStatement> getStatements() { return Collections.unmodifiableList(Arrays.asList(myStatements)); } SqlScript(@NotNull final String... statements); SqlScript(@NotNull final SqlStatement... statements); SqlScript(@NotNull final SqlScript... scripts); SqlScript(@NotNull final Collection<? extends SqlStatement> statements); private SqlScript(@NotNull final SqlStatement[] statements, boolean copy); @NotNull List<? extends SqlStatement> getStatements(); boolean hasStatements(); int count(); @Override @NotNull String toString(); }### Answer:
@Test public void construct_2() { SqlScript script1 = new SqlScript("command1"), script2 = new SqlScript("command2"); SqlScript script = new SqlScript(script1, script2); assertThat((Integer)script.getStatements().size()).isEqualTo((Integer)2); assertThat(script.getStatements().get(0).getSourceText()).isEqualTo("command1"); assertThat(script.getStatements().get(1).getSourceText()).isEqualTo("command2"); }
|
### Question:
SqlScript { @Override @NotNull public String toString() { switch (myCount) { case 0: return ""; case 1: return myStatements[0].getSourceText(); default: final StringBuilder b = new StringBuilder(); final String delimiterString = getScriptDelimiterString(); b.append(myStatements[0].getSourceText()); for (int i = 1; i < myCount; i++) { if (b.charAt(b.length()-1) != '\n') b.append('\n'); b.append(delimiterString).append('\n'); b.append(myStatements[i].getSourceText()); } return b.toString(); } } SqlScript(@NotNull final String... statements); SqlScript(@NotNull final SqlStatement... statements); SqlScript(@NotNull final SqlScript... scripts); SqlScript(@NotNull final Collection<? extends SqlStatement> statements); private SqlScript(@NotNull final SqlStatement[] statements, boolean copy); @NotNull List<? extends SqlStatement> getStatements(); boolean hasStatements(); int count(); @Override @NotNull String toString(); }### Answer:
@Test public void toString_contains_all_commands() { SqlScript script = new SqlScript("command 1", "command 2"); final String text = script.toString(); assertThat(text).contains("command 1") .contains("command 2"); }
|
### Question:
SqlCommand extends SqlStatement { @NotNull @Override public SqlCommand rewrite(@NotNull final StringOperator operator) { String transformedSourceTex = operator.apply(mySourceText); return new SqlCommand(myRow, transformedSourceTex, myName, myDescription); } SqlCommand(@NotNull final TextFragment sourceFragment); SqlCommand(@NotNull final String sourceText, final int row, @Nullable final String commandName); SqlCommand(@NotNull final String sourceText); private SqlCommand(final int row,
@NotNull final String sourceText,
@Nullable final String name,
@NotNull final String description); @NotNull @Override SqlCommand rewrite(@NotNull final StringOperator operator); }### Answer:
@Test public void rewrite_basic() { SqlCommand cmd1 = new SqlCommand("AAA BBB CCC", 33, "name"); SqlCommand cmd2 = cmd1.rewrite(Rewriters.replace("BBB", "XXX")); assertThat(cmd2.getSourceText()).isEqualTo("AAA XXX CCC"); assertThat(cmd2.getRow()).isEqualTo(33); assertThat(cmd2.getName()).isEqualTo("name"); }
|
### Question:
BaseRdbmsProvider implements DBRdbmsProvider { @NotNull @Override public BaseFacade openFacade(@NotNull final String connectionString, @Nullable final Properties connectionProperties, final int connectionsLimit, final boolean connect) { boolean ok = false; final IntegralIntermediateFacade intermediateFacade = myIntermediateProvider.openFacade(connectionString, connectionProperties, connectionsLimit); try { final BaseFacade facade = new BaseFacade(intermediateFacade); if (connect) { facade.connect(); } ok = true; return facade; } finally { if (!ok) { intermediateFacade.disconnect(); } } } BaseRdbmsProvider(@NotNull final PrimeIntermediateRdbmsProvider primeIntermediateProvider); BaseRdbmsProvider(@NotNull final IntegralIntermediateRdbmsProvider integralIntermediateProvider); @NotNull @Override Rdbms rdbms(); @NotNull @Override Pattern connectionStringPattern(); @NotNull @Override BaseFacade openFacade(@NotNull final String connectionString,
@Nullable final Properties connectionProperties,
final int connectionsLimit,
final boolean connect); @Nullable @Override I getSpecificService(@NotNull final Class<I> serviceClass,
@NotNull final String serviceName); }### Answer:
@Test public void connect_directly() { final BaseRdbmsProvider provider = new BaseRdbmsProvider(ourUnknownDatabaseProvider); final BaseFacade facade = provider.openFacade(H2_CONNECTION_STRING, null, 1, true); assertThat(facade.isConnected()).isTrue(); facade.disconnect(); assertThat(facade.isConnected()).isFalse(); }
@Test public void connect_remotely() { final BaseRdbmsProvider provider = new BaseRdbmsProvider(ourUnknownDatabaseProvider); final BaseFacade facade = provider.openFacade(H2_CONNECTION_STRING, null, 1, true); assertThat(facade.isConnected()).isTrue(); facade.disconnect(); assertThat(facade.isConnected()).isFalse(); }
|
### Question:
BaseRdbmsProvider implements DBRdbmsProvider { @Nullable @Override public <I> I getSpecificService(@NotNull final Class<I> serviceClass, @NotNull final String serviceName) throws ClassCastException { return myIntermediateProvider.getSpecificService(serviceClass, serviceName); } BaseRdbmsProvider(@NotNull final PrimeIntermediateRdbmsProvider primeIntermediateProvider); BaseRdbmsProvider(@NotNull final IntegralIntermediateRdbmsProvider integralIntermediateProvider); @NotNull @Override Rdbms rdbms(); @NotNull @Override Pattern connectionStringPattern(); @NotNull @Override BaseFacade openFacade(@NotNull final String connectionString,
@Nullable final Properties connectionProperties,
final int connectionsLimit,
final boolean connect); @Nullable @Override I getSpecificService(@NotNull final Class<I> serviceClass,
@NotNull final String serviceName); }### Answer:
@Test public void get_intermediate_service() { final BaseRdbmsProvider provider = new BaseRdbmsProvider(ourUnknownDatabaseProvider); final IntegralIntermediateRdbmsProvider intermediateRdbmsProvider = provider.getSpecificService( IntegralIntermediateRdbmsProvider.class, ImplementationAccessibleService.Names.INTERMEDIATE_SERVICE); assertThat(intermediateRdbmsProvider).isSameAs(ourUnknownDatabaseProvider); }
|
### Question:
BaseFacade implements DBFacade { @Override public synchronized DBLeasedSession leaseSession() { final IntegralIntermediateSession interSession = instantiateIntermediateSession(); final BaseSession baseSession = new BaseSession(interSession); return new DBLeasedSessionWrapper(baseSession); } BaseFacade(@NotNull final IntegralIntermediateFacade interFacade); @NotNull @Override Rdbms rdbms(); @Override synchronized void connect(); @Override synchronized void reconnect(); @Override synchronized void disconnect(); @Override boolean isConnected(); @Override ConnectionInfo getConnectionInfo(); @Override R inTransaction(final InTransaction<R> operation); @Override void inTransaction(final InTransactionNoResult operation); @Override R inSession(final InSession<R> operation); @Override void inSession(final InSessionNoResult operation); @Override synchronized DBLeasedSession leaseSession(); @Nullable @Override I getSpecificService(@NotNull final Class<I> serviceClass,
@NotNull final String serviceName); }### Answer:
@Test public void leaseSession_basic() { final DBLeasedSession session = myFacade.leaseSession(); assertThat(session.isClosed()).isFalse(); session.ping(); session.close(); assertThat(session.isClosed()).isTrue(); }
|
### Question:
BaseFacade implements DBFacade { @Nullable @Override public <I> I getSpecificService(@NotNull final Class<I> serviceClass, @NotNull final String serviceName) throws ClassCastException { return myInterFacade.getSpecificService(serviceClass, serviceName); } BaseFacade(@NotNull final IntegralIntermediateFacade interFacade); @NotNull @Override Rdbms rdbms(); @Override synchronized void connect(); @Override synchronized void reconnect(); @Override synchronized void disconnect(); @Override boolean isConnected(); @Override ConnectionInfo getConnectionInfo(); @Override R inTransaction(final InTransaction<R> operation); @Override void inTransaction(final InTransactionNoResult operation); @Override R inSession(final InSession<R> operation); @Override void inSession(final InSessionNoResult operation); @Override synchronized DBLeasedSession leaseSession(); @Nullable @Override I getSpecificService(@NotNull final Class<I> serviceClass,
@NotNull final String serviceName); }### Answer:
@Test public void get_intermediate_service() { IntegralIntermediateFacade intermediateSession = myFacade.getSpecificService( IntegralIntermediateFacade.class, ImplementationAccessibleService.Names.INTERMEDIATE_SERVICE); assertThat(intermediateSession).isInstanceOf(JdbcIntermediateFacade.class); }
|
### Question:
BaseScriptRunner implements DBScriptRunner { @Override public DBScriptRunner run() { List<? extends SqlStatement> statements = myScript.getStatements(); for (SqlStatement statement : statements) { if (statement instanceof SqlCommand) { runCommand((SqlCommand)statement); } if (statement instanceof SqlQuery) { runQuery((SqlQuery) statement); } } return this; } BaseScriptRunner(@NotNull final DBTransaction transaction,
@NotNull final SqlScript script); @Override DBScriptRunner run(); }### Answer:
@Test public void basic_2() { final SqlScript script = new SqlScript("create table TT2(X1 integer)", "drop table TT2"); myFacade.inSession(new InSessionNoResult() { @Override public void run(@NotNull final DBSession session) { session.script(script).run(); } }); }
@Test public void basic_4() { final SqlScript script = new SqlScript("create table TT4(X1 integer)", "insert into TT4 values (44)", "select * from TT4", "drop table TT4"); myFacade.inSession(new InSessionNoResult() { @Override public void run(@NotNull final DBSession session) { session.script(script).run(); } }); }
@Test public void basic_4_with_query() { final SqlScript script = new SqlScript(new SqlCommand("create table TT4a(X1 integer)"), new SqlCommand("insert into TT4a values (44)"), new SqlQuery<Boolean>("select * from TT4a", Layouts.existence()), new SqlCommand("drop table TT4a")); myFacade.inSession(new InSessionNoResult() { @Override public void run(@NotNull final DBSession session) { session.script(script).run(); } }); }
|
### Question:
Rdbms implements Serializable { public static Rdbms of(@NotNull final String code) { String theCode = code.intern(); Rdbms newRdbms = new Rdbms(theCode); Rdbms oldRdbms = RdbmsMarkersCache.cache.putIfAbsent(theCode, newRdbms); return notNull(oldRdbms, newRdbms); } private Rdbms(@NotNull final String code); static Rdbms of(@NotNull final String code); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @NotNull
final String code; }### Answer:
@SuppressWarnings("RedundantStringConstructorCall") @Test public void dedulplicate_on_create() { String str1 = new String("FantasticDB"); String str2 = new String("FantasticDB"); assertThat(str2).isNotSameAs(str1); Rdbms rdbms1 = Rdbms.of(str1); Rdbms rdbms2 = Rdbms.of(str2); assertThat(rdbms2).isSameAs(rdbms1); }
@Test public void serialization() throws IOException, ClassNotFoundException { JustAClass c1 = new JustAClass(Rdbms.of("MicroDB")); ByteArrayOutputStream os = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(os); oos.writeObject(c1); ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray()); ObjectInputStream ois = new ObjectInputStream(is); Object gotObject = ois.readObject(); assertThat(gotObject).isInstanceOf(JustAClass.class); JustAClass c2 = (JustAClass) gotObject; assertThat(c2.rdbms).isSameAs(c1.rdbms); }
|
### Question:
JdbcSessions extends DBSessions { @NotNull public static DBLeasedSession wrap(@NotNull final Connection connection, @NotNull final JdbcIntermediateRdbmsProvider rdbmsProvider, final boolean takeOwnership) { final JdbcIntermediateSession intermediateSession = rdbmsProvider.wrapConnection(connection, takeOwnership); return wrap(intermediateSession); } @NotNull static DBLeasedSession wrap(@NotNull final Connection connection,
@NotNull final JdbcIntermediateRdbmsProvider rdbmsProvider,
final boolean takeOwnership); @NotNull static DBLeasedSession wrap(@NotNull final Connection connection,
@NotNull final JdbcIntermediateFederatedProvider federatedProvider,
@NotNull final Rdbms rdbms,
final boolean takeOwnership); }### Answer:
@Test public void wrap_connection_not_own() throws SQLException { final Connection connection = obtainConnection(); assertThat(connection.isClosed()).isFalse(); final DBLeasedSession session = JdbcSessions.wrap(connection, provider, false); assertThat(session.isClosed()).isFalse(); session.close(); assertThat(session.isClosed()).isTrue(); assertThat(connection.isClosed()).isFalse(); connection.close(); assertThat(connection.isClosed()).isTrue(); }
@Test public void wrap_connection_ownership() throws SQLException { final Connection connection = obtainConnection(); assertThat(connection.isClosed()).isFalse(); final DBLeasedSession session = JdbcSessions.wrap(connection, provider, true); assertThat(session.isClosed()).isFalse(); session.close(); assertThat(session.isClosed()).isTrue(); assertThat(connection.isClosed()).isTrue(); }
|
### Question:
JdbcIntermediateFederatedProvider implements IntegralIntermediateFederatedProvider { @Nullable @Override public IntegralIntermediateRdbmsProvider getSpecificServiceProvider(@NotNull final Rdbms rdbms) { final SpecificProvider sp = myBestProviders.get(rdbms); return sp != null ? sp.provider : null; } JdbcIntermediateFederatedProvider(); void registerProvider(@NotNull final IntegralIntermediateRdbmsProvider provider); void deregisterProvider(@NotNull final PrimeIntermediateRdbmsProvider provider); @NotNull @Override Set<Rdbms> supportedRdbms(); @NotNull @Override IntegralIntermediateFacade openFacade(@NotNull final String connectionString,
@Nullable final Properties connectionProperties,
final int connectionsLimit); @Nullable @Override IntegralIntermediateRdbmsProvider getSpecificServiceProvider(@NotNull final Rdbms rdbms); }### Answer:
@Test public void the_UnknownDatabaseServiceProvider_is_registered() { PrimeIntermediateRdbmsProvider provider = myFederatedProvider.getSpecificServiceProvider(UnknownDatabase.RDBMS); assertThat(provider).isNotNull() .isInstanceOf(UnknownDatabaseProvider.class); }
|
### Question:
JdbcIntermediateFederatedProvider implements IntegralIntermediateFederatedProvider { @NotNull @Override public IntegralIntermediateFacade openFacade(@NotNull final String connectionString, @Nullable final Properties connectionProperties, final int connectionsLimit) { IntegralIntermediateRdbmsProvider provider = findTheBestFor(connectionString); return provider.openFacade(connectionString, connectionProperties, connectionsLimit); } JdbcIntermediateFederatedProvider(); void registerProvider(@NotNull final IntegralIntermediateRdbmsProvider provider); void deregisterProvider(@NotNull final PrimeIntermediateRdbmsProvider provider); @NotNull @Override Set<Rdbms> supportedRdbms(); @NotNull @Override IntegralIntermediateFacade openFacade(@NotNull final String connectionString,
@Nullable final Properties connectionProperties,
final int connectionsLimit); @Nullable @Override IntegralIntermediateRdbmsProvider getSpecificServiceProvider(@NotNull final Rdbms rdbms); }### Answer:
@Test public void the_UnknownDatabaseServiceProvider_is_accepted_by_connectionString() { myFederatedProvider.openFacade(UnknownDatabaseProviderTest.H2_CONNECTION_STRING, null, 1); }
|
### Question:
UnknownDatabaseProvider extends JdbcIntermediateRdbmsProvider { @NotNull @Override public Pattern connectionStringPattern() { return CONNECTION_STRING_PATTERN; } @NotNull @Override Rdbms rdbms(); @NotNull @Override Pattern connectionStringPattern(); @Override byte specificity(); @NotNull @Override BaseExceptionRecognizer getExceptionRecognizer(); }### Answer:
@Test public void accepts_connectionString_H2() { PatternAssert.assertThat(myProvider.connectionStringPattern()).fits(H2_CONNECTION_STRING); }
|
### Question:
AdaptIntermediateRdbmsProvider implements IntegralIntermediateRdbmsProvider { @NotNull @Override public DBExceptionRecognizer getExceptionRecognizer() { Class<? extends DBExceptionRecognizer> erClass = myRemoteProvider.getExceptionRecognizerClass(); try { Field instanceField = erClass.getDeclaredField("INSTANCE"); if (instanceField != null && Modifier.isStatic(instanceField.getModifiers())) { return (DBExceptionRecognizer) instanceField.get(null); } return erClass.newInstance(); } catch (Exception e) { e.printStackTrace(); } throw new IllegalStateException("Unknown how to get an instance of class "+erClass.getName()); } AdaptIntermediateRdbmsProvider(@NotNull final PrimeIntermediateRdbmsProvider remoteProvider); @NotNull @Override Rdbms rdbms(); @NotNull @Override Pattern connectionStringPattern(); @Override byte specificity(); @NotNull @Override IntegralIntermediateFacade openFacade(@NotNull final String connectionString,
@Nullable final Properties connectionProperties,
final int connectionsLimit); @NotNull @Override Class<? extends DBExceptionRecognizer> getExceptionRecognizerClass(); @NotNull @Override DBExceptionRecognizer getExceptionRecognizer(); @Nullable @Override I getSpecificService(@NotNull final Class<I> serviceClass,
@NotNull final String serviceName); }### Answer:
@Test public void getExceptionRecognizer_same() { AdaptIntermediateRdbmsProvider adaptProvider = new AdaptIntermediateRdbmsProvider(ourUnknownDatabaseProvider); assertThat(adaptProvider.getExceptionRecognizer()).isSameAs(ourUnknownDatabaseProvider.getExceptionRecognizer()); }
|
### Question:
Sorting { public static void parallelSort(double[] dValues, int[] iValues) { quickSort(new DoubleIntIndexedSortable(dValues, iValues)); } private Sorting(); static int selectPivotIndex(final int[] indices,
int left,
int right,
final IntComparator comp); static int partitionIndices(
final int[] indices,
final int k0,
final int left0,
final int right0,
final IntComparator comp); static void quickSort(final IndexedSortable sortable); static void quickSort(final IndexedSortable sortable, final int offset, final int len); static void quickSort(final int[] arr, final IntComparator comp); static void quickSort(final int[] arr, final int offset, final int len, final IntComparator comp); static int medianOf3(final int[] a, final int x, final int y, final int z, final IntComparator c); static int medianOf3(IndexedSortable sortable, int x, int y, int z); static void parallelSort(double[] dValues, int[] iValues); }### Answer:
@Test public void testParallelSort() { final int numValues = 1000; double[] dValues = new double[numValues]; int[] iValues = new int[numValues]; Map<Double, Integer> checkMap = new HashMap<Double, Integer>(); Random random = new Random(); for (int i = 0; i < numValues; i++) { double d = random.nextDouble(); dValues[i] = d; iValues[i] = i; checkMap.put(d, i); } double[] dValuesCopy = (double[]) dValues.clone(); Sorting.parallelSort(dValues, iValues); Arrays.sort(dValuesCopy); for (int i = 0; i < numValues; i++) { assertTrue(dValuesCopy[i] == dValues[i]); assertTrue(checkMap.get(dValues[i]).intValue() == iValues[i]); } }
|
### Question:
AbstractTask implements Task<V> { @Override public V get() throws InterruptedException, ExecutionException { while(!hasEnded.get()) { synchronized (this) { wait(); } } return getResultAfterHasEnded(); } @Override void addTaskListener(TaskListener l); @Override void removeTaskListener(TaskListener l); @Override void setProgressEndpoints(double begin, double end); double getBeginProgress(); double getEndProgress(); @Override V get(); @Override V get(long timeout, TimeUnit unit); boolean isPaused(); synchronized void pause(); synchronized void play(); void reset(); final void run(); boolean cancel(boolean mayInterruptIfRunning); @Override /** * This version is mandated by the Future<V> interface. */ boolean isCancelled(); boolean isDone(); String getErrorMessage(); Throwable getError(); double getProgress(); boolean isBegun(); boolean isEnded(); final TaskOutcome getTaskOutcome(); }### Answer:
@Test(expected=TimeoutException.class) public void testGetWithNoStartOfTask() throws InterruptedException, ExecutionException, TimeoutException { AbstractTask<String> instance = new CapitalizeStringTask("a string to capitalize"); String result = instance.get(1L, TimeUnit.MILLISECONDS); }
|
### Question:
ProgressHandler { public void postMessage(final String msg) { if (task != null) { task.postMessage(msg); } } ProgressHandler(AbstractTask<?> t,
double begin,
double end,
int steps); ProgressHandler(AbstractTask<?> t, int steps); ProgressHandler(final AbstractTask<?> task,
final double begin,
final double end); ProgressHandler(AbstractTask<?> t); void setMinProgressIncrement(final double minInc); void setMinTimeIncrement(final long ms); void postMessage(final String msg); void postFraction(final double fraction); void postStep(); void postSteps(final int steps); void postEnd(); void postIndeterminate(); void subsection(final double fraction); void subsection(final double fraction, final int steps); void subsection(final int steps); void subsection(); void postBegin(); double getCurrentProgress(); static final double DEFAULT_START_VALUE; static final double DEFAULT_END_VALUE; static final double DEFAULT_MIN_PROGRESS_INC; static final long DEFAULT_MIN_TIME_INC; }### Answer:
@Test public void testPostMessage() throws InterruptedException { final int steps = 100; TestTask testTask = new TestTask(0.0, 1.0, steps); List<String> messages = new ArrayList<>(); testTask.addTaskListener(new TaskAdapter() { @Override public void taskMessage(TaskEvent evt) { messages.add(evt.getMessage()); } }); Thread t = new Thread(testTask); t.start(); t.join(); assertThat(messages.size(), is(equalTo(steps + 1))); }
|
### Question:
ProgressHandler { public void postFraction(final double fraction) { currentStep.postFraction(fraction); } ProgressHandler(AbstractTask<?> t,
double begin,
double end,
int steps); ProgressHandler(AbstractTask<?> t, int steps); ProgressHandler(final AbstractTask<?> task,
final double begin,
final double end); ProgressHandler(AbstractTask<?> t); void setMinProgressIncrement(final double minInc); void setMinTimeIncrement(final long ms); void postMessage(final String msg); void postFraction(final double fraction); void postStep(); void postSteps(final int steps); void postEnd(); void postIndeterminate(); void subsection(final double fraction); void subsection(final double fraction, final int steps); void subsection(final int steps); void subsection(); void postBegin(); double getCurrentProgress(); static final double DEFAULT_START_VALUE; static final double DEFAULT_END_VALUE; static final double DEFAULT_MIN_PROGRESS_INC; static final long DEFAULT_MIN_TIME_INC; }### Answer:
@Test public void testPostFraction() throws InterruptedException { TestTask testTask = new TestTask(0.0, 1.0, 10); testTask.setPostFractionalProgress(true); final List<Double> progressReceived = new ArrayList<>(); testTask.addTaskListener(new TaskAdapter() { @Override public void taskProgress(TaskEvent evt) { progressReceived.add(evt.getProgress()); } }); Thread t = new Thread(testTask); t.start(); t.join(); assertTrue(progressReceived.size() >= 10); for (int i=1; i<progressReceived.size() - 1; i++) { assertEquals(0.1, progressReceived.get(i) - progressReceived.get(i-1), 1.0e-10); } }
|
### Question:
ProgressHandler { public void postIndeterminate() { postValue(-1.0); } ProgressHandler(AbstractTask<?> t,
double begin,
double end,
int steps); ProgressHandler(AbstractTask<?> t, int steps); ProgressHandler(final AbstractTask<?> task,
final double begin,
final double end); ProgressHandler(AbstractTask<?> t); void setMinProgressIncrement(final double minInc); void setMinTimeIncrement(final long ms); void postMessage(final String msg); void postFraction(final double fraction); void postStep(); void postSteps(final int steps); void postEnd(); void postIndeterminate(); void subsection(final double fraction); void subsection(final double fraction, final int steps); void subsection(final int steps); void subsection(); void postBegin(); double getCurrentProgress(); static final double DEFAULT_START_VALUE; static final double DEFAULT_END_VALUE; static final double DEFAULT_MIN_PROGRESS_INC; static final long DEFAULT_MIN_TIME_INC; }### Answer:
@Test public void testPostIndeterminate() throws InterruptedException { final int loops = 10; Task<Void> task = new AbstractTask<Void> () { @Override protected Void doTask() throws Exception { ProgressHandler ph = new ProgressHandler(this, 0.0, 1.0); ph.postBegin(); for (int i=0; i<loops; i++) { ph.postIndeterminate(); } ph.postEnd(); return null; } @Override public String taskName() { return "testPostIndeterminate() task"; } }; final AtomicInteger numIndeterminates = new AtomicInteger(); task.addTaskListener(new TaskAdapter() { @Override public void taskProgress(TaskEvent evt) { if (evt.getProgress() == -1.0) { numIndeterminates.incrementAndGet(); } } }); Thread t = new Thread(task); t.start(); t.join(); assertThat(numIndeterminates.get(), is(equalTo(1))); }
|
### Question:
AbstractTask implements Task<V> { @Override public void addTaskListener(TaskListener l) { eventSupport.addTaskListener(l); } @Override void addTaskListener(TaskListener l); @Override void removeTaskListener(TaskListener l); @Override void setProgressEndpoints(double begin, double end); double getBeginProgress(); double getEndProgress(); @Override V get(); @Override V get(long timeout, TimeUnit unit); boolean isPaused(); synchronized void pause(); synchronized void play(); void reset(); final void run(); boolean cancel(boolean mayInterruptIfRunning); @Override /** * This version is mandated by the Future<V> interface. */ boolean isCancelled(); boolean isDone(); String getErrorMessage(); Throwable getError(); double getProgress(); boolean isBegun(); boolean isEnded(); final TaskOutcome getTaskOutcome(); }### Answer:
@Test public void testAddTaskListener() throws InterruptedException, ExecutionException { System.out.println("addTaskListener"); TestTaskListener l = new TestTaskListener(); final String s = "a string to capitalize"; AbstractTask<String> instance = new CapitalizeStringTask(s); instance.addTaskListener(l); Thread t = new Thread(instance); t.start(); t.join(); assertThat(l.taskBegunCount(), is(1)); assertThat(l.taskEndedCount(), is(1)); assertThat(instance.get(), is(s.toUpperCase())); }
|
### Question:
AbstractTask implements Task<V> { @Override public void removeTaskListener(TaskListener l) { eventSupport.removeTaskListener(l); } @Override void addTaskListener(TaskListener l); @Override void removeTaskListener(TaskListener l); @Override void setProgressEndpoints(double begin, double end); double getBeginProgress(); double getEndProgress(); @Override V get(); @Override V get(long timeout, TimeUnit unit); boolean isPaused(); synchronized void pause(); synchronized void play(); void reset(); final void run(); boolean cancel(boolean mayInterruptIfRunning); @Override /** * This version is mandated by the Future<V> interface. */ boolean isCancelled(); boolean isDone(); String getErrorMessage(); Throwable getError(); double getProgress(); boolean isBegun(); boolean isEnded(); final TaskOutcome getTaskOutcome(); }### Answer:
@Test public void testRemoveTaskListener() throws InterruptedException { System.out.println("removeTaskListener"); TestTaskListener l = new TestTaskListener(); AbstractTask instance = new CapitalizeStringTask("a string to capitalize"); instance.addTaskListener(l); instance.removeTaskListener(l); Thread t = new Thread(instance); t.start(); t.join(); assertThat(l.taskBegunCount(), is(0)); assertThat(l.taskEndedCount(), is(0)); }
|
### Question:
HostManager { synchronized String getNextHostForRequest() { if (participantHosts.isEmpty()) { return null; } checkNextHostIndex(); String host = participantHosts.get(currentIndex); if (LOG.isDebugEnabled()) { LOG.debug("hosts size: " + participantHosts.size()); } if (LOG.isInfoEnabled()) { LOG.info("Next host retrieved for signing: " + host); } return host; } HostManager(List<String> hosts, boolean useLoadBalancing); }### Answer:
@Test public void test01GetNextHostNoLoadBalancing() throws Exception { List<String> participantHosts = new ArrayList<>(); participantHosts.add("host1"); participantHosts.add("host2"); participantHosts.add("host3"); MockHostManager hostManager = new MockHostManager(participantHosts, false); assertEquals("host1", hostManager.getNextHostForRequest()); assertEquals("host1", hostManager.getNextHostForRequest()); assertEquals("host1", hostManager.getNextHostForRequest()); assertEquals("host1", hostManager.getNextHostForRequest()); assertEquals("host1", hostManager.getNextHostForRequest()); assertEquals("host1", hostManager.getNextHostForRequest()); }
@Test public void test03GetNextHostWithLoadBalancing() throws Exception { List<String> participantHosts = new ArrayList<>(); participantHosts.add("host1"); participantHosts.add("host2"); participantHosts.add("host3"); participantHosts.add("host4"); MockHostManager hostManager = new MockHostManager(participantHosts, true); assertEquals("host2", hostManager.getNextHostForRequest()); assertEquals("host3", hostManager.getNextHostForRequest()); assertEquals("host4", hostManager.getNextHostForRequest()); assertEquals("host1", hostManager.getNextHostForRequest()); assertEquals("host2", hostManager.getNextHostForRequest()); assertEquals("host3", hostManager.getNextHostForRequest()); assertEquals("host4", hostManager.getNextHostForRequest()); }
|
### Question:
PdfVersionCompatibilityChecker { public int getMinimumCompatiblePdfVersion() { switch (signatureDigestAlgorithm) { case PdfSignatureDigestAlgorithms.SHA1: return 0; case PdfSignatureDigestAlgorithms.SHA256: case PdfSignatureDigestAlgorithms.SHA_256: return 6; case PdfSignatureDigestAlgorithms.SHA384: case PdfSignatureDigestAlgorithms.SHA_384: case PdfSignatureDigestAlgorithms.SHA512: case PdfSignatureDigestAlgorithms.SHA_512: case PdfSignatureDigestAlgorithms.RIPEMD160: return 7; default: throw new IllegalArgumentException("Unknown digest algorithm: " + signatureDigestAlgorithm); } } PdfVersionCompatibilityChecker(String pPdfVersionOfDocumentToBeSigned, String pSignatureDigestAlgorithm); int getPdfVersionOfDocumentToBeSigned(); boolean isVersionUpgradeRequired(); int getMinimumCompatiblePdfVersion(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void minimumVersionCannotBeRetrievedForUnknownDigestAlgorithm() { PdfVersionCompatibilityChecker checker = new PdfVersionCompatibilityChecker("0", "HSA 223"); checker.getMinimumCompatiblePdfVersion(); }
@Test public void minimumVersionForSHA1Is0() { PdfVersionCompatibilityChecker checker = new PdfVersionCompatibilityChecker("0", "SHA1"); int minVer = checker.getMinimumCompatiblePdfVersion(); assertEquals(0, minVer); }
@Test public void minimumVersionForSHA256Is6() { PdfVersionCompatibilityChecker checker = new PdfVersionCompatibilityChecker("0", "SHA-256"); int minVer = checker.getMinimumCompatiblePdfVersion(); assertEquals(6, minVer); }
@Test public void minimumVersionForSHA512Is7() { PdfVersionCompatibilityChecker checker = new PdfVersionCompatibilityChecker("0", "SHA512"); int minVer = checker.getMinimumCompatiblePdfVersion(); assertEquals(7, minVer); }
|
### Question:
PdfSignatureDigestAlgorithms { public static boolean isSupported(String digestAlgorithm) { return ALL_SUPPORTED_DIGEST_ALGORITHMS.contains(digestAlgorithm); } private PdfSignatureDigestAlgorithms(); static boolean isSupported(String digestAlgorithm); static final String SHA1; static final String SHA256; static final String SHA_256; static final String SHA384; static final String SHA_384; static final String SHA512; static final String SHA_512; static final String RIPEMD160; static final List<String> ALL_SUPPORTED_DIGEST_ALGORITHMS; }### Answer:
@Test public void shouldNotSupportFictitiousDigestAlgorithm() { boolean supported = PdfSignatureDigestAlgorithms.isSupported("HSA 256"); assertFalse("We support fictitious Digest Algorithms ??", supported); }
|
### Question:
AllowedMechanisms { public byte[] toBinaryEncoding() { final int num = mechs.size(); final ByteBuffer bb = ByteBuffer.allocate(8 * num); bb.order(ByteOrder.LITTLE_ENDIAN); for (long mech : mechs) { bb.putLong(mech); } return bb.array(); } AllowedMechanisms(List<Long> mechs); static AllowedMechanisms parse(final String allowedMechanismsProperty); static AllowedMechanisms fromBinaryEncoding(final byte[] binary); byte[] toBinaryEncoding(); Long[] toLongArray(); String toPropertyValue(); @Override String toString(); }### Answer:
@Test public void testToBinaryEncoding() { LOG.info(">testToBinaryEncoding"); String allowedMechanismsProperty = " 0x00000040, 0x00000000, 0x00000250, 0x252, 624, 0x81234567"; AllowedMechanisms instance = AllowedMechanisms.parse(allowedMechanismsProperty); final String expected = "4000000000000000" + "0000000000000000" + "5002000000000000" + "5202000000000000" + "7002000000000000" + "6745238100000000"; assertEquals(expected, Hex.toHexString(instance.toBinaryEncoding())); }
|
### Question:
AllowedMechanisms { public static AllowedMechanisms fromBinaryEncoding(final byte[] binary) throws IllegalArgumentException { final ArrayList<Long> mechs = new ArrayList<>(); try { final LongBuffer lb = ByteBuffer.wrap(binary).order(ByteOrder.LITTLE_ENDIAN).asLongBuffer(); while (lb.hasRemaining()) { mechs.add(lb.get()); } } catch (BufferUnderflowException ex) { throw new IllegalArgumentException("Unable to parse allowed mechanisms value: " + ex.getMessage()); } return new AllowedMechanisms(mechs); } AllowedMechanisms(List<Long> mechs); static AllowedMechanisms parse(final String allowedMechanismsProperty); static AllowedMechanisms fromBinaryEncoding(final byte[] binary); byte[] toBinaryEncoding(); Long[] toLongArray(); String toPropertyValue(); @Override String toString(); }### Answer:
@Test public void testFromBinaryEncoding() { LOG.info(">testFromBinaryEncoding"); final Long[] expected = new Long[] { 0x00000040l, 0x00000000l, 0x00000250l, 0x252l, 624l, 0x81234567l }; final String binary = "4000000000000000" + "0000000000000000" + "5002000000000000" + "5202000000000000" + "7002000000000000" + "6745238100000000"; assertArrayEquals(expected, AllowedMechanisms.fromBinaryEncoding(Hex.decode(binary)).toLongArray()); }
|
### Question:
AllowedMechanisms { @Override public String toString() { return "AllowedMechanisms{" + toPropertyValue() + "}"; } AllowedMechanisms(List<Long> mechs); static AllowedMechanisms parse(final String allowedMechanismsProperty); static AllowedMechanisms fromBinaryEncoding(final byte[] binary); byte[] toBinaryEncoding(); Long[] toLongArray(); String toPropertyValue(); @Override String toString(); }### Answer:
@Test public void testToString() { LOG.info(">testToString"); String allowedMechanismsProperty = " 0x00000040, 0x00000000 0x00000250;0x252 ,624 0x81234567"; String expected = "AllowedMechanisms{CKM_SHA256_RSA_PKCS, CKM_RSA_PKCS_KEY_PAIR_GEN, CKM_SHA256, CKM_SHA256_HMAC_GENERAL, CKM_SHA512, 0x81234567}"; AllowedMechanisms result = AllowedMechanisms.parse(allowedMechanismsProperty); assertEquals(expected, result.toString()); }
|
### Question:
AttributeProperties { public Properties toWorkerProperties() { Properties properties = new Properties(); fill(properties, OBJECT_PRIVATE, privateTemplateMap); fill(properties, OBJECT_PUBLIC, publicTemplateMap); return properties; } AttributeProperties(Map<String, List<Attribute>> publicTemplate, Map<String, List<Attribute>> privateTemplate); static AttributeProperties fromWorkerProperties(Properties properties); List<Attribute> getPublicTemplate(final String keyType); List<Attribute> getPrivateTemplate(final String keyType); Properties toWorkerProperties(); @Override String toString(); }### Answer:
@Test public void testToWorkerProperties() { LOG.info(">testToWorkerProperties"); Properties properties = new Properties(); properties.setProperty("ATTRIBUTE.PRIVATE.RSA.CKA_VERIFY", "True"); properties.setProperty("OTHER", "true"); properties.setProperty("ATTRIBUTE.PRIVATE.RSA.CKA_ALLOWED_MECHANISMS", "SHA256_RSA_PKCS, RSA_PKCS_KEY_PAIR_GEN"); properties.setProperty("ATTRIBUTES", "Attributes value"); properties.setProperty("ATTRIBUTE.PRIVATE.ECDSA.0x162", "false"); properties.setProperty("ATTRIBUTE", "Attribute value"); Properties actual = AttributeProperties.fromWorkerProperties(properties).toWorkerProperties(); assertEquals("ATTRIBUTE.PRIVATE.RSA.CKA_VERIFY", "true", actual.get("ATTRIBUTE.PRIVATE.RSA.CKA_VERIFY")); assertEquals("ATTRIBUTE.PRIVATE.RSA.CKA_ALLOWED_MECHANISMS", "CKM_SHA256_RSA_PKCS, CKM_RSA_PKCS_KEY_PAIR_GEN", actual.get("ATTRIBUTE.PRIVATE.RSA.CKA_ALLOWED_MECHANISMS")); assertEquals("ATTRIBUTE.PRIVATE.ECDSA.CKA_EXTRACTABLE", "false", actual.get("ATTRIBUTE.PRIVATE.ECDSA.CKA_EXTRACTABLE")); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.