auphong2707/dl4se-code-review-dataset huggingface dataset:
Source:
private void verifyLogs() { String[] extension = {"log"}; File dir = logDir.toFile(); if (!dir.exists()) { throw new UnrecoverableCorfuError("Stream log data directory doesn't exists"); } Collection<File> files = FileUtils.listFiles(dir, extension, true); for (File file : files) { LogHeader header; EnumSet<StandardOpenOption> options = EnumSet.of( StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.SPARSE ); try (FileChannel fileChannel = FileChannel.open(file.toPath(), options)) { header = parseHeader(fileChannel); } catch (IOException e) { throw new IllegalStateException("Invalid header: " + file.getAbsolutePath(), e); } if (header == null) { log.warn("verifyLogs: Ignoring partially written header in {}", file.getAbsoluteFile()); continue; } if (header.getVersion() != VERSION) { String msg = String.format("Log version %s for %s should match the LogUnit log version %s", header.getVersion(), file.getAbsoluteFile(), VERSION); throw new IllegalStateException(msg); } if (verify && !header.getVerifyChecksum()) { String msg = String.format("Log file %s not generated with check sums, can't verify!", file.getAbsoluteFile()); throw new IllegalStateException(msg); } } }

Target:
private void verifyLogs() { String[] extension = {"log"}; File dir = logDir.toFile(); if (!dir.exists()) { throw new UnrecoverableCorfuError("Stream log data directory doesn't exists"); } Collection<File> files = FileUtils.listFiles(dir, extension, true); for (File file : files) { LogHeader header; try (FileChannel fileChannel = FileChannel.open(file.toPath())) { header = parseHeader(fileChannel); } catch (IOException e) { throw new IllegalStateException("Invalid header: " + file.getAbsolutePath(), e); } if (header == null) { log.warn("verifyLogs: Ignoring partially written header in {}", file.getAbsoluteFile()); continue; } if (header.getVersion() != VERSION) { String msg = String.format("Log version %s for %s should match the LogUnit log version %s", header.getVersion(), file.getAbsoluteFile(), VERSION); throw new IllegalStateException(msg); } if (verify && !header.getVerifyChecksum()) { String msg = String.format("Log file %s not generated with check sums, can't verify!", file.getAbsoluteFile()); throw new IllegalStateException(msg); } } }
Source:
public InputStream openInputStream() throws IOException { return new CloseShieldInputStream(inputStreamSupplier.get()); }

Target:
public InputStream openInputStream() throws IOException { try { return new CloseShieldInputStream(inputStreamSupplier.create()); } catch (IOException ioException) { throw ioException; } catch (Exception e) { throw Exceptions.handle() .error(e) .withSystemErrorMessage("Failed to unzip file from an archive: %s (%s)") .handle(); } }
Source:
protected static Optional<String> getEntityIdAsParameter(final Service service) { try { final URIBuilder builder = new URIBuilder(service.getId()); final Optional<NameValuePair> param = builder.getQueryParams() .stream() .filter(p -> p.getName().equals(PARAMETER_ENTITY_ID)) .findFirst(); if (param.isPresent()) { LOGGER.debug("Found Entity Id in Service id = " + param.get().getValue()); return Optional.of(param.get().getValue()); } final HttpServletRequest request = WebUtils.getHttpServletRequestFromExternalWebflowContext(); if (request != null && StringUtils.isNotBlank(request.getQueryString())) { final String[] query = request.getQueryString().split("&"); final Optional<String> paramRequest = Arrays.stream(query) .map(p -> { final List<String> params = Splitter.on("=").splitToList(p); return Pair.of(params.get(0), params.get(1)); }) .filter(p -> p.getKey().equals(PARAMETER_ENTITY_ID)) .map(Pair::getValue) .map(ShibbolethIdPEntityIdAuthenticationServiceSelectionStrategy::decode) .findFirst(); LOGGER.debug("Found entity id as part of request url = " + paramRequest); return paramRequest; } } catch (final Exception e) { LOGGER.error(e.getMessage(), e); } return Optional.empty(); }

Target:
protected static Optional<String> getEntityIdAsParameter(final Service service) { try { final URIBuilder builder = new URIBuilder(service.getId()); final Optional<NameValuePair> param = builder.getQueryParams() .stream() .filter(p -> p.getName().equals(PARAMETER_ENTITY_ID)) .findFirst(); if (param.isPresent()) { LOGGER.debug("Found Entity Id in Service id [{}]", param.get().getValue()); return Optional.of(param.get().getValue()); } final HttpServletRequest request = WebUtils.getHttpServletRequestFromExternalWebflowContext(); if (request != null && StringUtils.isNotBlank(request.getQueryString())) { final String[] query = request.getQueryString().split("&"); final Optional<String> paramRequest = Arrays.stream(query) .map(p -> { final List<String> params = Splitter.on("=").splitToList(p); return Pair.of(params.get(0), params.get(1)); }) .filter(p -> p.getKey().equals(PARAMETER_ENTITY_ID)) .map(Pair::getValue) .map(EncodingUtils::urlDecode) .findFirst(); LOGGER.debug("Found entity id as part of request url [{}]", paramRequest); return paramRequest; } } catch (final Exception e) { LOGGER.error(e.getMessage(), e); } return Optional.empty(); }
Source:
public void getVirtualAttributesByPrimaryHolder() throws Exception { System.out.println(CLASS_NAME + "getVirtualAttributesByPrimaryHolder"); AttributeDefinition memberVirtAttr = setUpVirtualMemberAttribute(); AttributeDefinition memberResourceVirtAttr = setUpVirtualMemberResourceAttribute(); setUpGroupAttribute(); setUpMemberGroupAttributeDefinition(); List<Attribute> attrs = cacheManager.getVirtualAttributes(Holder.HolderType.MEMBER, null); assertTrue("result should contain virtual member attribute definition", attrs.contains(new Attribute(memberVirtAttr))); assertTrue("result should not contain virtual member-resource attribute definition", !attrs.contains(new Attribute(memberResourceVirtAttr))); assertTrue("it should return only 1 attribute", attrs.size() == 1); }

