auphong2707/dl4se-code-review-dataset huggingface dataset:
Source:
public void testFunctionsListElements() { onBrickAtPosition(0).checkShowsText(R.string.brick_when_started); onBrickAtPosition(1).checkShowsText(R.string.brick_change_size_by); onBrickAtPosition(1).perform(click()); onView(withText(R.string.formula_editor_functions)).perform(click()); String formulaEditorFunctionString = InstrumentationRegistry.getTargetContext() .getString(formulaEditorFunction); String formulaEditorFunctionParameterString = InstrumentationRegistry.getTargetContext() .getString(formulaEditorFunctionParameter); String editorFunction = formulaEditorFunctionString + formulaEditorFunctionParameterString; String selectedFunctionString = getSelectedFunctionString(formulaEditorFunctionString, formulaEditorFunctionParameterString); onData(allOf(is(instanceOf(String.class)), is(editorFunction))) .inAdapterView(FormulaEditorFunctionListMatchers.isFunctionListView()) .check(matches(isDisplayed())); onView(withText(editorFunction)).perform(click()); onView(withId(R.id.formula_editor_edit_field)).check(matches(withText(selectedFunctionString))); }

Target:
public void testFunctionsListElements() { onBrickAtPosition(whenBrickPosition).checkShowsText(R.string.brick_when_started); onBrickAtPosition(changeSizeBrickPosition).checkShowsText(R.string.brick_change_size_by); onBrickAtPosition(changeSizeBrickPosition).onChildView(withId(R.id.brick_change_size_by_edit_text)) .perform(click()); onView(withText(R.string.formula_editor_functions)).perform(click()); String formulaEditorFunctionString = UiTestUtils.getResourcesString(formulaEditorFunction); String formulaEditorFunctionParameterString = UiTestUtils.getResourcesString(formulaEditorFunctionParameter); String editorFunction = formulaEditorFunctionString + formulaEditorFunctionParameterString; String selectedFunctionString = getSelectedFunctionString(editorFunction); onData(allOf(is(instanceOf(String.class)), is(editorFunction))) .inAdapterView(FormulaEditorFunctionListMatchers.isFunctionListView()) .onChildView(withId(R.id.fragment_formula_editor_list_item)) .check(matches(isDisplayed())) .perform(click()); onView(withId(R.id.formula_editor_edit_field)) .check(matches(withText(selectedFunctionString))); }
Source:
public File gitPrefix() throws IOException { String w; w = readPipe(null, new String[] { "which git" }, Charset.defaultCharset().name()); if (w == null) { w = readPipe(null, new String[] { "whence", "git" }, Charset.defaultCharset().name()); } if (w == null) { w = readPipe(userHome, new String[] { "bash", "--login", "-c", "which git" }, Charset.defaultCharset().name()); } if (w == null) return null; File f = new File(w); return f.getParentFile().getParentFile(); }

Target:
public File gitPrefix() { String osName = SystemReader.getInstance().getProperty("os.name"); if (osName.startsWith("Windows") || osName.startsWith("Mac")) { String w = readPipe(userHome, new String[] { "bash", "--login", "-c", "which git" }, Charset.defaultCharset().name()); File f = new File(w); return f.getParentFile().getParentFile(); } return null; }
Source:
public Operation exec(Prolog engine) throws PrologException { engine.areg2 = arg2; engine.areg3 = arg3; engine.areg4 = arg4; engine.cont = cont; engine.setB0(); Term a1 = arg1.dereference(); if (a1.isVariable()) { throw new PInstantiationException(this, 1); } if (!a1.isSymbol()) { throw new IllegalTypeException(this, 1, "symbol", a1); } PrologEnvironment env = (PrologEnvironment) engine.control; PatchSetInfo psInfo; try { psInfo = getPatchSetInfo(env); } catch (PatchSetInfoNotAvailableException err) { throw new JavaException(this, 1, err); } UserIdentity author = psInfo.getAuthor(); PatchListCache plCache = env.getInjector().getInstance(PatchListCache.class); Change change = StoredValues.CHANGE.get(engine); Project.NameKey projectKey = change.getProject(); ObjectId a = null; ObjectId b = ObjectId.fromString(psInfo.getRevId()); Whitespace ws = Whitespace.IGNORE_NONE; PatchListKey plKey = new PatchListKey(projectKey, a, b, ws); List<PatchListEntry> patches = new ArrayList<PatchListEntry>(); PatchList pl = plCache.get(plKey); for (PatchListEntry entry : pl.getPatches()) { patches.add(entry); } engine.areg1 = arg1; engine.areg5 = new JavaObjectTerm(patches); return commit_delta_4_top; }

Target:
public Operation exec(Prolog engine) throws PrologException { engine.cont = cont; engine.setB0(); Term a1 = arg1.dereference(); if (a1.isVariable()) { throw new PInstantiationException(this, 1); } if (!a1.isSymbol()) { throw new IllegalTypeException(this, 1, "symbol", a1); } Pattern regex = Pattern.compile(a1.name()); engine.areg1 = new JavaObjectTerm(regex); engine.areg2 = arg2; engine.areg3 = arg3; engine.areg4 = arg4; PrologEnvironment env = (PrologEnvironment) engine.control; PatchSetInfo psInfo; try { psInfo = getPatchSetInfo(env); } catch (PatchSetInfoNotAvailableException err) { throw new JavaException(this, 1, err); } PatchListCache plCache = env.getInjector().getInstance(PatchListCache.class); Change change = StoredValues.CHANGE.get(engine); Project.NameKey projectKey = change.getProject(); ObjectId a = null; ObjectId b = ObjectId.fromString(psInfo.getRevId()); Whitespace ws = Whitespace.IGNORE_NONE; PatchListKey plKey = new PatchListKey(projectKey, a, b, ws); PatchList pl = plCache.get(plKey); Iterator<PatchListEntry> iter = pl.getPatches().iterator(); engine.areg5 = new JavaObjectTerm(iter); return engine.jtry5(commit_delta_check, commit_delta_next); }
Source:
private static Iterable<TestEngine> validateEngineIds(Iterable<TestEngine> testEngines) { Set<String> ids = new HashSet<>(); for (TestEngine testEngine : testEngines) { if (!validateReservedIds(testEngine)) { logger.warn(() -> String.format("Thou shalt not use an engine ID starting with 'junit-': '%s'", testEngine.getId())); } if (!ids.add(testEngine.getId())) { throw new JUnitException(String.format( "Cannot create Launcher for multiple engines with the same ID '%s'.", testEngine.getId())); } } return testEngines; }

