auphong2707/dl4se-code-review-dataset huggingface dataset:
Source:
public boolean persistNowSafely(boolean alreadyHasMutex) { Stopwatch timer = Stopwatch.createStarted(); try { persistNowInternal(alreadyHasMutex); metrics.noteSuccess(Duration.of(timer)); return true; } catch (RuntimeInterruptedException e) { LOG.debug("Interrupted persisting change-delta (rethrowing)", e); metrics.noteFailure(Duration.of(timer)); metrics.noteError(e.toString()); Thread.currentThread().interrupt(); return false; } catch (Exception e) { LOG.error("Problem persisting change-delta", e); metrics.noteFailure(Duration.of(timer)); metrics.noteError(e.toString()); return false; } catch (Throwable t) { LOG.warn("Problem persisting change-delta (rethrowing)", t); metrics.noteFailure(Duration.of(timer)); metrics.noteError(t.toString()); throw Exceptions.propagate(t); } }

Target:
private boolean persistNowSafely(boolean alreadyHasMutex) { Stopwatch timer = Stopwatch.createStarted(); try { persistNowInternal(alreadyHasMutex); metrics.noteSuccess(Duration.of(timer)); return true; } catch (RuntimeInterruptedException e) { LOG.debug("Interrupted persisting change-delta (rethrowing)", e); metrics.noteFailure(Duration.of(timer)); metrics.noteError(e.toString()); Thread.currentThread().interrupt(); return false; } catch (Exception e) { LOG.error("Problem persisting change-delta", e); metrics.noteFailure(Duration.of(timer)); metrics.noteError(e.toString()); return false; } catch (Throwable t) { LOG.warn("Problem persisting change-delta (rethrowing)", t); metrics.noteFailure(Duration.of(timer)); metrics.noteError(t.toString()); throw Exceptions.propagate(t); } }
Source:
public AllKnownEEsResolutionHints() { additionalUnits = new LinkedHashMap<VersionedId, IInstallableUnit>(); for (String env : getAllKnownExecutionEnvironments()) { StandardEEResolutionHints.addIUsFromEnvironment(env, additionalUnits); } this.temporaryUnits = StandardEEResolutionHints.computeTemporaryAdditions(additionalUnits); }

Target:
public AllKnownEEsResolutionHints() { temporaryUnits = new LinkedHashMap<VersionedId, IInstallableUnit>(); for (String env : getAllKnownExecutionEnvironments()) { StandardEEResolutionHints.addIUsFromEnvironment(env, temporaryUnits); } }
Source:
public boolean containsValue(Object value) { Objects.nonNull(value); return values().stream().filter(value::equals).findFirst().isPresent(); }

Target:
public boolean containsValue(Object value) { Objects.nonNull(value); return values().stream().anyMatch(StreamMarshalling.equalityPredicate(value)); }
Source:
private void planDistribution(PlanRoot plan) { CloseableSplitSourceProvider splitSourceProvider = new CloseableSplitSourceProvider(splitManager::getSplits); stateMachine.addStateChangeListener(state -> { if (state.isDone()) { splitSourceProvider.close(); } }); if (stateMachine.isDone()) { return; } SubPlan outputStagePlan = plan.getRoot(); stateMachine.setColumns(((OutputNode) outputStagePlan.getFragment().getRoot()).getColumnNames(), outputStagePlan.getFragment().getTypes()); SplitSourceFactory splitSourceFactory = new SplitSourceFactory(splitSourceProvider); SqlQueryScheduler scheduler = createSqlQueryScheduler( locationFactory, executionPolicy, queryExecutor, schedulerStats, sectionStageExecutionFactory, remoteTaskFactory, splitSourceFactory, stateMachine.getSession(), stateMachine, outputStagePlan, plan.isSummarizeTaskInfos()); queryScheduler.set(scheduler); if (stateMachine.isDone()) { scheduler.abort(); queryScheduler.set(null); } }

Target:
private void planDistribution(PlanRoot plan) { CloseableSplitSourceProvider splitSourceProvider = new CloseableSplitSourceProvider(splitManager::getSplits); stateMachine.addStateChangeListener(state -> { if (state.isDone()) { splitSourceProvider.close(); } }); if (stateMachine.isDone()) { return; } SubPlan outputStagePlan = plan.getRoot(); stateMachine.setColumns(((OutputNode) outputStagePlan.getFragment().getRoot()).getColumnNames(), outputStagePlan.getFragment().getTypes()); PartitioningHandle partitioningHandle = outputStagePlan.getFragment().getPartitioningScheme().getPartitioning().getHandle(); OutputBuffers rootOutputBuffers = createInitialEmptyOutputBuffers(partitioningHandle) .withBuffer(OUTPUT_BUFFER_ID, BROADCAST_PARTITION_ID) .withNoMoreBufferIds(); SplitSourceFactory splitSourceFactory = new SplitSourceFactory(splitSourceProvider); SqlQuerySchedulerInterface scheduler = isUseLegacyScheduler(getSession()) ? LegacySqlQueryScheduler.createSqlQueryScheduler( locationFactory, executionPolicy, queryExecutor, schedulerStats, sectionExecutionFactory, remoteTaskFactory, splitSourceFactory, stateMachine.getSession(), stateMachine, outputStagePlan, rootOutputBuffers, plan.isSummarizeTaskInfos()) : SqlQueryScheduler.createSqlQueryScheduler( locationFactory, executionPolicy, queryExecutor, schedulerStats, sectionExecutionFactory, remoteTaskFactory, splitSourceFactory, internalNodeManager, stateMachine.getSession(), stateMachine, outputStagePlan, plan.isSummarizeTaskInfos()); queryScheduler.set(scheduler); if (stateMachine.isDone()) { scheduler.abort(); queryScheduler.set(null); } }
Source:
public ResponseEntity<List<String>> syncRepository(String repositoryUrl) { boolean validRequest = repositoryUrl != null && !StringUtils.isEmpty(repositoryUrl); if (validRequest) { String oldUrl = configurationService.getModelRepositoryUrl(); configurationService.setModelRepositoryUrl(repositoryUrl); try { sourceCodeManager.updateRepository(); List<String> versions = sourceCodeManager.getAvailableVersions(); if (!repositoryUrl.equals(oldUrl)) { configurationService.setModelRepositoryVersion(""); } return new ResponseEntity<List<String>>(versions, HttpStatus.OK); } catch (Exception e) { configurationService.setModelRepositoryUrl(oldUrl); } } return new ResponseEntity<List<String>>(HttpStatus.BAD_REQUEST); }