Target:
public void getVirtualAttributesByPrimaryHolder() throws Exception { System.out.println(CLASS_NAME + "getVirtualAttributesByPrimaryHolder"); AttributeDefinition memberVirtAttr = setUpVirtualMemberAttribute(); AttributeDefinition memberResourceVirtAttr = setUpVirtualMemberResourceAttribute(); setUpGroupAttribute(); setUpMemberGroupAttributeDefinition(); List<Attribute> attrs = cacheManager.getVirtualAttributes(Holder.HolderType.MEMBER, null); assertTrue("result should contain virtual member attribute definition", attrs.contains(memberVirtAttr)); assertTrue("result should not contain virtual member-resource attribute definition", !attrs.contains(memberResourceVirtAttr)); assertTrue("it should return only 1 attribute", attrs.size() == 1); }
Source:
public String replaceSelection(String value, boolean collapseSelection) { Selection selection = getSession().getSelection(); String oldValue = getSession().getTextRange(selection.getRange()); value = StringUtil.normalizeNewLines(value); replaceSelection(value); if (collapseSelection) { collapseSelection(false); } return oldValue; }

Target:
public String replaceSelection(String value, boolean collapseSelection) { Selection selection = getSession().getSelection(); String oldValue = getSession().getTextRange(selection.getRange()); replaceSelection(value); if (collapseSelection) { collapseSelection(false); } return oldValue; }
Source:
private void setupMultiExecutorMode() { String filters = azkProps.getString(AZKABAN_EXECUTOR_SELECTOR_FILTERS, ""); if (filters != null) { filterList = Arrays.asList(StringUtils.split(filters, ",")); } Map<String, String> compListStrings = azkProps.getMapByPrefix(AZKABAN_EXECUTOR_SELECTOR_COMPARATOR_PREFIX); if (compListStrings != null) { comparatorWeightsMap = new TreeMap<String, Integer>(); for (Map.Entry<String, String> entry : compListStrings.entrySet()) { comparatorWeightsMap.put(entry.getKey(), Integer.valueOf(entry.getValue())); } } executorInforRefresherService = Executors.newFixedThreadPool(azkProps.getInt( AZKABAN_EXECUTORINFO_REFRESH_MAX_THREADS, 5)); queueProcessor = new QueueProcessorThread(azkProps.getBoolean( AZKABAN_QUEUEPROCESSING_ENABLED, true), azkProps.getLong( AZKABAN_ACTIVE_EXECUTOR_REFRESHINTERVAL_IN_MS, 1000), azkProps.getInt( AZKABAN_ACTIVE_EXECUTOR_REFRESHINTERVAL_IN_NUM_FLOW, 10)); queueProcessor.start(); }

Target:
private void setupMultiExecutorMode() { String filters = azkProps.getString(AZKABAN_EXECUTOR_SELECTOR_FILTERS, ""); if (filters != null) { filterList = Arrays.asList(StringUtils.split(filters, ",")); } Map<String, String> compListStrings = azkProps.getMapByPrefix(AZKABAN_EXECUTOR_SELECTOR_COMPARATOR_PREFIX); if (compListStrings != null) { comparatorWeightsMap = new TreeMap<String, Integer>(); for (Map.Entry<String, String> entry : compListStrings.entrySet()) { comparatorWeightsMap.put(entry.getKey(), Integer.valueOf(entry.getValue())); } } executorInforRefresherService = Executors.newFixedThreadPool(azkProps.getInt( AZKABAN_EXECUTORINFO_REFRESH_MAX_THREADS, 5)); queueProcessor = new QueueProcessorThread(azkProps.getBoolean( AZKABAN_QUEUEPROCESSING_ENABLED, true), azkProps.getLong( AZKABAN_ACTIVE_EXECUTOR_REFRESH_IN_MS, 1000), azkProps.getInt( AZKABAN_ACTIVE_EXECUTOR_REFRESH_IN_NUM_FLOW, 10)); queueProcessor.start(); }
Source:
public Optional<Object> nextMarker() { return marker == null ? Optional.absent() : Optional.of((Object) marker); }

Target:
public Optional<Object> nextMarker() { return Optional.<Object>fromNullable(marker); }
Source:
private <T extends ObjectId> Iterable<FoundObject<T>> findAll( Iterable<T> objectIds) throws IOException { Collection<T> pending = new LinkedList<>(); for (T id : objectIds) { pending.add(id); } PackList packList = db.getPackList(); List<FoundObject<T>> r = new ArrayList<>(); findAllImpl(packList, pending, r); if (packList.dirty()) { findAllImpl(db.scanPacks(packList), pending, r); } for (T t : pending) { r.add(new FoundObject<T>(t)); } Collections.sort(r, FOUND_OBJECT_SORT); return r; }

Target:
private <T extends ObjectId> Iterable<FoundObject<T>> findAll( Iterable<T> objectIds) throws IOException { Collection<T> pending = new LinkedList<>(); for (T id : objectIds) { pending.add(id); } PackList packList = db.getPackList(); List<FoundObject<T>> r = new ArrayList<>(); findAllImpl(packList, pending, r); if (!pending.isEmpty() && packList.dirty()) { findAllImpl(db.scanPacks(packList), pending, r); } for (T t : pending) { r.add(new FoundObject<T>(t)); } Collections.sort(r, FOUND_OBJECT_SORT); return r; }
Source:
private OnHeapValueHolder<V> setAccessTimeAndExpiryThenReturnMappingUnderLock(K key, OnHeapValueHolder<V> valueHolder, long now, StoreEventSink<K, V> eventSink) { Duration duration = Duration.ZERO; try { duration = expiry.getExpiryForAccess(key, valueHolder.value()); } catch (RuntimeException re) { LOG.error("Expiry computation caused an exception - Expiry duration will be 0 ", re); } valueHolder.accessed(now, duration); if (Duration.ZERO.equals(duration)) { onExpiration(key, valueHolder, eventSink); return null; } return valueHolder; }

Target:
private OnHeapValueHolder<V> setAccessTimeAndExpiryThenReturnMappingUnderLock(K key, OnHeapValueHolder<V> valueHolder, long now, StoreEventSink<K, V> eventSink) { Duration duration = Duration.ZERO; try { duration = expiry.getExpiryForAccess(key, valueHolder.value()); } catch (RuntimeException re) { LOG.error("Expiry computation caused an exception - Expiry duration will be 0 ", re); } valueHolder.accessed(now, duration); if (Duration.ZERO.equals(duration)) { fireOnExpirationEvent(key, valueHolder, eventSink); return null; } return valueHolder; }
Source:
private void plotPlayerStatistics(PlayerStatistics result) { XYChart.Series<Long, Integer> series = new XYChart.Series<>(); series.setName("Player rating"); List<XYChart.Data<Long, Integer>> values = new ArrayList<>(); for (RatingInfo ratingInfo : result.getValues()) { int minRating = RatingUtil.getGlobalRating(ratingInfo); LocalDateTime dateTime = LocalDate.from(ratingInfo.getDate()).atTime(ratingInfo.getTime()); values.add(new XYChart.Data<>(dateTime.atZone(ZoneId.systemDefault()).toEpochSecond(), minRating)); } series.getData().setAll(FXCollections.observableList(values)); rating90DaysChart.getData().setAll(series); }