Target:
private static Iterable<TestEngine> validateEngineIds(Iterable<TestEngine> testEngines) { Set<String> ids = new HashSet<>(); for (TestEngine testEngine : testEngines) { if (!validateReservedIds(testEngine)) { logger.warn(() -> String.format( "Third-party TestEngine implementations are forbidden to use the reserved 'junit-' prefix for their ID: '%s'", testEngine.getId())); } if (!ids.add(testEngine.getId())) { throw new JUnitException(String.format( "Cannot create Launcher for multiple engines with the same ID '%s'.", testEngine.getId())); } } return testEngines; }
Source:
public TaskLock lock(final Task task, final Interval interval) throws InterruptedException { giant.lock(); try { if(!activeTasks.contains(task.getId())){ throw new IllegalStateException(String.format("Unable to grant lock to inactive Task [%s]", task.getId())); } Optional<TaskLock> taskLock; while (!(taskLock = tryLock(task, interval)).isPresent()) { lockReleaseCondition.await(); } return taskLock.get(); } finally { giant.unlock(); } }

Target:
public TaskLock lock(final Task task, final Interval interval) throws InterruptedException { giant.lock(); try { Optional<TaskLock> taskLock; while (!(taskLock = tryLock(task, interval)).isPresent()) { lockReleaseCondition.await(); } return taskLock.get(); } finally { giant.unlock(); } }
Source:
public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName("com.arjuna.ats.jdbc.TransactionalDriver"); dataSource.setUrl("jdbc:arjuna:h2:file:target/test.db"); Properties prop = new Properties(); prop.setProperty("DYNAMIC_CLASS", "org.jboss.narayana.quickstart.spring.config.H2DataSource"); dataSource.setConnectionProperties(prop); return dataSource; }

Target:
public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName("com.arjuna.ats.jdbc.TransactionalDriver"); dataSource.setUrl("jdbc:arjuna:"); Properties prop = new Properties(); prop.setProperty("DYNAMIC_CLASS", "org.jboss.narayana.quickstart.spring.config.H2DataSource"); dataSource.setConnectionProperties(prop); return dataSource; }
Source:
public String getDebugType() { return "DI"; }

Target:
public EDebugProcessType getDebugType() { return EDebugProcessType.DI; }
Source:
public static MagicSpellCardEvent create(final MagicCardDefinition cdef, final String rule) { if (cdef.hasAbility(MagicAbility.Entwine)) { return Entwine(rule); } if (cdef.hasAbility(MagicAbility.Buyback)) { return Buyback(rule); } if (cdef.hasAbility(MagicAbility.HauntSpell)) { return Haunt(rule); } if (cdef.hasAbility(MagicAbility.Ascend)) { return Ascend(rule); } final MagicSourceEvent sourceEvent = MagicRuleEventAction.create(rule); return new MagicSpellCardEvent() { @Override public MagicEvent getEvent(final MagicCardOnStack cardOnStack,final MagicPayedCost payedCost) { return sourceEvent.getEvent(cardOnStack, payedCost); } }; }

Target:
public static MagicSpellCardEvent create(final MagicCardDefinition cdef, final String rule) { if (cdef.hasAbility(MagicAbility.Entwine)) { return Entwine(rule); } if (cdef.hasAbility(MagicAbility.Buyback)) { return Buyback(rule); } if (cdef.hasAbility(MagicAbility.HauntSpell)) { return Haunt(rule); } final MagicSourceEvent sourceEvent = MagicRuleEventAction.create(rule); return new MagicSpellCardEvent() { @Override public MagicEvent getEvent(final MagicCardOnStack cardOnStack,final MagicPayedCost payedCost) { return sourceEvent.getEvent(cardOnStack, payedCost); } }; }
Source:
public URLParams and(final String key, final int value) { map.put(key, "" + value); return this; }

Target:
public URLParams and(final String key, final int value) { map.put(key, String.valueOf(value)); return this; }
Source:
public JSONObject getAccessToken() { try { return Oauth2JwtClient.builder() .withJwsHeaders(jwsHeaders()) .withJwtClaims(jwtClaims()) .signWithX509Key(x509Key(), org.talend.components.common.oauth.X509Key.Algorithm.SHA256withRSA) .fromTokenEndpoint(tokenEndpoint + "/token") .withPlayloadParams(playLoadParams()) .build() .getAccessToken(); } catch (IOException e) { throw new ComponentException(e); } }

Target:
public JsonNode getAccessToken() { try { return Oauth2JwtClient.builder() .withJwsHeaders(jwsHeaders()) .withJwtClaims(jwtClaims()) .signWithX509Key(x509Key(), org.talend.components.common.oauth.X509Key.Algorithm.SHA256withRSA) .fromTokenEndpoint(tokenEndpoint + "/token") .withPlayloadParams(playLoadParams()) .build() .getAccessToken(); } catch (IOException e) { throw new ComponentException(e); } }
Source:
@Override public final void put(K key, @Nullable V value) { synchronized (this) { Map<K, V> values = this.values; if (values == null) { values = new LinkedHashMap<>(); if (value != null) values.put(key, value); } else if (equal(value, values.get(key))) { return; } else { values = new LinkedHashMap<>(values); if (value != null) values.put(key, value); } this.values = Collections.unmodifiableMap(values); } }

Target:
@Override public final boolean put(K key, @Nullable V value) { synchronized (this) { Map<K, V> values = this.values; if (values == null) { values = new LinkedHashMap<>(); if (value != null) values.put(key, value); } else if (equal(value, values.get(key))) { return false; } else { values = new LinkedHashMap<>(values); if (value != null) { values.put(key, value); } else { values.remove(key); } } this.values = Collections.unmodifiableMap(values); } return false; }
Source:
public List<com.netflix.appinfo.InstanceInfo> getLatestServerListOrWait() { try { firstBatchLatch.await(FIRST_RESOLVE_TIMEOUT_SEC, TimeUnit.SECONDS); } catch (InterruptedException e) { } return latestServerList.get(); }