Target:
public ResponseEntity<List<String>> syncRepository(String repositoryUrl) { boolean validRequest = !StringUtils.isEmpty(repositoryUrl); if (validRequest) { String oldUrl = configurationService.getModelRepositoryUrl(); configurationService.setModelRepositoryUrl(repositoryUrl); try { sourceCodeManager.updateRepository(); List<String> versions = sourceCodeManager.getAvailableVersions(); if (!repositoryUrl.equals(oldUrl)) { configurationService.setModelRepositoryVersion(""); } return new ResponseEntity<List<String>>(versions, HttpStatus.OK); } catch (Exception e) { configurationService.setModelRepositoryUrl(oldUrl); } } return new ResponseEntity<List<String>>(HttpStatus.BAD_REQUEST); }
Source:
public void finish() throws IOException, SQLException { super.finish(); executorService.shutdown(); try { executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS); } catch (InterruptedException e) { throw new RuntimeException(e); } logger.info("Loaded files.", fileCount); }

Target:
public void finish() throws IOException, SQLException { super.finish(); for (Future<Void> uploadAndCopyFuture : uploadAndCopyFutures) { try { uploadAndCopyFuture.get(); } catch (InterruptedException e) { throw new RuntimeException(e); } catch (ExecutionException e) { if (e.getCause() instanceof SQLException) { throw (SQLException)e.getCause(); } throw new RuntimeException(e); } } logger.info("Loaded files.", fileCount); }
Source:
public void test_BorderedEdgeAndContainer() { createBorderedEdgeAndValidateAnchors("Container", "A", AbstractDiagramContainerEditPart.class, "B", AbstractDiagramContainerEditPart.class); }

Target:
public void test_BorderedEdgeAndContainer() { changeDiagramPreference(SiriusDiagramCorePreferences.PREF_ENABLE_OVERRIDE, true); changeDiagramPreference(SiriusDiagramCorePreferences.PREF_LINE_STYLE, EdgeRouting.MANHATTAN); createBorderedEdgeAndValidateAnchors("Container", "A", AbstractDiagramContainerEditPart.class, "B", AbstractDiagramContainerEditPart.class); resetDiagramPreference(SiriusDiagramCorePreferences.PREF_ENABLE_OVERRIDE); }
Source:
protected boolean isBonitaGroovyBasedValidator(final Instance validator) { final String className = validator.get("validatorClass"); final boolean isBonitaGroovyBasedValidator = className != null && (className.contains("GroovyPageValidator") || className.contains("GroovyFieldValidator")); return isBonitaGroovyBasedValidator; }

Target:
protected boolean isBonitaGroovyBasedValidator(final Instance validator) { final String className = validator.get("validatorClass"); return className != null && (className.contains("GroovyPageValidator") || className.contains("GroovyFieldValidator")); }
Source:
public String toString() { switch (status) { case ADDED: return "(" + name + " " + type + " +" + current + ")"; case MATCHED: return "(" + name + " " + type + " " + current + " " + baseline + ")"; case DELETED: return "(" + name + " " + type + " -" + baseline + ")"; } return "???"; }

Target:
public String toString() { switch (status) { case ADDED: return "(" + name + " " + type + " +" + current + ")"; case MATCHED: return "(" + name + " " + type + " " + current + " " + baseline + ")"; case DELETED: return "(" + name + " " + type + " -" + baseline + ")"; default: throw new AssertionError("unsupported enum member"); } }
Source:
void createTransactionAndRollbackMessagesTest(MessagingEntityType entityType) { setSenderAndReceiver(entityType, 0, isSessionEnabled); final String messageId = "createTransactionAndRollbackMessagesTest";UUID.randomUUID().toString(); final ServiceBusMessage message = getMessage(messageId, isSessionEnabled); sendMessage(message).block(OPERATION_TIMEOUT); AtomicReference<ServiceBusTransactionContext> transaction = new AtomicReference<>(); StepVerifier.create(receiver.createTransaction()) .assertNext(txn -> { transaction.set(txn); assertNotNull(transaction); }) .verifyComplete(); final ServiceBusReceivedMessageContext receivedContext = receiver.receive().next().block(OPERATION_TIMEOUT); assertNotNull(receivedContext); final ServiceBusReceivedMessage receivedMessage = receivedContext.getMessage(); assertNotNull(receivedMessage); StepVerifier.create(receiver.complete(receivedMessage, transaction.get())) .verifyComplete(); StepVerifier.create(receiver.rollbackTransaction(transaction.get())) .verifyComplete(); }

Target:
void createTransactionAndRollbackMessagesTest(MessagingEntityType entityType) { setSenderAndReceiver(entityType, 0, isSessionEnabled); final String messageId = UUID.randomUUID().toString(); final ServiceBusMessage message = getMessage(messageId, isSessionEnabled); sendMessage(message).block(OPERATION_TIMEOUT); AtomicReference<ServiceBusTransactionContext> transaction = new AtomicReference<>(); StepVerifier.create(receiver.createTransaction()) .assertNext(txn -> { transaction.set(txn); assertNotNull(transaction); }) .verifyComplete(); final ServiceBusReceivedMessageContext receivedContext = receiver.receive().next().block(OPERATION_TIMEOUT); assertNotNull(receivedContext); final ServiceBusReceivedMessage receivedMessage = receivedContext.getMessage(); assertNotNull(receivedMessage); StepVerifier.create(receiver.complete(receivedMessage, transaction.get())) .verifyComplete(); StepVerifier.create(receiver.rollbackTransaction(transaction.get())) .verifyComplete(); }
Source:
public void toStream(@NonNull JsonStream writer) throws IOException { writer.beginArray(); if (cachedThreads != null) { for (CachedThread thread : cachedThreads) { writer.value(thread); } } else { for (Thread thread : threads) { writer.beginObject(); writer.name("id").value(thread.getId()); writer.name("name").value(thread.getName()); writer.name("type").value(THREAD_TYPE); StackTraceElement[] stacktrace = stackTraces.get(thread); writer.name("stacktrace").value(new Stacktrace(config, stacktrace)); if (currentThreadId == thread.getId()) { writer.name("errorReportingThread").value(true); } writer.endObject(); } } writer.endArray(); }