Target:
private void plotPlayerStatistics(PlayerStatistics result) { XYChart.Series<Long, Integer> series = new XYChart.Series<>(); series.setName("Player rating"); List<XYChart.Data<Long, Integer>> values = new ArrayList<>(); for (RatingInfo ratingInfo : result.getValues()) { int minRating = RatingUtil.getRating(ratingInfo); LocalDateTime dateTime = LocalDate.from(ratingInfo.getDate()).atTime(ratingInfo.getTime()); values.add(new XYChart.Data<>(dateTime.atZone(ZoneId.systemDefault()).toEpochSecond(), minRating)); } series.getData().setAll(FXCollections.observableList(values)); rating90DaysChart.getData().setAll(series); }
Source:
public void commitBranch(Artifact art, Branch branch, boolean isArchiveSource) { IOperation operation; try { operation = AtsBranchManager.commitWorkingBranch((TeamWorkFlowArtifact) art, false, false, branch, isArchiveSource); Operations.executeAsJob(operation, true); } catch (OseeCoreException ex) { OseeLog.log(Activator.class, Level.SEVERE, ex.toString(), ex); } }

Target:
public void commitBranch(Artifact art, Branch branch, boolean isArchiveSource) { if (art instanceof TeamWorkFlowArtifact) { IOperation operation; try { operation = AtsBranchManager.commitWorkingBranch((TeamWorkFlowArtifact) art, false, false, branch, isArchiveSource); Operations.executeAsJob(operation, true); } catch (OseeCoreException ex) { OseeLog.log(Activator.class, Level.SEVERE, ex.toString(), ex); } } }
Source:
protected void onCollectionLoaded(Collection col) { super.onCollectionLoaded(col); if (mCurrentCard == null) { mCurrentCard = new PreviewerCard(col, mCardList[mIndex]); } displayCardQuestion(); showBackIcon();; }

Target:
protected void onCollectionLoaded(Collection col) { super.onCollectionLoaded(col); if (mCurrentCard == null) { mCurrentCard = new PreviewerCard(col, mCardList[mOrdinal]); } displayCardQuestion(); showBackIcon(); }
Source:
public static CrateState fromStream(byte[] value) throws IOException { if (value.length == 0) { return new CrateState(); } ByteArrayInputStream in = new ByteArrayInputStream(value); try (ObjectInputStream objectInputStream = new ObjectInputStream(in)) { CrateState state = (CrateState) objectInputStream.readObject(); return state; } catch (ClassNotFoundException e) { LOGGER.error("Could not deserialize ClusterState: {}", e.getMessage()); } return null; }

Target:
public static CrateState fromStream(byte[] value) throws IOException { if (value.length == 0) { return new CrateState(); } ByteArrayInputStream in = new ByteArrayInputStream(value); try (ObjectInputStream objectInputStream = new ObjectInputStream(in)) { CrateState state = (CrateState) objectInputStream.readObject(); return state; } catch (ClassNotFoundException e) { LOGGER.error("Could not deserialize ClusterState:", e); } return null; }
Source:
public void saveRadiologyOrderEncounter_shouldCreateRadiologyOrderEncounterAttachedToExistingActiveVisitGivenPatientWithActiveVisit() throws Exception { Patient patient = patientService.getPatient(PATIENT_ID_WITH_NO_RADIOLOGY_ORDER_AND_NO_EXISTIG_ENCOUNTER_AND_ACTIVE_VISIT); Provider provider = providerService.getProviderByUuid(RADIOLOGY_ORDER_PROVIDER_UUID); Date encounterDatetime = new GregorianCalendar(2010, Calendar.OCTOBER, 10).getTime(); Visit preExistingVisit = visitService.getVisit(3001); assertThat(encounterService.getEncountersByPatient(patient), is(empty())); assertThat(visitService.getActiveVisitsByPatient(patient), is(Arrays.asList(preExistingVisit))); Encounter encounter = (Encounter) saveRadiologyOrderEncounterMethod.invoke(radiologyServiceImpl, new Object[] { patient, provider, encounterDatetime }); assertNotNull(encounter); assertThat(encounter.getPatient(), is(patient)); assertThat(encounter.getProvidersByRole(radiologyProperties.getOrderingProviderEncounterRole()) .size(), is(1)); assertThat(encounter.getProvidersByRole(radiologyProperties.getOrderingProviderEncounterRole()) .contains(provider), is(true)); assertThat(encounter.getEncounterDatetime(), is(encounterDatetime)); assertThat(encounter.getEncounterType(), is(radiologyProperties.getRadiologyOrderEncounterType())); assertThat(encounterService.getEncountersByPatient(patient), is(Arrays.asList(encounter))); assertThat(visitService.getActiveVisitsByPatient(patient), is(Arrays.asList(preExistingVisit))); }