Target:
public List<com.netflix.appinfo.InstanceInfo> getLatestServerListOrWait() { try { firstBatchLatch.await(firstResolveTimeoutMs, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { } return latestServerList.get(); }
Source:
public SinkRuntimeProvider getSinkRuntimeProvider(Context context) { final SerializationSchema<RowData> keySerialization = createSerialization(context, keyEncodingFormat, keyProjection, keyPrefix); final SerializationSchema<RowData> valueSerialization = createSerialization(context, valueEncodingFormat, valueProjection, keyPrefix); final FlinkKafkaProducer<RowData> kafkaProducer = createKafkaProducer(keySerialization, valueSerialization); return SinkFunctionProvider.of(kafkaProducer); }

Target:
public SinkRuntimeProvider getSinkRuntimeProvider(Context context) { final SerializationSchema<RowData> keySerialization = createSerialization(context, keyEncodingFormat, keyProjection, keyPrefix); final SerializationSchema<RowData> valueSerialization = createSerialization(context, valueEncodingFormat, valueProjection, null); final FlinkKafkaProducer<RowData> kafkaProducer = createKafkaProducer(keySerialization, valueSerialization); return SinkFunctionProvider.of(kafkaProducer); }
Source:
private void writeOutServiceDefinitionFile(ServiceDefinition serviceDefinition, Path serviceDefinitionFolderPath) throws JAXBException, IOException { final Marshaller marshaller = getJaxbContext().createMarshaller(); marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); try (BufferedWriter serviceDefinitionXmlFileWriter = newBufferedWriter(Paths.get(serviceDefinitionFolderPath.toAbsolutePath().toString() + "/" + SERVICE_DEFINITION_FILE_NAME), UTF_8);) { marshaller.marshal(serviceDefinition, serviceDefinitionXmlFileWriter); } }

Target:
private void writeOutServiceDefinitionFile(ServiceDefinition serviceDefinition, Path serviceDefinitionFolderPath) throws JAXBException, IOException { final Marshaller marshaller = getJaxbContext().createMarshaller(); marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE); try (BufferedWriter serviceDefinitionXmlFileWriter = newBufferedWriter(Paths.get(serviceDefinitionFolderPath.toAbsolutePath().toString(), SERVICE_DEFINITION_FILE_NAME), UTF_8);) { marshaller.marshal(serviceDefinition, serviceDefinitionXmlFileWriter); } }
Source:
protected void onStart() { super.onStart(); if (castManager != null && player != null) { castManager.registerWithOoyalaPlayer(player); } layoutController.getControls().refresh(); }

Target:
protected void onStart() { super.onStart(); if (castManager != null && player != null) { castManager.registerWithOoyalaPlayer(player); } if (layoutController != null) { final OoyalaPlayerControls controls = layoutController.getControls(); if (controls != null) { controls.refresh(); } } }
Source:
public InputInfoBuilder.TableParams clientInfo(ClientInfo clientInfo) { Objects.requireNonNull(clientInfo, "ClientInfo must not be null"); this.clientInfo = clientInfo; return this; }

Target:
public InputInfoBuilder.TableParams clientInfo(ClientInfo clientInfo) { this.clientInfo = Objects.requireNonNull(clientInfo, "ClientInfo must not be null"); return this; }
Source:
public final StateClass<?> stateClass() { return StateClass.of(stateType()); }

Target:
public StateClass<?> stateClass() { return StateClass.of(stateType()); }
Source:
public Set<List<JavaFileScannerContext.Location>> getFlows() { Stream<Flow> flowsAsStream = flows.stream(); if (flows.stream().anyMatch(Flow::isExceptional) && flows.stream().anyMatch(Flow::isNonExceptional)) { flowsAsStream = flowsAsStream.filter(Flow::isNonExceptional); } return flowsAsStream.map(Flow::elements).collect(Collectors.toSet()); }

Target:
public Set<List<JavaFileScannerContext.Location>> getFlows() { Set<List<JavaFileScannerContext.Location>> nonExceptionalFlows = flows.stream().filter(Flow::isNonExceptional).map(Flow::elements).collect(Collectors.toSet()); if (!nonExceptionalFlows.isEmpty()) { return nonExceptionalFlows; } return flows.stream().map(Flow::elements).collect(Collectors.toSet()); }
Source:
protected void getThreadExecutionStateDone(ICPUDMContext cpuContext, ICoreDMContext coreContext, IMIExecutionDMContext execContext, IThreadDMData threadData, IFrameDMData frame, VisualizerExecutionState state, VisualizerModel model, RequestMonitor rm) { int cpuID = Integer.parseInt(cpuContext.getId()); VisualizerCPU cpu = model.getCPU(cpuID); int coreID = Integer.parseInt(coreContext.getId()); VisualizerCore core = cpu.getCore(coreID); if (state == null) { state = VisualizerExecutionState.RUNNING; } IMIProcessDMContext processContext = DMContexts.getAncestorOfType(execContext, IMIProcessDMContext.class); int pid = Integer.parseInt(processContext.getProcId()); int tid; try { tid = Integer.parseInt(execContext.getThreadId()); } catch (NumberFormatException e) { rm.setStatus(new Status(IStatus.ERROR, MulticoreVisualizerUIPlugin.PLUGIN_ID, IStatus.ERROR, "Unxepected thread id format:" + execContext.getThreadId(), e)); rm.done(); return; } String osTIDValue = threadData.getId(); int osTid = (osTIDValue == null) ? tid : Integer.parseInt(osTIDValue); VisualizerThread t = model.getThread(tid); if (t == null) { model.addThread(new VisualizerThread(core, pid, osTid, tid, state, frame)); } else { t.setCore(core); t.setTID(osTid); t.setState(state); t.setLocationInfo(frame); } rm.done(); }