Target:
public void toStream(@NonNull JsonStream writer) throws IOException { writer.beginArray(); for (CachedThread thread : cachedThreads) { writer.value(thread); } writer.endArray(); }
Source:
public List<? extends Module> getJacksonModules() { return ImmutableList.<Module>of( new SimpleModule("SingleCached-LoadingOrPolling-Lookup-Module") { @Override public void setupModule(SetupContext context) { context.setMixInAnnotations(LookupExtractorFactory.class, LookupExtractorFactoryMixIn.class); } } ); }

Target:
public List<? extends Module> getJacksonModules() { return ImmutableList.<Module>of( new SimpleModule("SingleCached-LoadingOrPolling-Lookup-Module") { @Override public void setupModule(SetupContext context) { context.registerSubtypes(LoadingLookupFactory.class); context.registerSubtypes(PollingLookupFactory.class); context.registerSubtypes(new NamedType(PrefetchedLoadingLookupFactory.class, "prefetchLoadingLookup")); } } ); }
Source:
public ShaderLayer setTextureBounds(double... bounds) { if(bounds==null) return this; assert (bounds.length==4); this.textureBounds = bounds; return this; }

Target:
public ShaderLayer setTextureBounds(double... bounds) { if(bounds==null) return this; Preconditions.checkArgument(bounds.length==4); this.textureBounds = bounds; return this; }
Source:
private String getUrl() throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, MalformedURLException { if (Strings.isNullOrEmpty(dingtalkConfiguration.getSecret())) { return dingtalkConfiguration.getWebhook(); } else { return getSignUrl(); } }

Target:
private String getUrl() { if (Strings.isNullOrEmpty(dingtalkConfiguration.getSecret())) { return dingtalkConfiguration.getWebhook(); } else { return getSignUrl(); } }
Source:
public void run() { synchronized (scannerLock) { if (status == Status.STOPPED) { return; } scanNow(); status = Status.RUNNING; } }

Target:
public void run() { synchronized (KieRepositoryScannerImpl.this) { if (status == Status.STOPPED) { return; } scanNow(); status = Status.RUNNING; } }
Source:
private void deleteInDb(NetworkInstance networkInstance, String vdc, String region) throws InvalidEntityException { log.info("Destroying network in DB" + networkInstance.getNetworkName()); try { networkInstance = load(networkInstance.getNetworkName(), vdc, region); Set<SubNetworkInstance> subNetAux = networkInstance.cloneSubNets(); log.info("Deleting the subnets " + subNetAux.size()); networkInstance.getSubNets().clear(); networkInstanceDao.update(networkInstance); for (SubNetworkInstance subNet : subNetAux) { log.info ("Delete subnet " + subNet.getName()); subNetworkInstanceManager.deleteInBD(subNet); } log.info("Deleting the network"); networkInstanceDao.remove(networkInstance); } catch (Exception e) { log.error("Error to remove the network in BD " + e.getMessage()); throw new InvalidEntityException(networkInstance); } }

Target:
private void deleteInDb(NetworkInstance networkInstance, String vdc, String region) throws InvalidEntityException { log.info("Destroying network in DB" + networkInstance.getNetworkName()); try { networkInstance = load(networkInstance.getNetworkName(), vdc, region); Set<SubNetworkInstance> subNetAux = networkInstance.cloneSubNets(); networkInstance.getSubNets().clear(); networkInstanceDao.update(networkInstance); for (SubNetworkInstance subNet : subNetAux) { log.info ("Delete subnet in BD " + subNet.getName()); subNetworkInstanceManager.deleteInBD(subNet); } networkInstanceDao.remove(networkInstance); } catch (Exception e) { log.error("Error to remove the network in BD " + e.getMessage()); throw new InvalidEntityException(networkInstance); } }
Source:
public void registerReferenceProviders(@NotNull PsiReferenceRegistrar registrar) { registerRecords(registrar, "erlang", "is_record", 2, 1); registerRecords(registrar, "erlang", "is_record", 3, 1); registrar.registerReferenceProvider(psiElement(ErlangQAtom.class).with( new ErlangPsiImplUtil.ErlangSpecParameter<PsiElement>()), getProvider(Kind.MODULE)); ErlangFunctionCallNamedParameter<PsiElement> funParameter = new ErlangFunctionCallNamedParameter<PsiElement>("Function", "Fun", "_Function"); registrar.registerReferenceProvider(psiElement(ErlangQAtom.class).with(funParameter), getProvider(Kind.FUNCTION)); }

Target:
public void registerReferenceProviders(@NotNull PsiReferenceRegistrar registrar) { PsiElementPattern.Capture<ErlangQAtom> atom = psiElement(ErlangQAtom.class); PsiElementPattern.Capture<ErlangQAtom> atomArg = atom.withParents(ErlangMaxExpression.class, ErlangArgumentList.class, ErlangFunctionCallExpression.class); registrar.registerReferenceProvider(atomArg.with(isRecordArgument(2)), new RecordReferenceProvider()); registrar.registerReferenceProvider(atomArg.with(isRecordArgument(3)), new RecordReferenceProvider()); registrar.registerReferenceProvider(atom.with(new ErlangFunctionCallModuleArgument()), new ModuleReferenceProvider()); registrar.registerReferenceProvider(atom.with(new ErlangFunctionCallFunctionArgument()), new FunctionReferenceProvider()); }
Source:
public void afterPropertiesSet() throws Exception { Assert.state(dataSource != null, "DataSource must be provided"); if (getJdbcTemplate() == null) { setJdbcTemplate(new JdbcTemplate(dataSource)); } setJobExecutionIncrementer(new AbstractDataFieldMaxValueIncrementer() { @Override protected long getNextKey() { return 0; } }); final String subQuery = getQuery( "not exists (select * from %PREFIX%JOB_EXECUTION_PARAMS a where key_name = 'xd_parent_execution_id' and E.JOB_EXECUTION_ID=a.JOB_EXECUTION_ID)"); allExecutionsPagingQueryProvider = getPagingQueryProvider(null, subQuery); final String childJobExecutionsSubQuery = getQuery( "exists (select * from %PREFIX%JOB_EXECUTION_PARAMS a where key_name = 'xd_parent_execution_id' and E.JOB_EXECUTION_ID=a.JOB_EXECUTION_ID and long_val=?)"); childJobExecutionsPagingQueryProvider = getPagingQueryProvider(null, childJobExecutionsSubQuery); super.afterPropertiesSet(); }