Target:
public void saveRadiologyOrderEncounter_shouldCreateRadiologyOrderEncounterAttachedToExistingActiveVisitGivenPatientWithActiveVisit() throws Exception { Patient patient = patientService.getPatient(PATIENT_ID_WITH_NO_RADIOLOGY_ORDER_AND_NO_EXISTIG_ENCOUNTER_AND_ACTIVE_VISIT); Provider provider = providerService.getProviderByUuid(RADIOLOGY_ORDER_PROVIDER_UUID); Date encounterDatetime = new GregorianCalendar(2010, Calendar.OCTOBER, 10).getTime(); List<Visit> preExistingVisits = visitService.getActiveVisitsByPatient(patient); assertThat(encounterService.getEncountersByPatient(patient), is(empty())); assertThat(visitService.getActiveVisitsByPatient(patient), is(not(empty()))); Encounter encounter = (Encounter) saveRadiologyOrderEncounterMethod.invoke(radiologyServiceImpl, new Object[] { patient, provider, encounterDatetime }); assertNotNull(encounter); assertThat(encounter.getPatient(), is(patient)); assertThat(encounter.getProvidersByRole(radiologyProperties.getRadiologyOrderingProviderEncounterRole()) .size(), is(1)); assertThat(encounter.getProvidersByRole(radiologyProperties.getRadiologyOrderingProviderEncounterRole()) .contains(provider), is(true)); assertThat(encounter.getEncounterDatetime(), is(encounterDatetime)); assertThat(encounter.getVisit() .getVisitType(), is(radiologyProperties.getRadiologyVisitType())); assertThat(encounter.getEncounterType(), is(radiologyProperties.getRadiologyOrderEncounterType())); assertThat(encounterService.getEncountersByPatient(patient), is(Arrays.asList(encounter))); assertThat(visitService.getActiveVisitsByPatient(patient), is(preExistingVisits)); }
Source:
public static LatencyDataStore getResultsFromAnalysis(@Nullable LatencyAnalysis analysis) { if (analysis != null) { ISegmentStore<ISegment> results = analysis.getResults(); if (results != null) { return storeAndGet(results); } } return new LatencyDataStore(new TreeMapStore<>()); }

Target:
public static LatencyDataStore getResultsFromAnalysis(@Nullable LatencyAnalysis analysis) { ISegmentStore<ISegment> results = null; if (analysis != null) { results = analysis.getResults(); } return storeAndGet(results); }
Source:
private Map<String, Object> getRawCapabilities() { return (Map<String, Object>) asMap(); }

Target:
public Map<String, Object> getRawCapabilities() { return (Map<String, Object>) asMap(); }
Source:
protected void autonomousMain() throws AutonomousModeOverException, InterruptedException { try { Elevator.setBottom.event(); waitUntil(Elevator.atBottom); boolean r = Rollers.running.get(); boolean d = Rollers.direction.get(); boolean o = Rollers.closed.get(); try{ Rollers.closed.set(true); Rollers.direction.set(true); Rollers.running.set(true); waitUntil(BooleanMixing.invert(AutoLoader.crateInPosition)); waitForTime(timeout); } finally { Rollers.running.set(r); Rollers.direction.set(d); Rollers.direction.set(o); } } finally { running.set(false); } }

Target:
protected void autonomousMain() throws AutonomousModeOverException, InterruptedException { try { setClampHeight(1.0f); Elevator.setBottom.event(); waitUntil(Elevator.atBottom); float currentClampHeight = Clamp.height.get(); boolean running = Rollers.running.get(); boolean direction = Rollers.direction.get(); boolean open = Rollers.closed.get(); try{ Rollers.closed.set(true); Rollers.direction.set(true); Rollers.running.set(true); waitUntil(BooleanMixing.invert(AutoLoader.crateInPosition)); waitForTime(timeout); } finally { Rollers.running.set(running); Rollers.direction.set(direction); Rollers.direction.set(open); setClampHeight(currentClampHeight); } } finally { running.set(false); } }
Source:
protected void removeNode(final Node<E> node) { Objects.requireNonNull(node,"The new node to remove must not be null."); node.previous.next = node.next; node.next.previous = node.previous; size--; modCount++; }

Target:
protected void removeNode(final Node<E> node) { Objects.requireNonNull(node, "node"); node.previous.next = node.next; node.next.previous = node.previous; size--; modCount++; }
Source:
public Tuple next() throws IOException { if (fragments == null) { return null; } if (scanner == null) { System.out.println("[SeqScanExec/next] "); } Tuple tuple; Tuple outTuple = new VTuple(outColumnNum); if (!plan.hasQual()) { if ((tuple = scanner.next()) != null) { projector.eval(tuple, outTuple); outTuple.setOffset(tuple.getOffset()); return outTuple; } else { return null; } } else { while ((tuple = scanner.next()) != null) { if (qual.eval(tuple).isTrue()) { projector.eval(tuple, outTuple); return outTuple; } } return null; } }

Target:
public Tuple next() throws IOException { if (fragments == null) { return null; } Tuple tuple; Tuple outTuple = new VTuple(outColumnNum); if (!plan.hasQual()) { if ((tuple = scanner.next()) != null) { projector.eval(tuple, outTuple); outTuple.setOffset(tuple.getOffset()); return outTuple; } else { return null; } } else { while ((tuple = scanner.next()) != null) { if (qual.eval(tuple).isTrue()) { projector.eval(tuple, outTuple); return outTuple; } } return null; } }
Source:
public void call() { try { subscriber.onSuccess(value); } catch (Throwable t) { subscriber.onError(t); return; } }

Target:
public void call() { try { subscriber.onSuccess(value); } catch (Throwable t) { subscriber.onError(t); } }
Source:
private boolean isManagementNetworkChanged(List<HostNetwork> networksToConfigure){ Network managementNetwork = getClusterNetworks().stream() .filter(e -> e.getCluster().isManagement()) .collect(Collectors.collectingAndThen(Collectors.toList(), list -> { if (list.size() != 1) { throw new IllegalStateException("There isn't management network for cluster " + getClusterId()); } return list.get(0); })); String managementNetworkName = managementNetwork.getName(); for (HostNetwork network : networksToConfigure) { if (managementNetworkName.equals(network.getNetworkName())){ return true; } } for (CreateOrUpdateBond createOrUpdateBond : getParameters().getCreateOrUpdateBonds()) { VdsNetworkInterface bondNic = getExistingNicsBusinessEntityMap().get(createOrUpdateBond.getId()); if (bondNic != null && managementNetworkName.equals(bondNic.getNetworkName())) { return true; } } return false; }