Target:
protected void getThreadExecutionStateDone(ICPUDMContext cpuContext, ICoreDMContext coreContext, IMIExecutionDMContext execContext, IThreadDMData threadData, IFrameDMData frame, VisualizerExecutionState state, VisualizerModel model, RequestMonitor rm) { int cpuID = Integer.parseInt(cpuContext.getId()); VisualizerCPU cpu = model.getCPU(cpuID); int coreID = Integer.parseInt(coreContext.getId()); VisualizerCore core = cpu.getCore(coreID); if (state == null) { state = VisualizerExecutionState.RUNNING; } IMIProcessDMContext processContext = DMContexts.getAncestorOfType(execContext, IMIProcessDMContext.class); int pid = Integer.parseInt(processContext.getProcId()); int tid; try { tid = Integer.parseInt(execContext.getThreadId()); } catch (NumberFormatException e) { rm.setStatus(new Status(IStatus.ERROR, MulticoreVisualizerUIPlugin.PLUGIN_ID, IStatus.ERROR, "Unxepected thread id format:" + execContext.getThreadId(), e)); rm.done(); assert false : THE_THREAD_ID_DOES_NOT_CONVERT_TO_AN_INTEGER + execContext.getThreadId(); return; } String osTIDValue = threadData.getId(); int osTid = (osTIDValue == null) ? tid : Integer.parseInt(osTIDValue); VisualizerThread t = model.getThread(tid); if (t == null) { model.addThread(new VisualizerThread(core, pid, osTid, tid, state, frame)); } else { t.setCore(core); t.setTID(osTid); t.setState(state); t.setLocationInfo(frame); } rm.done(); }
Source:
public char[] getEOSCharacters(String languageCode) { if ("th".equals(languageCode) || "tha".equals(languageCode)) { return thEosCharacters; } else if ("pt".equals(languageCode) || "por".equals(languageCode)) { return ptEosCharacters; } else if ("ja".equals(languageCode) || "jpn".equals(languageCode)) { return jaEosCharacters; } return defaultEosCharacters; }

Target:
public char[] getEOSCharacters(String languageCode) { if ("th".equals(languageCode) || "tha".equals(languageCode)) { return thEosCharacters; } else if ("pt".equals(languageCode) || "por".equals(languageCode)) { return ptEosCharacters; } else if ("jpn".equals(languageCode)) { return jpnEosCharacters; } return defaultEosCharacters; }
Source:
protected void performWorkload(BaseSubscriber<Document> baseSubscriber, long i) throws Exception { Flux<Document> obs; boolean readyMyWrite = RandomUtils.nextBoolean(); if (readyMyWrite) { int j = Math.toIntExact(Math.floorMod(i, 3)); switch (j) { case 0: obs = writeDocument() .flatMap(this::readDocument); break; case 1: obs = writeDocument() .flatMap(d -> singlePartitionQuery(d) .switchIfEmpty(Flux.error(new NotFoundException( "couldn't find my write in a single partition query!")))); break; case 2: obs = writeDocument() .flatMap(d -> xPartitionQuery(generateQuery(d)) .switchIfEmpty(Flux.error(new NotFoundException( "couldn't find my write in a cross partition query!")))); break; default: assert false; throw new IllegalStateException(); } } else { int j = Math.toIntExact(Math.floorMod(i, 4)); switch (j) { case 0: obs = writeDocument(); break; case 1: obs = readDocument(cache.get(cacheKey())); break; case 2: obs = singlePartitionQuery(cache.get(cacheKey())) .switchIfEmpty(Flux.error(new NotFoundException( "couldn't find my cached write in a single partition query!"))); break; case 3: obs = xPartitionQuery(generateRandomQuery()) .switchIfEmpty(Flux.error(new NotFoundException( "couldn't find my cached write in a cross partition query!"))); break; default: assert false; throw new IllegalStateException(); } } concurrencyControlSemaphore.acquire(); logger.debug("concurrencyControlSemaphore: {}", concurrencyControlSemaphore); try { obs.subscribeOn(Schedulers.parallel()).subscribe(baseSubscriber); } catch (Throwable error) { concurrencyControlSemaphore.release(); logger.error("subscription failed due to ", error); } }

Target:
protected void performWorkload(BaseSubscriber<Document> baseSubscriber, long i) throws Exception { Flux<Document> obs; boolean readyMyWrite = RandomUtils.nextBoolean(); if (readyMyWrite) { int j = Math.toIntExact(Math.floorMod(i, 3)); switch (j) { case 0: obs = writeDocument() .flatMap(this::readDocument); break; case 1: obs = writeDocument() .flatMap(d -> singlePartitionQuery(d) .switchIfEmpty(Flux.error(new NotFoundException( "couldn't find my write in a single partition query!")))); break; case 2: obs = writeDocument() .flatMap(d -> xPartitionQuery(generateQuery(d)) .switchIfEmpty(Flux.error(new NotFoundException( "couldn't find my write in a cross partition query!")))); break; default: assert false; throw new IllegalStateException(); } } else { int j = Math.toIntExact(Math.floorMod(i, 4)); switch (j) { case 0: obs = writeDocument(); break; case 1: obs = readDocument(cache.get(cacheKey())); break; case 2: obs = singlePartitionQuery(cache.get(cacheKey())) .switchIfEmpty(Flux.error(new NotFoundException( "couldn't find my cached write in a single partition query!"))); break; case 3: obs = xPartitionQuery(generateRandomQuery()) .switchIfEmpty(Flux.error(new NotFoundException( "couldn't find my cached write in a cross partition query!"))); break; default: assert false; throw new IllegalStateException(); } } concurrencyControlSemaphore.acquire(); logger.debug("concurrencyControlSemaphore: {}", concurrencyControlSemaphore); obs.subscribeOn(Schedulers.parallel()).subscribe(baseSubscriber); }
Source:
private void ensureAccountNameMatch(Account account, RestRequest restRequest) throws RestServiceException { String accountNameFromHeader = getHeader(restRequest.getArgs(), Headers.TARGET_ACCOUNT_NAME, false); if (accountNameFromHeader != null && !accountNameFromHeader.equals(account.getName())) { throw new RestServiceException("Invalid account for putting blob", RestServiceErrorCode.InvalidAccount); } }

Target:
private void ensureAccountNameMatch(Account account, RestRequest restRequest) throws RestServiceException { String accountNameFromHeader = getHeader(restRequest.getArgs(), Headers.TARGET_ACCOUNT_NAME, false); if (accountNameFromHeader != null && !accountNameFromHeader.equals(account.getName())) { throw new RestServiceException("Error occurs when locating account", RestServiceErrorCode.InternalServerError); } }
Source:
public void setDeploymentHandlerFactory(DeploymentHandlerFactory deploymentHandlerFactory) { this.deploymentHandlerFactory = deploymentHandlerFactory; }