Target:
public void afterPropertiesSet() throws Exception { Assert.state(dataSource != null, "DataSource must be provided"); if (getJdbcTemplate() == null) { setJdbcTemplate(new JdbcTemplate(dataSource)); } setJobExecutionIncrementer(new AbstractDataFieldMaxValueIncrementer() { @Override protected long getNextKey() { return 0; } }); final String subQuery = getQuery( "not exists (select * from %PREFIX%JOB_EXECUTION_PARAMS a where key_name = '" + JobLaunchingTasklet.XD_PARENT_JOB_EXECUTION_ID + "' and E.JOB_EXECUTION_ID=a.JOB_EXECUTION_ID)"); allExecutionsPagingQueryProvider = getPagingQueryProvider(subQuery); final String childJobExecutionsSubQuery = getQuery( "exists (select * from %PREFIX%JOB_EXECUTION_PARAMS a where key_name = '" + JobLaunchingTasklet.XD_PARENT_JOB_EXECUTION_ID + "' and E.JOB_EXECUTION_ID=a.JOB_EXECUTION_ID and long_val=?)"); childJobExecutionsPagingQueryProvider = getPagingQueryProvider(childJobExecutionsSubQuery); super.afterPropertiesSet(); }
Source:
public void awaitCompletion() throws InterruptedException { boolean performedWarning = false; lock.lock(); try { while (!isFlushed()) { flushedCondition.await(finishWaitMillis, TimeUnit.MILLISECONDS); long now = clock.nanoTime(); if (now >= noSuccessCheckDeadlineNanos) { lock.lock(); try { for (RetryHandler retryHandler : outstandingRetries.values()) { retryHandler.performRetryIfStale(); } if (isFlushed()) { break; } } finally { lock.unlock(); } logNoSuccessWarning(now); resetNoSuccessWarningDeadline(); performedWarning = true; } } if (performedWarning) { LOG.info("awaitCompletion() completed"); } } finally { lock.unlock(); } }

Target:
public void awaitCompletion() throws InterruptedException { boolean performedWarning = false; lock.lock(); try { while (!isFlushed()) { flushedCondition.await(finishWaitMillis, TimeUnit.MILLISECONDS); long now = clock.nanoTime(); if (now >= noSuccessCheckDeadlineNanos) { for (RetryHandler retryHandler : ImmutableList.copyOf(outstandingRetries.values())) { retryHandler.performRetryIfStale(); } if (isFlushed()) { break; } logNoSuccessWarning(now); resetNoSuccessWarningDeadline(); performedWarning = true; } } if (performedWarning) { LOG.info("awaitCompletion() completed"); } } finally { lock.unlock(); } }
Source:
public int compareTo(Currency o) { if (attributes.equals(o.attributes)) return 0; int comparison = attributes.commonCode.compareTo(o.attributes.commonCode); if (comparison == 0) comparison = getDisplayName().compareTo(o.getDisplayName()); if (comparison == 0) comparison = hashCode() - o.hashCode(); return comparison; }

Target:
public int compareTo(Currency o) { if (attributes.equals(o.attributes)) return 0; Comparator<String> nullSafeStringComparator = Comparator .nullsFirst(String::compareToIgnoreCase); Comparator<Integer> nullSafeIntComparator = Comparator .nullsFirst(Integer::compareTo); Comparator<Currency> currencyComparator; if (attributes.commonCode != null && o.attributes.commonCode != null) { currencyComparator= Comparator .comparing(Currency::getCommonCode, nullSafeStringComparator); } else { currencyComparator= Comparator .comparing(Currency::getCurrencyCode, nullSafeStringComparator); } return currencyComparator .thenComparing(Currency::getDisplayName, nullSafeStringComparator) .thenComparing(Currency::hashCode, nullSafeIntComparator) .compare(this, o); }
Source:
public void testExportTableCase() throws IOException { if (! MiscUtils.isPro()) { return; } VoltProjectBuilder project = new VoltProjectBuilder(); project.addSchema(TestVoltCompiler.class.getResource("ExportTester-ddl.sql")); project.addStmtProcedure("Dummy", "insert into a values (?, ?, ?);", new ProcedurePartitionData("a", "a_id")); project.addExport(true, ServerExportEnum.CUSTOM, "org.voltdb.exportclient.NoOpExporter", new Properties(), "noop"); project.addExport(true ); try { assertTrue(project.compile("/tmp/exportsettingstest.jar")); String catalogContents = VoltCompilerUtils.readFileFromJarfile("/tmp/exportsettingstest.jar", "catalog.txt"); Catalog cat = new Catalog(); cat.execute(catalogContents); CatalogUtil.compileDeployment(cat, project.getPathToDeployment(), false); Connector connector = cat.getClusters().get("cluster").getDatabases(). get("database").getConnectors().get("noop"); assertTrue(connector.getEnabled()); assertNotNull(connector.getTableinfo().getIgnoreCase("a")); assertNotNull(connector.getTableinfo().getIgnoreCase("b")); assertNotNull(connector.getTableinfo().getIgnoreCase("c")); assertNotNull(connector.getTableinfo().getIgnoreCase("d")); assertNotNull(connector.getTableinfo().getIgnoreCase("e")); assertNull(connector.getTableinfo().getIgnoreCase("f")); } finally { File jar = new File("/tmp/exportsettingstest.jar"); jar.delete(); } }