Target:
private boolean isManagementNetworkChanged(List<HostNetwork> networksToConfigure){ Network managementNetwork = managementNetworkUtil.getManagementNetwork(getClusterNetworks(), getClusterId()); String managementNetworkName = managementNetwork.getName(); for (HostNetwork network : networksToConfigure) { if (managementNetworkName.equals(network.getNetworkName())){ return true; } } for (CreateOrUpdateBond createOrUpdateBond : getParameters().getCreateOrUpdateBonds()) { VdsNetworkInterface bondNic = getExistingNicsBusinessEntityMap().get(createOrUpdateBond.getId()); if (bondNic != null && managementNetworkName.equals(bondNic.getNetworkName())) { return true; } } return false; }
Source:
private static Workspace initializeWorkspace() throws Exception { Workspace ws = null; try { Workspace.setDriver(Constants.BNDDRIVER_ECLIPSE); Workspace.addGestalt(Constants.GESTALT_INTERACTIVE, new Attrs()); ws = Workspace.getWorkspace(getWorkspaceDirectory()); updateResourceChangeListener(ws); ws.addBasicPlugin(new WorkspaceListener(ws)); ws.addBasicPlugin(getInstance().repoListenerTracker); ws.addBasicPlugin(getWorkspaceR5Repository()); ws.addBasicPlugin(new JobProgress()); ws.getBuildOrder(); workspaceRepositoryChangeDetector = new WorkspaceRepositoryChangeDetector(ws); } catch (final Exception e) { if (ws != null) { ws.close(); } throw e; } return ws; }

Target:
private static Workspace initializeWorkspace() throws Exception { Workspace ws = null; try { Workspace.setDriver(Constants.BNDDRIVER_ECLIPSE); Workspace.addGestalt(Constants.GESTALT_INTERACTIVE, new Attrs()); ws = new Workspace(getWorkspaceDirectory()); updateResourceChangeListener(ws); ws.addBasicPlugin(new WorkspaceListener(ws)); ws.addBasicPlugin(getInstance().repoListenerTracker); ws.addBasicPlugin(getWorkspaceR5Repository()); ws.addBasicPlugin(new JobProgress()); ws.getBuildOrder(); workspaceRepositoryChangeDetector = new WorkspaceRepositoryChangeDetector(ws); } catch (final Exception e) { if (ws != null) { ws.close(); } throw e; } return ws; }
Source:
public void onNext(final TaskStop taskStop) { LOG.log(Level.FINE, "Sends a msg to deregister itself to stop subscribing updates in routing table"); sender.sendWorkerDeregisterMsg(); }

Target:
public void onNext(final TaskStop taskStop) { LOG.log(Level.FINE, "Task {0} sends a msg to deregister itself to stop subscribing updates in routing table", taskStop.getId()); sender.sendWorkerDeregisterMsg(); }
Source:
protected void processAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException { String key = URLDecoder.decode(request.getHeader("Authorization").substring(7), "UTF-8").trim(); NuxeoOAuth2Token token = TransactionHelper.runInNewTransaction(() -> getTokenStore().getToken(key)); ClientRegistry clientRegistry = Framework.getService(ClientRegistry.class); if (token == null || token.isExpired() || !clientRegistry.hasClient(token.getClientId())) { response.setStatus(401); return; } LoginContext loginContext = buildLoginContext(token); if (loginContext != null) { Principal principal = (Principal) loginContext.getSubject().getPrincipals().toArray()[0]; try { chain.doFilter(new NuxeoSecuredRequestWrapper(request, principal), response); } finally { try { loginContext.logout(); } catch (LoginException e) { log.warn("Error when logging out", e); } } } }

Target:
protected void processAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException { String key = URLDecoder.decode( request.getHeader(AUTHORIZATION_HEADER).substring(BEARER_AUTHENTICATION_SCHEME.length()), "UTF-8") .trim(); NuxeoOAuth2Token token = TransactionHelper.runInTransaction(() -> tokenStore.getToken(key)); ClientRegistry clientRegistry = Framework.getService(ClientRegistry.class); if (token == null || token.isExpired() || !clientRegistry.hasClient(token.getClientId())) { response.setStatus(SC_UNAUTHORIZED); return; } LoginContext loginContext = buildLoginContext(token); if (loginContext != null) { Principal principal = (Principal) loginContext.getSubject().getPrincipals().toArray()[0]; try { chain.doFilter(new NuxeoSecuredRequestWrapper(request, principal), response); } finally { try { loginContext.logout(); } catch (LoginException e) { log.warn("Error when logging out", e); } } } }
Source:
public void start(BootstrapContext ctx) throws ResourceAdapterInternalException { if (engine == null) { engine = new ModeShapeEngine(); engine.start(); } }

Target:
public synchronized void start(BootstrapContext ctx) throws ResourceAdapterInternalException { if (engine == null) { engine = new ModeShapeEngine(); engine.start(); } }
Source:
public RetriableCommitFailedException(Throwable t) { super("Offset commit failed with a retriable exception. This is usually because the consumer is no longer " + "part of a group or is participating a rebalance right now. You should first call poll to complete " + "the rebalance and then commit the latest consumed offsets.", t); }

Target:
public RetriableCommitFailedException(Throwable t) { super("Offset commit failed with a retriable exception. You should retry committing " + "the latest consumed offsets.", t); }
Source:
private List<MethodSpec> getMethods() { ArrayList<MethodSpec> results = new ArrayList<>(); results.addAll(definitions.entrySet() .stream() .map(entry -> getTableMethod(entry.getKey(), entry.getValue())) .collect(Collectors.toList())); results.addAll(definitions.entrySet() .stream() .filter(entry -> entry.getValue().hasV2TableEnabled()) .map(entry -> getSimpleTableMethod(entry.getKey(), entry.getValue())) .collect(Collectors.toList())); return results; }

Target:
private List<MethodSpec> getMethods() { List<MethodSpec> results = new ArrayList<>(); results.addAll(definitions.entrySet() .stream() .map(entry -> getTableMethod(entry.getKey(), entry.getValue())) .collect(Collectors.toList())); results.addAll(definitions.entrySet() .stream() .filter(entry -> entry.getValue().hasV2TableEnabled()) .map(entry -> getV2TableMethod(entry.getKey(), entry.getValue())) .collect(Collectors.toList())); return results; }
Source:
private void emitRow(@Nullable GenericRowData physicalKeyRow, @Nullable GenericRowData physicalValueRow) { final int metadataArity = metadataConverters.length; final int physicalArity = keyProjection.length + valueProjection.length; final RowKind rowkind = physicalValueRow == null ? RowKind.DELETE : physicalValueRow.getRowKind(); final GenericRowData producedRow = new GenericRowData( rowkind, physicalArity + metadataArity); for (int keyPos = 0; keyPos < keyProjection.length; keyPos++) { producedRow.setField(keyProjection[keyPos], physicalKeyRow.getField(keyPos)); } if (physicalValueRow != null) { for (int valuePos = 0; valuePos < valueProjection.length; valuePos++) { producedRow.setField(valueProjection[valuePos], physicalValueRow.getField(valuePos)); } } for (int i = 0; i < metadataArity; i++) { producedRow.setField(i + physicalArity, metadataConverters[i].read(inputRecord)); } outputCollector.collect(producedRow); }