Target:
public ProcessEngineConfigurationImpl setDeploymentHandlerFactory(DeploymentHandlerFactory deploymentHandlerFactory) { this.deploymentHandlerFactory = deploymentHandlerFactory; return this; }
Source:
private API addSummary(API api) { HashMap<String, Integer> stats = getSystemStatistics(); ApplicationMode appMode = getCurrent().get(ApplicationMode.class); ApiSummary summary = new ApiSummary(); if (appMode != ApplicationMode.GlusterOnly) { summary.setVMs(new VMs()); summary.getVMs().setTotal(get(stats, "total_vms")); summary.getVMs().setActive(get(stats, "active_vms")); } summary.setHosts(new Hosts()); summary.getHosts().setTotal(get(stats, "total_vds")); summary.getHosts().setActive(get(stats, "active_vds")); summary.setUsers(new Users()); summary.getUsers().setTotal(get(stats, "total_users")); summary.getUsers().setActive(get(stats, "active_users")); if (appMode != ApplicationMode.GlusterOnly) { summary.setStorageDomains(new StorageDomains()); summary.getStorageDomains().setTotal(get(stats, "total_storage_domains")); summary.getStorageDomains().setActive(get(stats, "active_storage_domains")); } api.setSummary(summary); return api; }

Target:
private API addSummary(API api) { HashMap<String, Integer> stats = getSystemStatistics(); ApiSummary summary = new ApiSummary(); if (appMode != ApplicationMode.GlusterOnly) { summary.setVMs(new VMs()); summary.getVMs().setTotal(get(stats, "total_vms")); summary.getVMs().setActive(get(stats, "active_vms")); } summary.setHosts(new Hosts()); summary.getHosts().setTotal(get(stats, "total_vds")); summary.getHosts().setActive(get(stats, "active_vds")); summary.setUsers(new Users()); summary.getUsers().setTotal(get(stats, "total_users")); summary.getUsers().setActive(get(stats, "active_users")); summary.setStorageDomains(new StorageDomains()); summary.getStorageDomains().setTotal(get(stats, "total_storage_domains")); summary.getStorageDomains().setActive(get(stats, "active_storage_domains")); api.setSummary(summary); return api; }
Source:
private static void initMomPoliciesSeverities() { severities.put(AuditLogType.USER_UPDATED_MOM_POLICIES, AuditLogSeverity.NORMAL); }

Target:
private static void initMomPoliciesSeverities() { severities.put(AuditLogType.USER_UPDATED_MOM_POLICIES, AuditLogSeverity.NORMAL); severities.put(AuditLogType.USER_FAILED_TO_UPDATE_MOM_POLICIES, AuditLogSeverity.WARNING); }
Source:
public int openTaskDeactivationDialog(List<IEditorReference> dirtyRefs) { StringBuilder editorsString = new StringBuilder(); for (IEditorReference ref : dirtyRefs) { editorsString.append(ref.getTitle()); editorsString.append('\n'); } return new MessageDialog(WorkbenchUtil.getShell(), "Task Deactivation", null, "The following editors have unsaved changes. Do you still want to deactivate the task?\n\n" + editorsString, MessageDialog.QUESTION, new String[] { "Deactivate Task and Save All", "Deactivate and Save Some...", IDialogConstants.CANCEL_LABEL }, 1).open(); }

Target:
public int openTaskDeactivationDialog(List<IEditorReference> dirtyRefs) { Iterable<String> iter = Iterables.transform(dirtyRefs, new Function<IEditorReference, String>() { @Override public String apply(IEditorReference ref) { return ref.getTitle(); } }); Joiner joiner = Joiner.on('\n'); return new MessageDialog(WorkbenchUtil.getShell(), "Task Deactivation", null, "The following editors have unsaved changes. Do you still want to deactivate the task?\n\n" + joiner.join(iter), MessageDialog.QUESTION, new String[] { "Deactivate Task and Save All", "Deactivate and Save Some...", IDialogConstants.CANCEL_LABEL }, 1).open(); }
Source:
private ByteBuf fillHeader(ByteBufAllocator allocator) { buffer.setAllocator(allocator); ByteBuf headerBuf = allocateBuffer(allocator, ID, MESSAGE_HEADER_LENGTH, bufferSize, false); receiverId.writeTo(headerBuf); headerBuf.writeInt(sequenceNumber); headerBuf.writeInt(backlog); headerBuf.writeByte(dataType.ordinal()); headerBuf.writeBoolean(isCompressed); headerBuf.writeInt(buffer.readableBytes()); return headerBuf; }

Target:
private ByteBuf fillHeader(ByteBufAllocator allocator) { ByteBuf headerBuf = allocateBuffer(allocator, ID, MESSAGE_HEADER_LENGTH, bufferSize, false); receiverId.writeTo(headerBuf); headerBuf.writeInt(sequenceNumber); headerBuf.writeInt(backlog); headerBuf.writeByte(dataType.ordinal()); headerBuf.writeBoolean(isCompressed); headerBuf.writeInt(buffer.readableBytes()); return headerBuf; }
Source:
public void run() { try { cloudBlockBlob.uploadFromFile(tempFile.toString()); } catch (StorageException | IOException e) { throw new RuntimeException(e); } }

Target:
public void run() { try { cloudBlockBlob.uploadFromFile(TEMP_FILE_PATH); } catch (StorageException | IOException e) { throw new RuntimeException(e); } }
Source:
public void run() { Message message = null; while (!socket.isClosed()) { try { message = MessageUtils.getMessage(socket.getInputStream()); } catch (Exception e) { closeSocket(); break; } if (myThread.isInterrupted()) break; if (message == null || message.getType() == MessageType.BYE) break; if (message.getType() == MessageType.ERROR) { System.out.println(message.getText()); break; } if (nickname == null) if (message.getType() == MessageType.HELLO) nickname = message.getName(); else send(new Message(MessageType.ERROR, "", "Wrong message type")); else if (message.getType() == MessageType.MESSAGE) sendAll(message, true); } listeners.remove(this); System.out.println("user " + nickname + " disconnected"); if (message != null) sendAll(new Message(MessageType.MESSAGE, "server", "user " + message.getName() + " has disconnected"), true); }