Target:
public void testExportTableCase() throws IOException { if (! MiscUtils.isPro()) { return; } VoltProjectBuilder project = new VoltProjectBuilder(); project.addSchema(TestVoltCompiler.class.getResource("ExportTester-ddl.sql")); project.addStmtProcedure("Dummy", "insert into a values (?, ?, ?);", new ProcedurePartitionData("a", "a_id")); project.addExport(true, ServerExportEnum.CUSTOM, "org.voltdb.exportclient.NoOpExporter", new Properties(), "noop"); project.addExport(true ); try { assertTrue(project.compile("/tmp/exportsettingstest.jar")); String catalogContents = VoltCompilerUtils.readFileFromJarfile("/tmp/exportsettingstest.jar", "catalog.txt"); Catalog cat = new Catalog(); cat.execute(catalogContents); CatalogUtil.compileDeployment(cat, project.getPathToDeployment(), false); Connector connector = cat.getClusters().get("cluster").getDatabases(). get("database").getConnectors().get("noop"); assertTrue(connector.getEnabled()); assertNotNull(connector.getTableinfo().getIgnoreCase("a")); assertNotNull(connector.getTableinfo().getIgnoreCase("B")); assertNull(connector.getTableinfo().getIgnoreCase("c")); assertNull(connector.getTableinfo().getIgnoreCase("D")); assertNull(connector.getTableinfo().getIgnoreCase("e")); assertNotNull(connector.getTableinfo().getIgnoreCase("f")); } finally { File jar = new File("/tmp/exportsettingstest.jar"); jar.delete(); } }
Source:
protected PatchScreen(final Patch.Key id, final int patchIndex, final PatchSetDetail detail, final PatchTable patchTable) { patchKey = id; patchSetDetail = detail; fileList = patchTable; diffSideA = patchTable.getPatchSetIdToCompareWith(); if (diffSideA == null) { historyOpen = null; } idSideA = diffSideA; idSideB = diffSideB != null ? diffSideB : id.getParentKey(); this.patchIndex = patchIndex; prefs = fileList != null ? fileList.getPreferences() : new ListenableAccountDiffPreference(); prefs.addValueChangeHandler( new ValueChangeHandler<AccountDiffPreference>() { @Override public void onValueChange(ValueChangeEvent<AccountDiffPreference> event) { update(event.getValue()); } }); settingsPanel = new PatchScriptSettingsPanel(prefs); settingsPanel.getReviewedCheckBox().addValueChangeHandler( new ValueChangeHandler<Boolean>() { @Override public void onValueChange(ValueChangeEvent<Boolean> event) { setReviewedByCurrentUser(event.getValue()); } }); }

Target:
protected PatchScreen(final Patch.Key id, final int patchIndex, final PatchSetDetail detail, final PatchTable patchTable) { patchKey = id; patchSetDetail = detail; fileList = patchTable; if (patchTable != null) { diffSideA = patchTable.getPatchSetIdToCompareWith(); } else { diffSideA = null; } if (diffSideA == null) { historyOpen = null; } idSideA = diffSideA; idSideB = diffSideB != null ? diffSideB : id.getParentKey(); this.patchIndex = patchIndex; prefs = fileList != null ? fileList.getPreferences() : new ListenableAccountDiffPreference(); prefs.addValueChangeHandler( new ValueChangeHandler<AccountDiffPreference>() { @Override public void onValueChange(ValueChangeEvent<AccountDiffPreference> event) { update(event.getValue()); } }); settingsPanel = new PatchScriptSettingsPanel(prefs); settingsPanel.getReviewedCheckBox().addValueChangeHandler( new ValueChangeHandler<Boolean>() { @Override public void onValueChange(ValueChangeEvent<Boolean> event) { setReviewedByCurrentUser(event.getValue()); } }); }
Source:
private void sendMessages(List<BackupMessage> messages) { logger.info("Sending messages from backup storage.", messages.size()); ExecutorService executor = Executors.newFixedThreadPool(16); int sentCounter = 0; int discardedCounter = 0; for (BackupMessage backupMessage : messages) { Message message = new JsonMessage(backupMessage.getMessageId(), backupMessage.getData(), backupMessage.getTimestamp()); Optional<Topic> topic = loadTopic(fromQualifiedName(backupMessage.getQualifiedTopicName()), executor); if (sendMessageIfNeeded(message, topic, "sending")) { sentCounter++; } else { discardedCounter++; } } executor.shutdownNow(); try { executor.awaitTermination(1, TimeUnit.MINUTES); } catch (InterruptedException e) { logger.error("Termination of load topics executor service interrupted.", e); } logger.info("Loaded and sent messages and discarded messages from the backup storage.", sentCounter, discardedCounter); }

Target:
private void sendMessages(List<BackupMessage> messages) { logger.info("Sending messages from backup storage.", messages.size()); ExecutorService executor = createExecutor(); try { int sentCounter = 0; int discardedCounter = 0; for (BackupMessage backupMessage : messages) { Message message = new JsonMessage(backupMessage.getMessageId(), backupMessage.getData(), backupMessage.getTimestamp()); Optional<Topic> topic = loadTopic(fromQualifiedName(backupMessage.getQualifiedTopicName()), executor); if (sendMessageIfNeeded(message, topic, "sending")) { sentCounter++; } else { discardedCounter++; } } logger.info("Loaded and sent messages and discarded messages from the backup storage.", sentCounter, discardedCounter); } finally { shutdownExecutor(executor); } }
Source:
public <V> Future<V> schedule(BackgroundTask<V> task, long delay, TimeUnit unit) { return scheduledExecutor.schedule(task::call, delay, unit); }

Target:
public <V> Future<V> schedule(BackgroundTask<V> task, long delay, TimeUnit unit) { return scheduledExecutor.schedule(() -> getJavaFXTask(task).get(), delay, unit); }
Source:
public double kPercentileLatencyAsDouble(double percentile) { if (m_latencyHistogram.getTotalCount() == 0) return 0.0; percentile = Math.max(0.0, percentile); return m_latencyHistogram.getValueAtPercentile(percentile * 100.0) / 1000.0; }

Target:
public double kPercentileLatencyAsDouble(double percentile) { if (m_latencyHistogram.getTotalCount() == 0) return 0.0; percentile = Math.max(0.0D, percentile); return m_latencyHistogram.getValueAtPercentile(percentile * 100.0D) / 1000.0; }
Source:
public void write(Persistable persistable) { if (persistable.getID() != -1) { update(persistable.getID(), persistable); return; } SQLiteDatabase db = getDbOrThrow(); try { db.beginTransaction(); long insertedId; ByteArrayOutputStream bos = writeExternalizableToStream(persistable); try { if (blobFitsInDb(bos)) { ContentValues contentValues = helper.getNonDataContentValues(persistable); contentValues.put(DatabaseHelper.DATA_COL, bos.toByteArray()); insertedId = db.insertOrThrow(table, DatabaseHelper.DATA_COL, contentValues); } else { File dataFile = HybridFileBackedSqlHelpers.newFileForEntry(dbDir); ContentValues contentValues = helper.getNonDataContentValues(persistable); contentValues.put(DatabaseHelper.FILE_COL, dataFile.getAbsolutePath()); byte[] key = generateKeyAndAdd(contentValues); insertedId = db.insertOrThrow(table, DatabaseHelper.FILE_COL, contentValues); writeStreamToFile(bos, dataFile.getAbsolutePath(), key); } } finally { bos.close(); } persistable.setID((int)insertedId); if (insertedId > Integer.MAX_VALUE) { throw new RuntimeException("Waaaaaaaaaay too many values"); } db.setTransactionSuccessful(); } catch (IOException e) { e.printStackTrace(); } finally { db.endTransaction(); } }