Target:
private void emitRow(@Nullable GenericRowData physicalKeyRow, @Nullable GenericRowData physicalValueRow) { final int metadataArity = metadataConverters.length; final RowKind rowKind; if (physicalValueRow == null) { if (upsertMode) { rowKind = RowKind.DELETE; } else { throw new DeserializationException( "Get null value in non-upsert mode. Could not to set rowkind for input record."); } } else { rowKind = physicalValueRow.getRowKind(); } final GenericRowData producedRow = new GenericRowData( rowKind, physicalArity + metadataArity); for (int keyPos = 0; keyPos < keyProjection.length; keyPos++) { producedRow.setField(keyProjection[keyPos], physicalKeyRow.getField(keyPos)); } if (physicalValueRow != null) { for (int valuePos = 0; valuePos < valueProjection.length; valuePos++) { producedRow.setField(valueProjection[valuePos], physicalValueRow.getField(valuePos)); } } for (int metadataPos = 0; metadataPos < metadataArity; metadataPos++) { producedRow.setField(physicalArity + metadataPos, metadataConverters[metadataPos].read(inputRecord)); } outputCollector.collect(producedRow); }
Source:
public static void initCreateElementTest() { try { Bundle bundle = Platform.getBundle("org.eclipse.papyrus.infra.elementtypesconfigurations.ui.tests"); workspaceTestFile = PapyrusProjectUtils.copyIFile("/model/WorkspaceTest.elementtypesconfigurations", bundle, createProject, "/model/WorkspaceTest.elementtypesconfigurations"); Assert.assertTrue(workspaceTestFile.isAccessible()); } catch (CoreException e) { fail(e.getMessage()); } catch (IOException e) { fail(e.getMessage()); } }

Target:
public static void initCreateElementTest() { try { Bundle bundle = FrameworkUtil.getBundle(ElementTypesRegistryTests.class); workspaceTestFile = PapyrusProjectUtils.copyIFile("/model/WorkspaceTest.elementtypesconfigurations", bundle, createProject, "/model/WorkspaceTest.elementtypesconfigurations"); Assert.assertTrue(workspaceTestFile.isAccessible()); } catch (CoreException e) { fail(e.getMessage()); } catch (IOException e) { fail(e.getMessage()); } }
Source:
<T extends ColumnMapper> List<T> getColumnMappers(Class<T> mapperType) { List<T> attributeMappers = new ArrayList<>(); for (ColumnMapper columnMapper : this.columnMappers) { if (mapperType.isInstance(columnMapper)) { attributeMappers.add((T) columnMapper); } } return attributeMappers; }

Target:
<T extends ColumnMapper> List<T> getColumnMappers(Class<T> mapperType) { List<T> attributeMappers = new ArrayList<>(); for (ColumnMapper columnMapper : this.columnMappers) { if (mapperType.isInstance(columnMapper)) { attributeMappers.add(mapperType.cast(columnMapper)); } } return attributeMappers; }
Source:
public TaskReport run(TaskSource taskSource, Schema schema, int taskIndex, PageOutput output) { PluginTask task = taskSource.loadTask(getTaskClass()); PreparedQuery builtQuery = task.getBuiltQuery(); JdbcSchema querySchema = task.getQuerySchema(); BufferAllocator allocator = task.getBufferAllocator(); PageBuilder pageBuilder = new PageBuilder(allocator, schema, output); long totalRows = 0; LastRecordStore lastRecordStore = null; try (JdbcInputConnection con = newConnection(task)) { con.before_load(); List<ColumnGetter> getters = newColumnGetters(con, task, querySchema, pageBuilder); try (BatchSelect cursor = con.newSelectCursor(builtQuery, getters, task.getFetchRows(), task.getSocketTimeout())) { while (true) { long rows = fetch(cursor, getters, pageBuilder); if (rows <= 0L) { break; } totalRows += rows; } } if (task.getIncremental() && totalRows > 0) { lastRecordStore = new LastRecordStore(task.getIncrementalColumnIndexes(), task.getIncrementalColumns()); lastRecordStore.accept(getters); } pageBuilder.finish(); if (task.getAfterSelect().isPresent()) { con.executeUpdate(task.getAfterSelect().get()); con.connection.commit(); } } catch (SQLException ex) { throw Throwables.propagate(ex); } TaskReport report = Exec.newTaskReport(); if (lastRecordStore != null) { report.set("last_record", lastRecordStore.getList()); } return report; }

Target:
public TaskReport run(TaskSource taskSource, Schema schema, int taskIndex, PageOutput output) { PluginTask task = taskSource.loadTask(getTaskClass()); PreparedQuery builtQuery = task.getBuiltQuery(); JdbcSchema querySchema = task.getQuerySchema(); BufferAllocator allocator = task.getBufferAllocator(); PageBuilder pageBuilder = new PageBuilder(allocator, schema, output); long totalRows = 0; LastRecordStore lastRecordStore = null; try (JdbcInputConnection con = newConnection(task)) { List<ColumnGetter> getters = newColumnGetters(con, task, querySchema, pageBuilder); try (BatchSelect cursor = con.newSelectCursor(builtQuery, getters, task.getFetchRows(), task.getSocketTimeout())) { while (true) { long rows = fetch(cursor, getters, pageBuilder); if (rows <= 0L) { break; } totalRows += rows; } } if (task.getIncremental() && totalRows > 0) { lastRecordStore = new LastRecordStore(task.getIncrementalColumnIndexes(), task.getIncrementalColumns()); lastRecordStore.accept(getters); } pageBuilder.finish(); if (task.getAfterSelect().isPresent()) { con.executeUpdate(task.getAfterSelect().get()); con.connection.commit(); } } catch (SQLException ex) { throw Throwables.propagate(ex); } TaskReport report = Exec.newTaskReport(); if (lastRecordStore != null) { report.set("last_record", lastRecordStore.getList()); } return report; }
Source:
public CompoundInClause(Iterable<String> names, Iterable<?> valueLists) { if (valueLists == null) throw new IllegalArgumentException("Missing values for IN clause"); if (names == null) throw new IllegalArgumentException("Missing names for IN clause"); this.names = Lists.newArrayList(names); this.valueLists = Lists.newArrayListWithExpectedSize(this.names.size()); for (Object value : valueLists) { if (value instanceof Iterable) { List<?> tuple = Lists.newArrayList((Iterable<?>) value); if (tuple.size() != this.names.size()) { throw new IllegalArgumentException(String.format("The number of names (%d) and values (%d) don't match", this.names.size(), tuple.size())); } this.valueLists.add(tuple); } else if (!(value instanceof BindMarker)) { throw new IllegalArgumentException(String.format("Wrong element type for values list, expected List or BindMarker, got %s", value.getClass().getName())); } else { this.valueLists.add(value); } } if (this.valueLists.size() > 65535) throw new IllegalArgumentException("Too many values for IN clause, the maximum allowed is 65535"); }