Target:
public void run() { Message message = null; while (!socket.isClosed()) { try { message = MessageUtils.getMessage(socket.getInputStream()); } catch (Exception e) { closeSocket(); break; } if (myThread.isInterrupted()) break; if (message == null || message.getType() == MessageType.BYE) break; if (message.getType() == MessageType.ERROR) { System.out.println(message.getText()); break; } if (nickname == null) if (message.getType() == MessageType.HELLO) nickname = message.getName(); else send(new Message(MessageType.ERROR, "", "Wrong message type")); else if (message.getType() == MessageType.MESSAGE) sendAll(message, true); else kill(nickname); } listeners.remove(this); System.out.println("user " + nickname + " disconnected"); if (message != null) sendAll(new Message(MessageType.MESSAGE, "server", "user " + message.getName() + " has disconnected"), true); }
Source:
protected List<?> createOperationSet() { List<?> selection = getSelectedObjects(); if (selection.isEmpty() || !(selection.get(0) instanceof IGraphicalEditPart)) { selection = Collections.EMPTY_LIST; } else { selection = ToolUtilities.getSelectionWithoutDependants(selection); selection = Lists.newArrayList(Iterables.filter(selection, Predicates.not(Predicates.instanceOf(ConnectionEditPart.class)))); if (selection.size() < 3) { selection = Collections.EMPTY_LIST; } else { EditPart parent = ((EditPart) selection.get(0)).getParent(); int sideOfFirstSelection = PositionConstants.NONE; if (selection.get(0) instanceof IBorderItemEditPart) { sideOfFirstSelection = ((IBorderItemEditPart) selection.get(0)).getBorderItemLocator().getCurrentSideOfParent(); if (!isHorizontalAxisAuthorizedForBorderNode(sideOfFirstSelection) && !isVerticalAxisAuthorizedForBorderNode(sideOfFirstSelection)) { selection = Collections.EMPTY_LIST; } } for (int i = 1; i < selection.size(); i++) { EditPart part = (EditPart) selection.get(i); if (part.getParent() != parent) { selection = Collections.EMPTY_LIST; break; } else if (sideOfFirstSelection != PositionConstants.NONE && !isABorderNodeOnSameAxis(part, sideOfFirstSelection)) { selection = Collections.EMPTY_LIST; break; } else { if (!isFreeFormContainerChildrenPresentation(selection)) { selection = Collections.EMPTY_LIST; } break; } } } } return selection; }

Target:
protected List<?> createOperationSet() { List<?> selection = getSelectedObjects(); if (selection.isEmpty() || !(selection.get(0) instanceof IGraphicalEditPart)) { selection = Collections.EMPTY_LIST; } else { selection = ToolUtilities.getSelectionWithoutDependants(selection); selection = Lists.newArrayList(Iterables.filter(selection, Predicates.not(Predicates.instanceOf(ConnectionEditPart.class)))); if (selection.size() < 3) { selection = Collections.EMPTY_LIST; } else { EditPart parent = ((EditPart) selection.get(0)).getParent(); int sideOfFirstSelection = PositionConstants.NONE; if (selection.get(0) instanceof IBorderItemEditPart) { sideOfFirstSelection = ((IBorderItemEditPart) selection.get(0)).getBorderItemLocator().getCurrentSideOfParent(); if (!isHorizontalAxisAuthorizedForBorderNode(sideOfFirstSelection) && !isVerticalAxisAuthorizedForBorderNode(sideOfFirstSelection)) { selection = Collections.EMPTY_LIST; } } for (int i = 1; i < selection.size(); i++) { EditPart part = (EditPart) selection.get(i); if (part.getParent() != parent) { selection = Collections.EMPTY_LIST; break; } else if (sideOfFirstSelection != PositionConstants.NONE && !isABorderNodeOnSameAxis(part, sideOfFirstSelection)) { selection = Collections.EMPTY_LIST; break; } else if (!isFreeFormContainerChildrenPresentation(part)) { selection = Collections.EMPTY_LIST; } break; } } } return selection; }
Source:
public void cleanUp() { try { FileUtils.deleteDirectory(taskStoreDir); } catch (IOException e) { Assert.fail(); } }

Target:
public void cleanUp() { try { FileUtils.deleteDirectory(taskStoreDir); } catch (IOException e) { LOG.error("Deletion of directory: resulted in the exception: {}.", new Object[]{taskStoreDir, e}); Assert.fail(e.getMessage()); } }
Source:
public Aggregator factorize(ColumnSelectorFactory metricFactory) { return new DoubleFirstAggregator( name, metricFactory.makeFloatColumnSelector(fieldName), metricFactory.makeLongColumnSelector(Column.TIME_COLUMN_NAME) ); }

Target:
public Aggregator factorize(ColumnSelectorFactory metricFactory) { return new DoubleFirstAggregator( name, metricFactory.makeLongColumnSelector(Column.TIME_COLUMN_NAME), metricFactory.makeFloatColumnSelector(fieldName) ); }
Source:
private PlanNode extract(PlanNode node) { return resolveGroupReferences(node, Lookup.from(planNode -> ImmutableList.of(this.resolve(planNode)).stream())); }

Target:
private PlanNode extract(PlanNode node) { return resolveGroupReferences(node, Lookup.from(planNode -> Stream.of(this.resolve(planNode)))); }
Source:
protected Stream<T> fetchFromProvider(int offset, int limit) { Stream<T> stream = Stream.empty(); QueryTrace query = new QueryTrace(offset, pageSize, backEndSorting, inMemorySorting, filter); final int pages = (int) Math.ceil((double) limit / pageSize); if (limit > pageSize) { for (int page = 0; page < pages; page++) { final int newOffset = offset + page * pageSize; query = new QueryTrace(newOffset, pageSize, backEndSorting, inMemorySorting, filter); stream = Stream.concat(stream, getDataProvider().fetch(query)); } } else { stream = getDataProvider().fetch(query); } if (stream.isParallel()) { LoggerFactory.getLogger(DataCommunicator.class) .debug("Data provider has returned " + "parallel stream on 'fetch' call", getDataProvider().getClass()); stream = stream.collect(Collectors.toList()).stream(); assert !stream.isParallel(); } SizeVerifier verifier = new SizeVerifier<>(pages * pageSize); stream = stream.peek(verifier); if (!query.isLimitCalled() && !query.isPageSizeCalled()) { throw new IllegalStateException( getInvalidContractMessage("getLimit or getPageSize")); } if (!query.isOffsetCalled() && !query.isPageCalled()) { throw new IllegalStateException( getInvalidContractMessage("getOffset or getPage")); } return stream; }