Target:
public void write(Persistable persistable) { if (persistable.getID() != -1) { update(persistable.getID(), persistable); return; } SQLiteDatabase db = getDbOrThrow(); try { long insertedId; ByteArrayOutputStream bos = writeExternalizableToStream(persistable); String dataFilePath = null; try { if (blobFitsInDb(bos)) { db.beginTransaction(); ContentValues contentValues = helper.getNonDataContentValues(persistable); contentValues.put(DatabaseHelper.DATA_COL, bos.toByteArray()); insertedId = db.insertOrThrow(table, DatabaseHelper.DATA_COL, contentValues); } else { dataFilePath = HybridFileBackedSqlHelpers.newFileForEntry(dbDir).getAbsolutePath(); HybridFileBackedSqlHelpers.setFileAsOrphan(db, dataFilePath); db.beginTransaction(); ContentValues contentValues = helper.getNonDataContentValues(persistable); contentValues.put(DatabaseHelper.FILE_COL, dataFilePath); byte[] key = generateKeyAndAdd(contentValues); insertedId = db.insertOrThrow(table, DatabaseHelper.FILE_COL, contentValues); writeStreamToFile(bos, dataFilePath, key); } } finally { bos.close(); } persistable.setID((int)insertedId); if (insertedId > Integer.MAX_VALUE) { throw new RuntimeException("Waaaaaaaaaay too many values"); } if (dataFilePath != null) { HybridFileBackedSqlHelpers.unsetFileAsOrphan(db, dataFilePath); } db.setTransactionSuccessful(); } catch (IOException e) { throw new RuntimeException(e); } finally { db.endTransaction(); } }
Source:
public void mouseScrollWithKey(final int xPosition, final int yPosition, final int keyCode, final int zoomIncrement) { if (canvas instanceof SWTBotSiriusFigureCanvas) { ((SWTBotSiriusFigureCanvas) canvas).mouseScrollWithKey(xPosition, yPosition, keyCode, zoomIncrement); } else { throw new UnsupportedOperationException("This method is supported only by SWTBotSiriusFigureCanvas canva and not by " + canvas.getClass().getSimpleName()); } }

Target:
public void mouseScrollWithKey(final int xPosition, final int yPosition, final int keyCode, final int zoomIncrement) { if (canvas instanceof SWTBotSiriusFigureCanvas) { ((SWTBotSiriusFigureCanvas) canvas).mouseScrollWithKey(xPosition, yPosition, keyCode, zoomIncrement); } else { throw new UnsupportedOperationException("This method is supported only by SWTBotSiriusFigureCanvas canvas and not by " + canvas.getClass().getSimpleName()); } }
Source:
public void getMuleBinTest() { assertThat("Mule bin path is not the expected", controller.getMuleBin(), equalTo("/home/mule/bin/mule")); }

Target:
public void getMuleBinTest() { assertThat("Mule bin path is not the expected", controller.getMuleBin(), equalTo(MULE_HOME + "/bin/mule")); }
Source:
private static Multimap<Cell, Value> getVersions() { Multimap<Cell, Value> versions = ArrayListMultimap.create(); LongStream.range(1, CELL_VERSIONS + 1).boxed() .forEach(timestamp -> versions.put(cell, Value.create(value, timestamp))); return versions; }

Target:
private static Multimap<Cell, Value> getVersions() { Multimap<Cell, Value> versions = ArrayListMultimap.create(); LongStream.rangeClosed(1, CELL_VERSIONS).boxed() .forEach(timestamp -> versions.put(cell, Value.create(value, timestamp))); return versions; }
Source:
protected String getValue() { return this.width + "|" + this.height + "|" + this.screenX + "|" + this.screenY + "|" + this.isMaximized; }

Target:
protected String getValue() { return String.format("%d|%d|%d|%d|%s", this.width, this.height, this.screenX, this.screenY, this.isMaximized); }
Source:
public int hashCode() { return isBigInteger() ? biValue.hashCode() : (int) longValue; }

Target:
public int hashCode() { int hash = 0; if(isBigInteger()) { hash = biValue.hashCode(); } else { hash = (int)((longValue >>> 32) * 31 + longValue & 0xFFFFFFFF); } return hash; }
Source:
private String getTargetPath(String location) { return getClass().getResource(File.separatorChar + location).toString().substring(5); }

Target:
private String getTargetPath(String location) { String targetPath = getClass().getResource(File.separatorChar + location).toString(); if (targetPath.startsWith("file:/")) { return targetPath.substring(5); } return targetPath; }
Source:
private ResultWithToken getTimestampsByCell( DbReadTable table, Iterable<byte[]> rows, ColumnSelection columns, long timestamp, long batchSize, boolean isReverse, Token token) { try (ClosableIterator<AgnosticLightResultRow> iterator = table .getAllRows(rows, columns, timestamp, false, DbReadTable.Order.fromBoolean(isReverse))) { ResultWithToken result = ResultWithToken.create(iterator); result.moveForward(token); result.getBatchOfTimestamps(batchSize); result.checkNextEntryAndCreateToken(); return result; } }

Target:
private TimestampsByCellResultWithToken getTimestampsByCell( DbReadTable table, Iterable<byte[]> rows, ColumnSelection columns, long timestamp, long batchSize, boolean isReverse, Token token) { try (ClosableIterator<AgnosticLightResultRow> iterator = table .getAllRows(rows, columns, timestamp, false, DbReadTable.Order.fromBoolean(isReverse))) { return TimestampsByCellResultWithToken.create(iterator, token, batchSize); } }
Source:
public Subscriber<? super T> call(final Subscriber<? super T> subscriber) { return new Subscriber<T>(subscriber) { private int counter = 0; @Override public void onNext(T args) { boolean isSelected; try { isSelected = predicate.call(args, counter++); } catch (Throwable e) { subscriber.onError(e); return; } if (isSelected) { subscriber.onNext(args); } else { subscriber.onCompleted(); } } @Override public void onCompleted() { subscriber.onCompleted(); } @Override public void onError(Throwable e) { subscriber.onError(e); } }; }