Target:
public CompoundInClause(Iterable<String> names, Iterable<?> valueLists) { if (valueLists == null) throw new IllegalArgumentException("Missing values for IN clause"); if (names == null) throw new IllegalArgumentException("Missing names for IN clause"); this.names = Lists.newArrayList(names); this.valueLists = Lists.newArrayList(); for (Object value : valueLists) { if (value instanceof Iterable) { List<?> tuple = Lists.newArrayList((Iterable<?>) value); if (tuple.size() != this.names.size()) { throw new IllegalArgumentException(String.format("The number of names (%d) and values (%d) don't match", this.names.size(), tuple.size())); } this.valueLists.add(tuple); } else if (!(value instanceof BindMarker)) { throw new IllegalArgumentException(String.format("Wrong element type for values list, expected List or BindMarker, got %s", value.getClass().getName())); } else { this.valueLists.add(value); } } if (this.valueLists.size() > 65535) throw new IllegalArgumentException("Too many values for IN clause, the maximum allowed is 65535"); }
Source:
public int compareTo(RankedEntity o) { return new Float(this.score).compareTo(new Float(o.score)); }

Target:
public int compareTo(RankedEntity o) { return Float.compare(score, o.score); }
Source:
public MakeBlob(boolean produceImmediate) { super(NAME, 1, 3); this.produceImmediate = produceImmediate; }

Target:
public MakeBlob(boolean produceImmediate) { super(NAME, NB_OUTPUT_STREAMS); this.produceImmediate = produceImmediate; }
Source:
public void anonCanRemindPasswordOnUserLoginSpecialPage() { MailFunctions.deleteAllEmails(credentials.email, credentials.emailPassword); WikiBasePageObject base = new WikiBasePageObject(); AttachedSignInPage signIn = new AttachedSignInPage().open(); signIn.clickForgotPasswordLink().requestLinkForUsername(User.FORGOTTEN_PASSWORD.getUserName()); String resetLink = base.getPasswordResetLink(credentials.email, credentials.emailPassword); ResetPasswordPage resetPass = new ResetPasswordPage(resetLink); resetPass.setNewPassword(User.FORGOTTEN_PASSWORD.getPassword()); Assertion.assertTrue(resetPass.newPasswordSetSuccessfully()); }

Target:
public void anonCanRemindPasswordOnUserLoginSpecialPage() { EmailUtils.deleteAllEmails(credentials.email, credentials.emailPassword); WikiBasePageObject base = new WikiBasePageObject(); AttachedSignInPage signIn = new AttachedSignInPage().open(); signIn.clickForgotPasswordLink().requestLinkForUsername(User.FORGOTTEN_PASSWORD.getUserName()); String resetLink = base.getPasswordResetLink(credentials.email, credentials.emailPassword); ResetPasswordPage resetPass = new ResetPasswordPage(resetLink); resetPass.setNewPassword(User.FORGOTTEN_PASSWORD.getPassword()); assertTrue(resetPass.newPasswordSetSuccessfully()); }
Source:
public boolean getChecked(Object element) { if (fObjects.containsKey(element)) { return fObjects.get(element); } return fCheckboxTreeViewer.getChecked(element); }

Target:
public boolean getChecked(Object element) { return fObjects.contains(element); }
Source:
public MetaDataStore(String scanPackageName) { super(META_DATA_PACKAGE); this.scanPackageName = scanPackageName; this.metadataDictionary = new EntityDictionary(new HashMap<>()); for (Class<? extends Annotation> cls : METADATA_STORE_CLASSES) { ClassScanner.getAnnotatedClasses(scanPackageName, cls).stream().forEach(modelClass -> { metadataDictionary.bindEntity(modelClass); }); } }

Target:
public MetaDataStore(String scanPackageName) { super(META_DATA_PACKAGE); this.scanPackageName = scanPackageName; this.dictionary = new EntityDictionary(new HashMap<>()); ClassScanner.getAllClasses(Table.class.getPackage().getName()).stream().forEach(cls -> { dictionary.bindEntity(cls); }); for (Class<? extends Annotation> cls : METADATA_STORE_ANNOTATIONS) { dictionary.bindEntity(cls); ClassScanner.getAnnotatedClasses(scanPackageName, cls).stream().forEach(modelClass -> { dictionary.bindEntity(modelClass); addTable( isAnalyticView(modelClass) ? new AnalyticView(modelClass, dictionary) : new Table(modelClass, dictionary)); }); } }
Source:
public void shouldBlockUserAfterCrossingTheFailureLoginCounter() { MotechUser motechUser = new MotechUser(); motechUser.setUserStatus(UserStatus.MUST_CHANGE_PASSWORD); motechUser.setPassword(PASSWORD); motechUser.setUserName(USER); motechUser.setFailureLoginCounter(1); when(allMotechUsers.findByUserName(USER)).thenReturn(motechUser); when(motechPasswordEncoder.isPasswordValid(PASSWORD, PASSWORD)).thenReturn(false); when(motechPasswordEncoder.isPasswordValid(PASSWORD, NEW_PASSWORD)).thenReturn(false); when(settingService.getFailureLoginLimit()).thenReturn(1); motechUserService.changeExpiredPassword(USER, PASSWORD, NEW_PASSWORD); }