Target:
protected Stream<T> fetchFromProvider(int offset, int limit) { Stream<T> stream = Stream.empty(); QueryTrace query = new QueryTrace(offset, pageSize, backEndSorting, inMemorySorting, filter); final int pages = (limit + pageSize - 1) / pageSize; if (limit > pageSize) { for (int page = 0; page < pages; page++) { final int newOffset = offset + page * pageSize; query = new QueryTrace(newOffset, pageSize, backEndSorting, inMemorySorting, filter); stream = Stream.concat(stream, getDataProvider().fetch(query)); } } else { stream = getDataProvider().fetch(query); } if (stream.isParallel()) { LoggerFactory.getLogger(DataCommunicator.class) .debug("Data provider has returned " + "parallel stream on 'fetch' call", getDataProvider().getClass()); stream = stream.collect(Collectors.toList()).stream(); assert !stream.isParallel(); } SizeVerifier verifier = new SizeVerifier<>(pages * pageSize); stream = stream.peek(verifier); if (!query.isLimitCalled()) { throw new IllegalStateException( getInvalidContractMessage("getLimit or getPageSize")); } if (!query.isOffsetCalled()) { throw new IllegalStateException( getInvalidContractMessage("getOffset or getPage")); } return stream; }
Source:
public static String adHocSQLFromInvocationForDebug(StoredProcedureInvocation invocation) { assert(invocation.getProcName().startsWith("@AdHoc")); ParameterSet params = invocation.getParams(); assert(params.size() == 2 || params.size() == 3); byte[] serializedBatchData = (byte[]) params.getParam(params.size() - 1); Pair<Object[], AdHocPlannedStatement[]> data = decodeSerializedBatchData(serializedBatchData); Object[] userparams = data.getFirst(); AdHocPlannedStatement[] statements = data.getSecond(); StringBuilder sb = new StringBuilder(); if (statements.length == 0) { sb.append("ONLYSLOW INVOCATION HAS NO SQL"); } else if (statements.length == 1) { sb.append(adHocSQLStringFromPlannedStatement(statements[0], userparams)); } else { sb.append("BEGIN READONLYSLOW_SQL_BATCH {\n"); for (AdHocPlannedStatement stmt : statements) { sb.append(adHocSQLStringFromPlannedStatement(stmt, userparams)).append("\n"); } sb.append("} END READONLYSLOW_SQL_BATCH"); } return sb.toString(); }

Target:
public static String adHocSQLFromInvocationForDebug(StoredProcedureInvocation invocation) { ParameterSet params = invocation.getParams(); assert(params.size() == 2 || params.size() == 3); byte[] serializedBatchData = (byte[]) params.getParam(params.size() - 1); Pair<Object[], AdHocPlannedStatement[]> data = decodeSerializedBatchData(serializedBatchData); Object[] userparams = data.getFirst(); AdHocPlannedStatement[] statements = data.getSecond(); StringBuilder sb = new StringBuilder(); if (statements.length == 0) { sb.append("READONLYSLOW INVOCATION HAS NO SQL"); } else if (statements.length == 1) { sb.append(adHocSQLStringFromPlannedStatement(statements[0], userparams)); } else { sb.append("BEGIN READONLYSLOW_SQL_BATCH {\n"); for (AdHocPlannedStatement stmt : statements) { sb.append(adHocSQLStringFromPlannedStatement(stmt, userparams)).append("\n"); } sb.append("} END READONLYSLOW_SQL_BATCH"); } return sb.toString(); }
Source:
public boolean isIgnoringSundamage() { return this.isPotionActive(ModPotions.sunscreen) || this.ignoreSundamageAction; }

Target:
public boolean isIgnoringSundamage() { return this.isPotionActive(ModPotions.sunscreen); }
Source:
public CompletableFuture<List<? extends TextEdit>> formatting(DocumentFormattingParams params) throws LanguageServerException { String fileUri = params.getTextDocument().getUri(); FormattingOptions options = params.getOptions(); if (options == null) { options = new FormattingOptions(); params.setOptions(options); } String projectPath = WsPathUtils.absolutize(extractProjectPath(fileUri)); String formatterPathSuffix = CHE_FOLDER + SEPARATOR + CHE_FORMATTER_XML; Path projectFormatterPath = Paths.get(projectPath, formatterPathSuffix); Path wsFormatterPath = Paths.get(PROJECTS_ROOT, formatterPathSuffix); if (Files.exists(projectFormatterPath)) { updateFormatterOptions(params, getFormatSettingsFromFile(projectFormatterPath.toFile())); } else if (Files.exists(wsFormatterPath)) { updateFormatterOptions(params, getFormatSettingsFromFile(wsFormatterPath.toFile())); } return wrapped.formatting(params); }

Target:
public CompletableFuture<List<? extends TextEdit>> formatting(DocumentFormattingParams params) throws LanguageServerException { String fileUri = params.getTextDocument().getUri(); FormattingOptions options = params.getOptions(); if (options == null) { options = new FormattingOptions(); params.setOptions(options); } updateFormatterOptions(params, fileUri); return wrapped.formatting(params); }
Source:
public boolean canHandle(Object source) { return (source!=null && source.getClass().isArray() && source.getClass().getComponentType().isPrimitive()) && byte.class.isAssignableFrom(source.getClass().getComponentType()); }

Target:
public boolean canHandle(Object source) { return (source != null && source.getClass().equals(byte[].class)); }
Source:
public static boolean hasTag(Tag tag, String keyword) { Pattern pattern = Pattern.compile(keyword, Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE); String value = getTranslatedPathToRoot(tag); return pattern.matcher(value).find(); }

Target:
public static boolean hasTag(Tag tag, String keyword) { Pattern pattern = Pattern.compile(keyword, Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE); String translatedValue = getTranslatedPathToRoot(tag); String value = getPathToRoot(tag); return pattern.matcher(translatedValue).find() || pattern.matcher(value).find(); }
Source:
CookiePageIterator() { try { dataStream = new DataInputStream(new FileInputStream(cookieFile)); dataStream.skipBytes((2 * SIZEOF_INT_BYTES) + (pageSizeArray.length * SIZEOF_INT_BYTES)); } catch (IOException ex) { logger.log(Level.WARNING, "Error occured creating DataInputStream", new Object[]{cookieFile.getName(), ex}); closeStream(); } }