Target:
public Subscriber<? super T> call(final Subscriber<? super T> subscriber) { return new Subscriber<T>(subscriber) { private int counter = 0; @Override public void onNext(T args) { boolean isSelected; try { isSelected = predicate.call(args, counter++); } catch (Throwable e) { subscriber.onError(e); unsubscribe(); return; } if (isSelected) { subscriber.onNext(args); } else { subscriber.onCompleted(); unsubscribe(); } } @Override public void onCompleted() { subscriber.onCompleted(); } @Override public void onError(Throwable e) { subscriber.onError(e); } }; }
Source:
public final <T> T visit(Visitor<T> visitor) { return visitor.apply(hosts().stream().map(CqlCapableServer::thriftServer).collect(Collectors.toSet()), Optional.of(hosts().stream().map(CqlCapableServer::thriftServer).collect(Collectors.toSet()))); }

Target:
public final <T> T visit(Visitor<T> visitor) { return visitor.apply( hosts().stream() .map(host -> new InetSocketAddress(host, thriftPort())) .collect(Collectors.toSet()), Optional.of(hosts().stream() .map(host -> new InetSocketAddress(host, cqlPort())) .collect(Collectors.toSet()))); }
Source:
public List<Revision> execute() throws GitException { reset(); commandLine.add("log") .add("--format=%an#%ae#%cn#%ce#%cd#%H#%s") .add("--date=raw"); if (branch != null) { commandLine.add(branch); } if (count > 0) { commandLine.add("-" + count); } if (fileFilter != null && !fileFilter.isEmpty()) { commandLine.add(fileFilter); } start(); List<Revision> list = new LinkedList<>(); final DtoFactory dtoFactory = DtoFactory.getInstance(); for (String oneRev : lines) { String[] elements = oneRev.split("#"); GitUser committer = dtoFactory.createDto(GitUser.class).withName(elements[2]).withEmail(elements[3]); long commitTime = Long.parseLong(elements[4].substring(0, elements[4].indexOf(" "))) * 1000L; String commitId = elements[5]; StringBuilder commitMessage = new StringBuilder(); for (int i = 6; i < elements.length; i++) { commitMessage.append(elements[i]); } Revision revision = dtoFactory.createDto(Revision.class) .withId(commitId) .withMessage(commitMessage.toString()) .withCommitTime(commitTime) .withCommitter(committer); list.add(revision); } return list; }

Target:
public List<Revision> execute() throws GitException { reset(); commandLine.add("log") .add("--format=%an#%ae#%cn#%ce#%cd#%H#%s") .add("--date=raw"); if (branch != null) { commandLine.add(branch); } if (count > 0) { commandLine.add("-" + count); } commandLine.add(fileFilter); start(); List<Revision> list = new LinkedList<>(); final DtoFactory dtoFactory = DtoFactory.getInstance(); for (String oneRev : lines) { String[] elements = oneRev.split("#"); GitUser committer = dtoFactory.createDto(GitUser.class).withName(elements[2]).withEmail(elements[3]); long commitTime = Long.parseLong(elements[4].substring(0, elements[4].indexOf(" "))) * 1000L; String commitId = elements[5]; StringBuilder commitMessage = new StringBuilder(); for (int i = 6; i < elements.length; i++) { commitMessage.append(elements[i]); } Revision revision = dtoFactory.createDto(Revision.class) .withId(commitId) .withMessage(commitMessage.toString()) .withCommitTime(commitTime) .withCommitter(committer); list.add(revision); } return list; }
Source:
public static void reportException(@Nonnull String name, @Nonnull Throwable e) { name = name.replace('/', '.').trim(); if (isFromMovedPackage(name)) { events.put(name, e); if (LOGGER.isLoggable(Level.FINE)) LOGGER.log(Level.FINE, "Added a missed class for Java 11 telemetry. Class: " + name, e); } }

Target:
public static void reportException(@Nonnull String name, @Nonnull Throwable e) { if (enabled()) { name = name.replace('/', '.').trim(); if (isFromMovedPackage(name) && !calledFromIgnoredPlace(e)) { events.put(name, e); if (LOGGER.isLoggable(Level.WARNING)) LOGGER.log(Level.WARNING, "Added a missed class for missing class telemetry. Class: " + name, e); } } }
Source:
public ChefClient puppetClientload(String nodeName, String token, String vdc) throws EntityNotFoundException { puppetLog.info("Getting node " + nodeName + " from puppet master"); String url = null; try { url = openStackRegion.getPuppetWrapperEndPoint(token) + "v2/node/" + nodeName; } catch (OpenStackException e2) { puppetLog.warn(e2.getMessage()); } if (url != null) { Map<String, String> headers = new HashMap<String, String>(); headers.put(HttpsClient.HEADER_AUTH, token); headers.put(HttpsClient.HEADER_TENNANT, vdc); try { int statusCode; statusCode = httpsClient.doHttps(HttpMethod.GET, url, "", headers); if (statusCode == HTTP_OK || statusCode == HTTP_NOT_FOUND) { log.info("Node obtained"); return new ChefClient(); } else { String msg = format("[puppet get node] response code was: {0}", statusCode); puppetLog.info(msg); throw new EntityNotFoundException(ChefClient.class, msg, nodeName); } } catch (Exception e) { String msg = format("[puppet get node] response code was: {0}", e.getMessage()); puppetLog.info(e.getMessage()); throw new EntityNotFoundException(ChefClient.class, msg, nodeName); } } return null; }

Target:
public NodeDto puppetClientload(String nodeName, String token, String vdc) throws EntityNotFoundException { puppetLog.info("Getting node " + nodeName + " from puppet master"); String url = null; NodeDto node = null; try { url = openStackRegion.getPuppetWrapperEndPoint(token) + "v2/node/" + nodeName; } catch (OpenStackException e2) { puppetLog.warn(e2.getMessage()); } if (url != null) { Map<String, String> headers = new HashMap<String, String>(); headers.put(HttpsClient.HEADER_AUTH, token); headers.put(HttpsClient.HEADER_TENNANT, vdc); try { int statusCode; statusCode = httpsClient.doHttps(HttpMethod.GET, url, "", headers); if (statusCode == HTTP_OK) { log.info("Node obtained " + nodeName); node = new NodeDto (); node.setSoftwareName(nodeName); } else { String msg = format("[puppet get node] response code was: {0}", statusCode); puppetLog.info(msg); throw new EntityNotFoundException(ChefClient.class, msg, nodeName); } } catch (Exception e) { String msg = format("[puppet get node] response code was: {0}", e.getMessage()); puppetLog.info(e.getMessage()); throw new EntityNotFoundException(ChefClient.class, msg, nodeName); } } return node; }
Source:
public void visitMethodInvocation(MethodInvocationTree tree) { if (EQUALS_MATCHER.matches(tree)) { if (tree.methodSelect().is(Tree.Kind.MEMBER_SELECT) && isArgument(((MemberSelectExpressionTree) tree.methodSelect()).expression())) { typeChecked = true; } else if (isArgument(tree.arguments().get(0))) { typeChecked = true; } } }