Target:
public void shouldBlockUserAfterCrossingTheFailureLoginCounter() { MotechUser motechUser = new MotechUser(); motechUser.setUserStatus(UserStatus.MUST_CHANGE_PASSWORD); motechUser.setPassword(PASSWORD); motechUser.setUserName(USER); motechUser.setFailureLoginCounter(1); when(allMotechUsers.findByUserName(USER)).thenReturn(motechUser); when(motechPasswordEncoder.isPasswordValid(PASSWORD, PASSWORD)).thenReturn(false); when(settingService.getFailureLoginLimit()).thenReturn(1); motechUserService.changeExpiredPassword(USER, PASSWORD, NEW_PASSWORD); }
Source:
public void onConnectAccept(IClient client) { logger.debug("onConnectAccept"+ client.getClientId()); try { WMSProperties properties = client.getProperties(); String entryId = Utils.getEntryIdFromClient(client); KalturaLiveEntry liveEntry = (KalturaLiveEntry)KalturaEntryDataPersistence.getPropertyByEntry(entryId, Constants.CLIENT_PROPERTY_KALTURA_LIVE_ENTRY); boolean isNewLiveRecordingEnabled = KalturaAPI.getKalturaAPI().isNewRecordingEnabled(liveEntry); if (!isNewLiveRecordingEnabled || liveEntry.recordStatus == null || liveEntry.recordStatus == KalturaRecordStatus.DISABLED){ return; } KalturaFlavorAssetListResponse liveAssetList = KalturaAPI.getKalturaAPI().getKalturaFlavorAssetListResponse(liveEntry); if (liveAssetList != null) { synchronized(properties) { properties.setProperty(Constants.CLIENT_PROPERTY_KALTURA_LIVE_ASSET_LIST, liveAssetList); } logger.debug("Adding live asset list for entry [" + liveEntry.id + "]" ); } } catch (Exception e ){ logger.error("Failed to load liveAssetList:",e); } }

Target:
public void onConnectAccept(IClient client) { logger.debug("onConnectAccept"+ client.getClientId()); try { WMSProperties properties = client.getProperties(); String entryId = Utils.getEntryIdFromClient(client); KalturaLiveEntry liveEntry = (KalturaLiveEntry)KalturaEntryDataPersistence.getPropertyByEntry(entryId, Constants.CLIENT_PROPERTY_KALTURA_LIVE_ENTRY); boolean isNewLiveRecordingEnabled = KalturaAPI.getKalturaAPI().isNewRecordingEnabled(liveEntry); if (isNewLiveRecordingEnabled || liveEntry.recordStatus == null || liveEntry.recordStatus == KalturaRecordStatus.DISABLED){ return; } KalturaFlavorAssetListResponse liveAssetList = KalturaAPI.getKalturaAPI().getKalturaFlavorAssetListResponse(liveEntry); if (liveAssetList != null) { synchronized(properties) { properties.setProperty(Constants.CLIENT_PROPERTY_KALTURA_LIVE_ASSET_LIST, liveAssetList); } logger.debug("Adding live asset list for entry [" + liveEntry.id + "]" ); } } catch (Exception e ){ logger.error("Failed to load liveAssetList:",e); } }
Source:
public String save() { metadataPanel.preserve(); structurePanel.preserve(); if (validate()) { try (OutputStream out = ServiceManager.getFileService().write(mainFileUri)) { ServiceManager.getMetsService().save(workpiece, out); return close(); } catch (IOException e) { Helper.setErrorMessage(e.getLocalizedMessage(), logger, e); logger.error(e.getLocalizedMessage()); } } PrimeFaces.current().executeScript("PF('sticky-notifications').removeAll();"); PrimeFaces.current().ajax().update("notifications"); return null; }

Target:
public String save() { metadataPanel.preserve(); structurePanel.preserve(); if (validate()) { try (OutputStream out = ServiceManager.getFileService().write(mainFileUri)) { ServiceManager.getMetsService().save(workpiece, out); return close(); } catch (IOException e) { Helper.setErrorMessage(e.getLocalizedMessage(), logger, e); } } PrimeFaces.current().executeScript("PF('sticky-notifications').removeAll();"); PrimeFaces.current().ajax().update("notifications"); return null; }
Source:
public void testCloneRepositoryDefaultDirectory() throws IOException, JGitInternalException, GitAPIException { CloneCommand command = Git.cloneRepository(); command.setURI(fileUri()); Git git2 = command.call(); addRepoToClose(git2.getRepository()); assertEquals(git.getRepository().getWorkTree().getName(), git2.getRepository().getWorkTree().getName()); }

Target:
public void testCloneRepositoryDefaultDirectory() throws IOException, URISyntaxException, JGitInternalException, GitAPIException { CloneCommand command = Git.cloneRepository(); command.setURI(fileUri()); command.verifyDirectories(new URIish(fileUri())); File directory = command.getDirectory(); assertEquals(git.getRepository().getWorkTree().getName(), directory.getName()); }
Source:
private String makeStringFromSentences(List<String> sentences, int numSentences) { StringBuilder outStr = new StringBuilder(); for (int i = 0; i < numSentences; i++) { outStr.append(sentences.get(i)); outStr.append(' '); } return outStr.toString(); }

Target:
private String makeStringFromSentences(List<String> sentences, int numSentences) { StringBuilder outStr = new StringBuilder(); for (int i = 0; i < Math.min(numSentences, sentences.size()); i++) { outStr.append(sentences.get(i)); outStr.append(' '); } return outStr.toString(); }
Source:
private void updateDataTables() { List<StarTable> plotterDataTables = new LinkedList<>(); List<StarTable> segmentDataTables = new LinkedList<>(); for (IrisStarTable table : selectedStarTables) { plotterDataTables.add(table.getPlotterTable()); segmentDataTables.add(table.getDataTable()); } plotterDataTable = new StackedStarTable(plotterDataTables, columnInfoMatcher); segmentDataTable = new StackedStarTable(segmentDataTables, columnInfoMatcher); setPlotterDataTable(plotterDataTable); setSegmentDataTable(segmentDataTable); }

Target:
private void updateDataTables() { List<StarTable> plotterDataTables = new LinkedList<>(); List<StarTable> segmentDataTables = new LinkedList<>(); for (IrisStarTable table : selectedStarTables) { plotterDataTables.add(table.getPlotterTable()); segmentDataTables.add(table.getSegmentDataTable()); } plotterDataTable = new StackedStarTable(plotterDataTables, columnInfoMatcher); segmentDataTable = new StackedStarTable(segmentDataTables, columnInfoMatcher); setPlotterDataTable(plotterDataTable); setSegmentDataTable(segmentDataTable); }