Target:
CookiePageIterator() { if(pageSizeArray == null || pageSizeArray.length == 0) { return; } try { dataStream = new DataInputStream(new FileInputStream(cookieFile)); dataStream.skipBytes((2 * SIZEOF_INT_BYTES) + (pageSizeArray.length * SIZEOF_INT_BYTES)); } catch (IOException ex) { String errorMessage = String.format("An error occurred creating an input stream for %s", cookieFile.getName()); LOG.log(Level.WARNING, errorMessage, ex); closeStream(); } }
Source:
public Set<String> deleteBundleAndDependenciesOlderThan(final Date olderThan, final User user) throws DotDataException { if(olderThan.after(new Date())){ throw new IllegalArgumentException("To avoid deleting bundles that publish in the future, the date can not be after the current date"); } final ImmutableSet.Builder<String> bundlesDeleted = new ImmutableSet.Builder<>(); final boolean isAdmin = this.userAPI.isCMSAdmin(user); final int bundleSleepCount = Config.getIntProperty ("bundle.sleep.count", 10); final long millisBundleSleep = Config.getLongProperty("bundle.sleep.millis", 25l); final MutableInt deletedCount = new MutableInt(0); try { Logger.info(this, "Deleting bundles older than: " + olderThan + " by the user :" + user.getUserId()); try (final Stream<String> bundleIds = this.getOlderBundleIds(olderThan, user.getUserId(), isAdmin)) { bundleIds.forEachOrdered(bundleId -> { this.internalDeleteBundleAndDependenciesThrowRuntime(bundleId, user, deletedCount.getValue(), bundleSleepCount, millisBundleSleep); bundlesDeleted.add(bundleId); deletedCount.increment(); }); } } catch (IOException e) { throw new DotDataException(e); } return bundlesDeleted.build(); }

Target:
public Set<String> deleteBundleAndDependenciesOlderThan(final Date olderThan, final User user) throws DotDataException { if(olderThan.after(new Date())){ Logger.error(this,"To avoid deleting bundles that publish in the future, the date can not be after the current date"); throw new IllegalArgumentException("To avoid deleting bundles that publish in the future, the date can not be after the current date"); } final ImmutableSet.Builder<String> bundlesDeleted = new ImmutableSet.Builder<>(); final boolean isAdmin = this.userAPI.isCMSAdmin(user); final int bundleSleepCount = Config.getIntProperty ("bundle.sleep.count", 10); final long millisBundleSleep = Config.getLongProperty("bundle.sleep.millis", 25l); final MutableInt deletedCount = new MutableInt(0); try { Logger.info(this, "Deleting bundles older than: " + olderThan + " by the user :" + user.getUserId()); try (final Stream<String> bundleIds = this.getOlderBundleIds(olderThan, user.getUserId(), isAdmin)) { bundleIds.forEachOrdered(bundleId -> { this.internalDeleteBundleAndDependenciesThrowRuntime(bundleId, user, deletedCount.getValue(), bundleSleepCount, millisBundleSleep); bundlesDeleted.add(bundleId); deletedCount.increment(); }); } } catch (IOException e) { Logger.error(this,"Error Removing bundles older than: " + olderThan + " by the user :" + user.getUserId(),e); throw new DotDataException(e); } return bundlesDeleted.build(); }
Source:
public String toString() { return String.format("Volume %s can only be used on host %s(%s)", volumeName, hostName, hostId); }

Target:
public String toString() { return String.format("Volume %s(%s) can only be used on host %s(%s)", volumeName, volumeId, hostName, hostId); }
Source:
public void checkDebug() { if(getVertexId().toString().equals("AGACCCATGCAGCGGGTCAGG")) System.out.println("stop"); debug = getContext().getConfiguration().get(GenomixJobConf.DEBUG_KMERS) != null; if (problemKmers == null) { problemKmers = new ArrayList<VKmer>(); if (getContext().getConfiguration().get(GenomixJobConf.DEBUG_KMERS) != null) { for (String kmer : getContext().getConfiguration().get(GenomixJobConf.DEBUG_KMERS).split(",")) { problemKmers.add(new VKmer(kmer)); } Node.problemKmers = problemKmers; } } verbose = false; for (VKmer problemKmer : problemKmers) { verbose |= debug && (getVertexValue().getNode().findEdge(problemKmer) != null || getVertexId().equals(problemKmer)); } }

Target:
public void checkDebug() { debug = getContext().getConfiguration().get(GenomixJobConf.DEBUG_KMERS) != null; if (problemKmers == null) { problemKmers = new ArrayList<VKmer>(); if (getContext().getConfiguration().get(GenomixJobConf.DEBUG_KMERS) != null) { for (String kmer : getContext().getConfiguration().get(GenomixJobConf.DEBUG_KMERS).split(",")) { problemKmers.add(new VKmer(kmer)); } Node.problemKmers = problemKmers; } } verbose = false; for (VKmer problemKmer : problemKmers) { verbose |= debug && (getVertexValue().getNode().findEdge(problemKmer) != null || getVertexId().equals(problemKmer)); } }
Source:
public Optional<String> explainExtras() { final StringBuilder sb = new StringBuilder(); sb.append("METADATA"); if (metadataAlias != null) { sb.append(" FROM "); sb.append(metadataAlias); } if (isVirtual) { sb.append(" VIRTUAL"); } return Optional.of(sb.toString()); }

Target:
public Optional<String> explainExtras() { final StringBuilder sb = new StringBuilder(); sb.append("METADATA"); if (metadataAlias != null) { sb.append(" FROM "); sb.append("'"); sb.append(metadataAlias); sb.append("'"); } if (isVirtual) { sb.append(" VIRTUAL"); } return Optional.of(sb.toString()); }
Source:
public InDbTimestampBoundStore getStore() { return InDbTimestampBoundStore.create( kvs.getConnectionManager(), AtlasDbConstants.TIMELOCK_TIMESTAMP_TABLE, DbkvsPostgresTestSuite.getKvsConfig().ddl().tablePrefix()); }

Target:
public InDbTimestampBoundStore getStore() { return InDbTimestampBoundStore.create( kvs.getConnectionManager(), AtlasDbConstants.TIMESTAMP_TABLE, DbkvsPostgresTestSuite.getKvsConfig().ddl().tablePrefix()); }
Source:
Predicate<Entry<Key,Value>> getScanPredicate() { final Range range = getRange(); return input -> { if (range != null && !range.contains(input.getKey())) return false; return true; }; }

Target:
Predicate<Entry<Key,Value>> getScanPredicate() { final Range range = getRange(); return input -> range == null || range.contains(input.getKey()); }