Target:
public void visitMethodInvocation(MethodInvocationTree tree) { for (ExpressionTree argument : tree.arguments()) { if (isArgument(argument, parameterSymbol)) { typeChecked = true; return; } } super.visitMethodInvocation(tree); }
Source:
public void eventReceived(Action action, Pod resource) { Map<String, String> labels = resource.getMetadata().getLabels(); if (workspaceId.equals(labels.get(CHE_WORKSPACE_ID_LABEL))) { future.complete(resource); } }

Target:
public void eventReceived(Action action, Pod resource) { Map<String, String> labels = resource.getMetadata().getLabels(); if (workspaceId.equals(labels.get(CHE_WORKSPACE_ID_LABEL)) && originalName.equals(labels.get(CHE_DEPLOYMENT_NAME_LABEL))) { future.complete(resource); } }
Source:
public synchronized void updateOnCommunicationFailure(long sendTimeMillis) { if (!recordingOfflineStatus) { if (trace) { log.trace("Start recording failures"); } recordingOfflineStatus = true; firstFailureTime = sendTimeMillis; } failureCount++; if (trace) { log.tracef("Failures count: %s", failureCount); } }

Target:
public synchronized void updateOnCommunicationFailure(long sendTimeMillis) { if (!recordingOfflineStatus) { recordingOfflineStatus = true; firstFailureTime = sendTimeMillis; } failureCount++; }
Source:
protected void syncSearch() { if(getEntity() != null) { GlusterVolumeEntity volume = (GlusterVolumeEntity) getEntity(); AsyncDataProvider.getInstance().getGlusterVolumeGeoRepStatusForMasterVolume(new AsyncQuery(this, new INewAsyncCallback() { @Override public void onSuccess(Object model, Object returnValue) { List<GlusterGeoRepSession> geoRepSessions = (ArrayList<GlusterGeoRepSession>) returnValue; if(getItems() == geoRepSessions) { getItemsChangedEvent().raise(this, EventArgs.EMPTY); } else { Collections.sort(geoRepSessions, new Linq.GlusterVolumeGeoRepSessionComparer()); setItems(geoRepSessions); } } }), volume.getId(), volume.getClusterId()); } else { setItems(null); } }

Target:
protected void syncSearch() { if (getEntity() == null) { return; } AsyncDataProvider.getInstance().getGlusterVolumeGeoRepStatusForMasterVolume(new AsyncQuery(this, new INewAsyncCallback() { @Override public void onSuccess(Object model, Object returnValue) { List<GlusterGeoRepSession> geoRepSessions = (ArrayList<GlusterGeoRepSession>) returnValue; Collections.sort(geoRepSessions, new Linq.GlusterVolumeGeoRepSessionComparer()); setItems(geoRepSessions); } }), getEntity().getId()); }
Source:
public void testPollSocketsInfo() { mTst.setTcpInfoSupported(false); assertFalse(mTst.pollSocketsInfo()); assertEquals(0, mTst.getLatestPacketFailRate()); mTst.setTcpInfoSupported(true); mTst.setPollingRequest(false, AF_INET6); mTst.setPollingRequest(true, AF_INET); mTst.setMessage(TEST_RESPONSE_BYTES); mTst.setLatestPacketFailRate(-1); assertEquals(0, mTst.getLatestPacketFailRate()); mTst.setSentSinceLastRecv(DEFAULT_DATA_STALL_MIN_PACKETS_THRESHOLD + 1); assertTrue(mTst.pollSocketsInfo()); assertEquals(100, mTst.getLatestPacketFailRate()); }

Target:
public void testPollSocketsInfo() throws Exception { when(mDependencies.isTcpInfoParsingSupported()).thenReturn(false); final TcpSocketTracker tst = new TcpSocketTracker(mDependencies); assertFalse(tst.pollSocketsInfo()); when(mDependencies.isTcpInfoParsingSupported()).thenReturn(true); final ByteBuffer invalidBuffer = ByteBuffer.allocate(1); when(mDependencies.recvMesssage(any())).thenReturn(invalidBuffer); assertTrue(tst.pollSocketsInfo()); assertEquals(0, tst.getLatestPacketFailRate()); assertEquals(0, tst.getSentSinceLastRecv()); final ByteBuffer headerBuffer = ByteBuffer.wrap(SOCK_DIAG_MSG_BYTES); when(mDependencies.recvMesssage(any())).thenReturn(headerBuffer); assertTrue(tst.pollSocketsInfo()); assertEquals(0, tst.getSentSinceLastRecv()); assertEquals(0, tst.getLatestPacketFailRate()); final ByteBuffer tcpBuffer = ByteBuffer.wrap(TEST_RESPONSE_BYTES); when(mDependencies.recvMesssage(any())).thenReturn(tcpBuffer); assertTrue(tst.pollSocketsInfo()); assertEquals(0, tst.getSentSinceLastRecv()); assertEquals(100, tst.getLatestPacketFailRate()); assertEquals(10, tst.getSentSinceLastRecv()); }
Source:
public Map<String, String> getFileSystemProperties() { if (fileSystemProperties == null) { return new HashMap<>(); } try { return GSON.fromJson(fileSystemProperties, MAP_STRING_STRING_TYPE); } catch (Exception e) { throw new IllegalArgumentException("Unable to parse filesystem properties: " + e.getMessage()); } }

Target:
Map<String, String> getFileSystemProperties() { if (fileSystemProperties == null) { return new HashMap<>(); } try { return GSON.fromJson(fileSystemProperties, MAP_STRING_STRING_TYPE); } catch (Exception e) { throw new IllegalArgumentException("Unable to parse filesystem properties: " + e.getMessage()); } }