auphong2707/dl4se-code-review-dataset huggingface dataset:
Source:
private static CompletionParams getCompletionParams(String buf, int cursor) { final int actualCursor = Math.min(cursor, buf.length()); final String beforeCursor = buf.substring(0, actualCursor); final int line = countLines(beforeCursor) - 1; final int character = beforeCursor.length() - beforeCursor.lastIndexOf("\n") - 1; Logger.info("Line: {}, character: from actual cursor: ", line, character, cursor); return new CompletionParams( new TextDocumentIdentifier(ANY_URI), new Position(line, character)); }

Target:
private static CompletionParams getCompletionParams(String buf, int cursor) { final int actualCursor = Math.min(cursor, buf.length()); final String beforeCursor = buf.substring(0, actualCursor); final int line = countLines(beforeCursor) - 1; final int character = beforeCursor.length() - beforeCursor.lastIndexOf("\n") - 1; Logger.debug("Line: {}, character: from actual cursor: ", line, character, cursor); return new CompletionParams( new TextDocumentIdentifier(ANY_URI), new Position(line, character)); }
Source:
public static Boolean areDependenciesAllowed(List<ArtifactCoordinates> artifactCoordinates) throws ValidationException { for (ArtifactCoordinates a : artifactCoordinates) { isDependencyAllowed(a); } return true; }

Target:
public static Boolean areDependenciesAllowed(List<ArtifactCoordinates> artifactCoordinates) throws ValidationException { List<ArtifactCoordinates> notAllowedDependencies = collectNotAllowedDependencies(artifactCoordinates); if (!notAllowedDependencies.isEmpty()) { StringBuilder notAllowedMessage = new StringBuilder(); notAllowedDependencies.forEach(d -> notAllowedMessage.append(d.toString()).append(",")); throw new ValidationException("The following dependencies are not allowed unless their scope is [provided]: " + removeEnd(notAllowedMessage.toString(), ",")); } return true; }
Source:
public String getIdForHolder() { if (this.getType() == MessageType.PRIVATE_MESSAGE) { return getRawRecipients(); } if(getStream() == null) { String k = ""; } return getStream().getId() + getSubject(); }

Target:
public String getIdForHolder() { if (this.getType() == MessageType.PRIVATE_MESSAGE) { return getRawRecipients(); } return getStream().getId() + getSubject(); }
Source:
String plainId() { return "[R" + id + "]"; }

Target:
String plainId() { return "[R" + id + ']'; }
Source:
private PhoneAccountHandle getAccountHandleFromNumber(String dialNumber) { PhoneAccountHandle phoneAccountFromNumber = null; Cursor cursor = null; cursor = mContentResolver.query(Calls.CONTENT_URI, new String[] {Calls.PHONE_ACCOUNT_ID, Calls.PHONE_ACCOUNT_COMPONENT_NAME}, Calls.TYPE + "=" + Calls.OUTGOING_TYPE + " AND " + Calls.NUMBER + "=\"" + PhoneNumberUtils.normalizeNumber(dialNumber) + "\"", null, Calls.DEFAULT_SORT_ORDER + " LIMIT 1"); if (cursor != null) { if (cursor.getCount() > 0) { cursor.moveToNext(); String componentName = cursor.getString( cursor.getColumnIndex(Calls.PHONE_ACCOUNT_COMPONENT_NAME)); String accountId = cursor.getString(cursor.getColumnIndex(Calls.PHONE_ACCOUNT_ID)); if (!TextUtils.isEmpty(componentName) && !TextUtils.isEmpty(accountId)) { phoneAccountFromNumber = new PhoneAccountHandle( ComponentName.unflattenFromString(componentName), accountId); } } cursor.close(); } return phoneAccountFromNumber; }

Target:
private PhoneAccountHandle getAccountHandleFromNumber(String dialNumber) { Cursor cursor = mContentResolver.query(Calls.CONTENT_URI, new String[] {Calls.PHONE_ACCOUNT_ID, Calls.PHONE_ACCOUNT_COMPONENT_NAME}, Calls.TYPE + "=" + Calls.OUTGOING_TYPE + " AND " + Calls.NUMBER + "=\"" + PhoneNumberUtils.normalizeNumber(dialNumber) + "\"", null, Calls.DEFAULT_SORT_ORDER + " LIMIT 1"); if (cursor == null) { return null; } if (cursor.getCount() > 0) { cursor.moveToNext(); String componentName = cursor.getString( cursor.getColumnIndex(Calls.PHONE_ACCOUNT_COMPONENT_NAME)); String accountId = cursor.getString(cursor.getColumnIndex(Calls.PHONE_ACCOUNT_ID)); cursor.close(); if (!TextUtils.isEmpty(componentName) && !TextUtils.isEmpty(accountId)) { return new PhoneAccountHandle( ComponentName.unflattenFromString(componentName), accountId); } } return null; }
Source:
private String getPropertiesString(Map<String, Object> properties) { StringBuilder output = new StringBuilder(); for (Entry<String, Object> entry : properties.entrySet()) { if (entry.getKey().equals("spring.profiles")) { continue; } if (output.length() > 0) { output.append("\n"); } String line = entry.getKey() + ": " + entry.getValue(); output.append(line); } return output.toString(); }

Target:
private String getPropertiesString(Map<String, Object> properties) { StringBuilder output = new StringBuilder(); for (Entry<String, Object> entry : properties.entrySet()) { if (output.length() > 0) { output.append("\n"); } String line = entry.getKey() + ": " + entry.getValue(); output.append(line); } return output.toString(); }
Source:
public boolean getEnabled(String actionCommand) { if (ActionNames.ADD.equals(actionCommand)) return guiComp.canBeAdded(); else return true; }

Target:
public boolean getEnabled(String actionCommand) { if (ActionNames.ADD.equals(actionCommand)) { return guiComp.canBeAdded(); } else { return true; } }
Source:
public List<String> getTags() { if (tags == null) { return new ArrayList<>(); } return tags; }

Target:
public List<String> getTags() { if (tags == null) { tags = new ArrayList<>(); } return tags; }
Source:
public void swap(INDArray x, INDArray y) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, x, y); if(x.isSparse() || y.isSparse()) { Nd4j.getSparseBlasWrapper().level1().swap(x, y); } if (x.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, x, y); dswap(x.length(), x, BlasBufferUtil.getBlasStride(x), y, BlasBufferUtil.getBlasStride(y)); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, x, y); sswap(x.length(), x, BlasBufferUtil.getBlasStride(x), y, BlasBufferUtil.getBlasStride(y)); } }

Target:
public void swap(INDArray x, INDArray y) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, x, y); if (x.isSparse() || y.isSparse()) { Nd4j.getSparseBlasWrapper().level1().swap(x, y); return; } if (x.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, x, y); dswap(x.length(), x, BlasBufferUtil.getBlasStride(x), y, BlasBufferUtil.getBlasStride(y)); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, x, y); sswap(x.length(), x, BlasBufferUtil.getBlasStride(x), y, BlasBufferUtil.getBlasStride(y)); } }
Source:
public synchronized void run() { try { if (connection == null) { log.warn("MBean connection is not open, cannot read open files stats"); return; } OperatingSystemMXBean osBean = ManagementFactory.newPlatformMXBeanProxy(connection, ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME, OperatingSystemMXBean.class); Long openFiles = (Long) connection.getAttribute(osBean.getObjectName(), OPEN_FILE_DESCRIPTOR_COUNT); Long maxOpenFiles = (Long) connection.getAttribute(osBean.getObjectName(), MAX_FILE_DESCRIPTOR_COUNT); if (openFiles != null) { timeline.addValue(OPEN_FILES, new Timeline.Value(openFiles)); } log.tracef("Open files: open=%s, max=%s", openFiles, maxOpenFiles); } catch (Exception e) { log.error("Error in JMX memory stats retrieval", e); } }

Target:
public synchronized void run() { try { if (connection == null) { log.warn("MBean connection is not open, cannot read open files stats"); return; } OperatingSystemMXBean osBean = ManagementFactory.newPlatformMXBeanProxy(connection, ManagementFactory.OPERATING_SYSTEM_MXBEAN_NAME, OperatingSystemMXBean.class); Long openFiles = (Long) connection.getAttribute(osBean.getObjectName(), OPEN_FILE_DESCRIPTOR_COUNT); Long maxOpenFiles = (Long) connection.getAttribute(osBean.getObjectName(), MAX_FILE_DESCRIPTOR_COUNT); if (openFiles != null) { timeline.addValue(OPEN_FILES, new Timeline.Value(openFiles)); } log.tracef("Open files: open=%s, max=%s", openFiles, maxOpenFiles); } catch (Exception e) { log.error("Error in open files stats retrieval", e); } }
Source:
public List<SCTVerificationResult> getValidSCTs() { return Collections.unmodifiableList(validSCTs); }

Target:
public List<VerifiedSCT> getValidSCTs() { return Collections.unmodifiableList(validSCTs); }
Source:
public void updateHosts() { UpdateExternalHostModels(); updateHostList(getProviderSearchFilter().getEntity()); }

Target:
public void updateHosts() { updateExternalHostModels(); updateHostList(getProviderSearchFilter().getEntity()); }
Source:
private void adjustKVMDataForBlockSD() { if (getVm().getOrigin() == OriginType.KVM && getActionState() == CommandActionState.EXECUTE && getStorageDomain() != null && getStorageDomain().getStorageType().isBlockDomain()) { getVm().getImages().forEach(image -> image.setActualSizeInBytes(image.getSize())); getVm().getImages().forEach(image -> image.setVolumeType(VolumeType.Preallocated)); } }

Target:
private void adjustKVMDataForBlockSD() { if (getVm().getOrigin() == OriginType.KVM && getActionState() == CommandActionState.EXECUTE && getStorageDomain() != null && getStorageDomain().getStorageType().isBlockDomain()) { getVm().getImages().forEach(image -> { image.setActualSizeInBytes(image.getSize()); image.setVolumeType(VolumeType.Preallocated); }); } }
Source:
public Enum<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { String text = jp.getText().toUpperCase(); try { Method valueOfMethod = handledType().getDeclaredMethod("valueOf", String.class); return (Enum<?>) valueOfMethod.invoke(null, text); } catch (Exception e) { throw new RuntimeException("Cannot deserialize enum " + handledType().getName() + " from " + text, e); } }

Target:
public Enum<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { String text = jp.getText().toUpperCase(); return (Enum<?>) Enum.valueOf((Class<Enum>)handledType(), text); }
Source:
public OnmsTopology buildTopology() { final OnmsTopology topology = new OnmsTopology(); final List<UserDefinedLink> udls = udlTopologyService.findAllUserDefinedLinks(); final Set<Integer> referencedNodes = new HashSet<>(); referencedNodes.addAll(udls.stream() .map(UserDefinedLink::getNodeIdA) .collect(Collectors.toSet())); referencedNodes.addAll(udls.stream() .map(UserDefinedLink::getNodeIdZ) .collect(Collectors.toSet())); final Map<Integer, NodeTopologyEntity> nodeMap = getNodeMap(); final Map<Integer, IpInterfaceTopologyEntity> ipMap = getIpPrimaryMap(); final Map<Integer, OnmsTopologyVertex> nodeVertexMap = new LinkedHashMap<>(); for (Integer nodeId: referencedNodes) { final OnmsTopologyVertex nodeVertex = create(nodeMap.get(nodeId), ipMap.get(nodeId)); nodeVertexMap.put(nodeId, nodeVertex); topology.addVertex(create(nodeMap.get(nodeId), ipMap.get(nodeId))); } for (UserDefinedLink udl : udls) { final String uniqueLinkId = Integer.toString(udl.getDbId()); final OnmsTopologyPort sourcePort = OnmsTopologyPort.create(uniqueLinkId + "|A", nodeVertexMap.get(udl.getNodeIdA()), null); sourcePort.setToolTipText(udl.getComponentLabelA()); final OnmsTopologyPort targetPort = OnmsTopologyPort.create(uniqueLinkId + "|Z", nodeVertexMap.get(udl.getNodeIdZ()), null); targetPort.setToolTipText(udl.getComponentLabelZ()); final OnmsTopologyEdge edge = OnmsTopologyEdge.create(uniqueLinkId, sourcePort, targetPort); edge.setToolTipText(udl.getLinkLabel()); topology.addEdge(edge); } return topology; }

Target:
public OnmsTopology buildTopology() { final OnmsTopology topology = new OnmsTopology(); final List<UserDefinedLink> udls = udlTopologyService.findAllUserDefinedLinks(); final Set<Integer> referencedNodes = new HashSet<>(); referencedNodes.addAll(udls.stream() .map(UserDefinedLink::getNodeIdA) .collect(Collectors.toSet())); referencedNodes.addAll(udls.stream() .map(UserDefinedLink::getNodeIdZ) .collect(Collectors.toSet())); final Map<Integer, NodeTopologyEntity> nodeMap = getNodeMap(); final Map<Integer, IpInterfaceTopologyEntity> ipMap = getIpPrimaryMap(); final Map<Integer, OnmsTopologyVertex> nodeVertexMap = new LinkedHashMap<>(); for (Integer nodeId: referencedNodes) { final OnmsTopologyVertex nodeVertex = create(nodeMap.get(nodeId), ipMap.get(nodeId)); nodeVertexMap.put(nodeId, nodeVertex); topology.addVertex(nodeVertex); } for (UserDefinedLink udl : udls) { final String uniqueLinkId = Integer.toString(udl.getDbId()); final OnmsTopologyPort sourcePort = OnmsTopologyPort.create(uniqueLinkId + "|A", nodeVertexMap.get(udl.getNodeIdA()), null); sourcePort.setToolTipText(udl.getComponentLabelA()); final OnmsTopologyPort targetPort = OnmsTopologyPort.create(uniqueLinkId + "|Z", nodeVertexMap.get(udl.getNodeIdZ()), null); targetPort.setToolTipText(udl.getComponentLabelZ()); final OnmsTopologyEdge edge = OnmsTopologyEdge.create(uniqueLinkId, sourcePort, targetPort); edge.setToolTipText(udl.getLinkLabel()); topology.addEdge(edge); } return topology; }
Source:
public Object getNewInstance(FMLModContainer container, Class<?> objectClass, ClassLoader classLoader, Method factoryMarkedAnnotation) throws Exception; public boolean supportsStatics(); public void setProxy(Field target, Class<?> proxyTarget, Object proxy) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException; public void setInternalProxies(ModContainer mod, Side side, ClassLoader loader); public default Function<FMLEvent, CompletableFuture<Void>> createEventHandler(Method method) { return event -> { CompletableFuture<Void> future = new CompletableFuture<>(); try { if (CompletionStage.class.isAssignableFrom(method.getReturnType())) { ((CompletionStage<Void>) method.invoke(event)).whenComplete((value, throwable) -> { if (throwable != null) { future.completeExceptionally(throwable); } else { future.complete(value); } }); } else { method.invoke(event); future.complete(null); } } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException exception) { future.completeExceptionally(exception); } return future; }; }

Target:
Object getNewInstance(FMLModContainer container, Class<?> objectClass, ClassLoader classLoader, Method factoryMarkedAnnotation) throws Exception; boolean supportsStatics(); void setProxy(Field target, Class<?> proxyTarget, Object proxy) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException; void setInternalProxies(ModContainer mod, Side side, ClassLoader loader); default BiFunction<Object, FMLEvent, CompletableFuture<Void>> createEventHandler(Method method) { return (Object mod, FMLEvent event) -> { CompletableFuture<Void> future = new CompletableFuture<>(); try { if (CompletionStage.class.isAssignableFrom(method.getReturnType())) { ((CompletionStage<Void>) method.invoke(mod, event)).whenComplete((value, throwable) -> { if (throwable != null) { future.completeExceptionally(throwable); } else { future.complete(value); } }); } else { method.invoke(mod, event); future.complete(null); } } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException exception) { future.completeExceptionally(exception); } return future; }; }
Source:
public void onCreate(Bundle savedInstanceState){ super.onCreate(savedInstanceState); setContentView(R.layout.content_frame); setBehindContentView(R.layout.menu_frame); switchFragment(getString(R.string.menu), false); switchActiveContent(getString(R.string.playlist)); setTitle(getString(R.string.playlist)); getSlidingMenu().setBehindOffset(60); setSlidingActionBarEnabled(false); getSupportActionBar().setDisplayHomeAsUpEnabled(true); setTitle(getString(R.string.playlist)); CustomApp curApp = ((CustomApp)getApplication()); curApp.getUserList().addUser(BluetoothUtils.getLocalBluetoothName()); }

Target:
public void onCreate(Bundle savedInstanceState){ super.onCreate(savedInstanceState); setContentView(R.layout.content_frame); setBehindContentView(R.layout.menu_frame); switchFragment(getString(R.string.menu), false); switchActiveContent(getString(R.string.playlist)); setTitle(getString(R.string.playlist)); getSlidingMenu().setBehindOffsetRes(R.dimen.show_content); setSlidingActionBarEnabled(false); getSupportActionBar().setDisplayHomeAsUpEnabled(true); setTitle(getString(R.string.playlist)); CustomApp curApp = ((CustomApp)getApplication()); curApp.getUserList().addUser(BluetoothUtils.getLocalBluetoothName()); }
Source:
protected Object visitCoalesceExpression(CoalesceExpression node, Object context) { Type type = type(node); List<Object> values = node.getOperands().stream() .map(value -> processWithExceptionHandling(value, context)) .filter(Objects::nonNull) .collect(Collectors.toList()); if ((!values.isEmpty() && !(values.get(0) instanceof Expression)) || values.size() == 1) { return values.get(0); } HashSet<Expression> visitExpression = new HashSet<>(); List<Expression> expressions = values.stream() .map(value -> toExpression(value, type)) .filter(x -> !visitExpression.contains(x)) .peek(visitExpression::add) .collect(Collectors.toList()); if (expressions.isEmpty()) { return null; } if (expressions.size() == 1 || expressions.get(0) instanceof Literal) { return expressions.get(0); } return new CoalesceExpression(expressions); }

Target:
protected Object visitCoalesceExpression(CoalesceExpression node, Object context) { Type type = type(node); List<Object> values = node.getOperands().stream() .map(value -> processWithExceptionHandling(value, context)) .filter(Objects::nonNull) .flatMap(expression -> { if (expression instanceof CoalesceExpression) { return ((CoalesceExpression) expression).getOperands().stream(); } return Stream.of(expression); }) .collect(Collectors.toList()); if ((!values.isEmpty() && !(values.get(0) instanceof Expression)) || values.size() == 1) { return values.get(0); } ImmutableList.Builder<Expression> operandsBuilder = ImmutableList.builder(); Set<Expression> visitedExpression = new HashSet<>(); for (Object value : values) { Expression expression = toExpression(value, type); if (!isDeterministic(expression) || visitedExpression.add(expression)) { operandsBuilder.add(expression); } if (expression instanceof Literal) { break; } } List<Expression> expressions = operandsBuilder.build(); if (expressions.isEmpty()) { return null; } if (expressions.size() == 1) { return getOnlyElement(expressions); } return new CoalesceExpression(expressions); }
Source:
private void getMetadata() { if (title == null) { title = tag.getFirst(FieldKey.TITLE); } if (artist == null) { artist = tag.getFirst(FieldKey.ARTIST); } if (album == null) { album = tag.getFirst(FieldKey.ALBUM); } if (duration < 1) { try { AudioFile audioFile = AudioFileIO.read(new File(absolutePath)); duration = ((MP3AudioHeader) audioFile.getAudioHeader()).getPreciseTrackLength(); } catch (Exception e) { log.error("Input was not correct: " + absolutePath); log.trace(StackTrace.stackTrace(e)); } } if (bpm == 0) { try { bpm = Double.parseDouble(tag.getFirst(FieldKey.BPM)); } catch (NumberFormatException e) { if (isWindows) { analyzeTrack(); } try { bpm = Double.parseDouble(tag.getFirst(FieldKey.BPM)); log.info("BPM for: " + title + " is: " + bpm); } catch (NumberFormatException f) { log.error("There was no bpm information in file: " + absolutePath); log.trace(StackTrace.stackTrace(f)); } } } try { key = new MusicalKey(tag.getFirst(FieldKey.KEY)); } catch (IllegalArgumentException e) { if (isWindows) { analyzeTrack(); } try { key = new MusicalKey(tag.getFirst(FieldKey.KEY)); log.info("Key for: " + title + " is: " + key); } catch (IllegalArgumentException f) { log.error("There was no key information in file: " + absolutePath); log.trace(StackTrace.stackTrace(f)); } } try { id3EnergyParser(); } catch (NumberFormatException | NullPointerException e) { energyLevels(); if (this.getBpm() > 0.0) { calculateDifferences(); } } calculateTransitions(); System.out.println(this.getTitle()); System.out.println(averageEnergy); System.out.println(differences); System.out.println(outTransitionTimes + " OTT"); System.out.println(inTransitionTimes + " ITT\n"); }

Target:
private void getMetadata() { if (title == null) { title = tag.getFirst(FieldKey.TITLE); } if (artist == null) { artist = tag.getFirst(FieldKey.ARTIST); } if (album == null) { album = tag.getFirst(FieldKey.ALBUM); } if (duration < 1) { try { AudioFile audioFile = AudioFileIO.read(new File(absolutePath)); duration = ((MP3AudioHeader) audioFile.getAudioHeader()).getPreciseTrackLength(); } catch (Exception e) { log.error("Input was not correct: " + absolutePath); log.trace(StackTrace.stackTrace(e)); } } if (bpm == 0) { try { bpm = Double.parseDouble(tag.getFirst(FieldKey.BPM)); } catch (NumberFormatException e) { if (isWindows) { analyzeTrack(); } try { bpm = Double.parseDouble(tag.getFirst(FieldKey.BPM)); log.info("BPM for: " + title + " is: " + bpm); } catch (NumberFormatException f) { log.error("There was no bpm information in file: " + absolutePath); log.trace(StackTrace.stackTrace(f)); } } } try { key = new MusicalKey(tag.getFirst(FieldKey.KEY)); } catch (IllegalArgumentException e) { if (isWindows) { analyzeTrack(); } try { key = new MusicalKey(tag.getFirst(FieldKey.KEY)); log.info("Key for: " + title + " is: " + key); } catch (IllegalArgumentException f) { log.error("There was no key information in file: " + absolutePath); log.trace(StackTrace.stackTrace(f)); } } try { id3EnergyParser(); } catch (NumberFormatException | NullPointerException e) { energyLevels(); if (this.getBpm() > 0.0) { calculateDifferences(); } } calculateTransitions(); }
Source:
public void init() throws IOException { pinotCrypter = new NoOpPinotCrypter(); srcFile = File.createTempFile("srcFile","txt"); srcFile.deleteOnExit(); destinationFile = File.createTempFile("destFile","txt"); destinationFile.deleteOnExit(); FileUtils.write(srcFile,"testData"); }

Target:
public void init() throws IOException { pinotCrypter = new NoOpPinotCrypter(); srcFile = File.createTempFile("srcFile","txt"); encryptedFile = File.createTempFile("encryptedFile","txt"); encryptedFile.deleteOnExit(); decryptedFile = File.createTempFile("decryptedFile","txt"); decryptedFile.deleteOnExit(); FileUtils.write(srcFile,"testData"); }
Source:
public List<CommonCourtJudgment> generateCcJudgments(int count) { CommonCourt commonCourt = testPersistenceObjectFactory.createCcCourt(CommonCourtType.DISTRICT); CommonCourt[] commonCourts = new CommonCourt[] {commonCourt, commonCourt.getRegionalCourt(), commonCourt.getAppealCourt()}; List<CommonCourtJudgment> ccJudgments = testPersistenceObjectFactory.createCcJudgmentListWithRandomData(count); int i = 0; for (CommonCourtJudgment ccJudgment : ccJudgments) { ccJudgment.setCourtDivision(commonCourts[i % 2].getDivisions().get(0)); i++; } judgmentRepository.save(ccJudgments); judgmentRepository.flush(); return ccJudgments; }

Target:
public List<CommonCourtJudgment> generateCcJudgments(int count) { CommonCourt commonCourt = testPersistenceObjectFactory.createCcCourt(CommonCourtType.DISTRICT); CommonCourt[] commonCourts = new CommonCourt[] {commonCourt, commonCourt.getRegionalCourt(), commonCourt.getAppealCourt()}; List<CommonCourtJudgment> ccJudgments = testPersistenceObjectFactory.createCcJudgmentListWithRandomData(count); int i = 0; for (CommonCourtJudgment ccJudgment : ccJudgments) { ccJudgment.setCourtDivision(commonCourts[i % 3].getDivisions().get(0)); i++; } judgmentRepository.save(ccJudgments); judgmentRepository.flush(); return ccJudgments; }
Source:
protected boolean connect() throws IOException { if (isConnected()) { return false; } if (super.connect()) { this.sslEngine = sslContext.createSSLEngine(); this.sslEngine.setUseClientMode(true); this.sslSession = sslEngine.getSession(); sslEngine.beginHandshake(); doHandshake(channel(), sslEngine, ByteBuffer.allocate(sslSession.getPacketBufferSize()), ByteBuffer.allocate(sslSession.getPacketBufferSize())); } return false; }

Target:
protected boolean connect() throws IOException { if (super.connect()) { this.sslEngine = sslContext.createSSLEngine(); this.sslEngine.setUseClientMode(true); this.sslSession = sslEngine.getSession(); sslEngine.beginHandshake(); doHandshake(channel(), sslEngine, ByteBuffer.allocate(sslSession.getPacketBufferSize()), ByteBuffer.allocate(sslSession.getPacketBufferSize())); } return false; }
Source:
private static void setIconHotSpot(XmlPullParser parser, KmlStyle style) { float xValue, yValue; String xUnits, yUnits; if (TextUtils.isEmpty(parser.getAttributeValue(null, "x")) || TextUtils.isEmpty(parser.getAttributeValue(null, "y"))) { return; } xValue = Float.parseFloat(parser.getAttributeValue(null, "x")); yValue = Float.parseFloat(parser.getAttributeValue(null, "y")); xUnits = parser.getAttributeValue(null, "xunits"); yUnits = parser.getAttributeValue(null, "yunits"); style.setHotSpot(xValue, yValue, xUnits, yUnits); }

Target:
private static void setIconHotSpot(XmlPullParser parser, KmlStyle style) throws XmlPullParserException { if (parser.isEmptyElementTag()) { return; } float xValue, yValue; String xUnits, yUnits; xValue = Float.parseFloat(parser.getAttributeValue(null, "x")); yValue = Float.parseFloat(parser.getAttributeValue(null, "y")); xUnits = parser.getAttributeValue(null, "xunits"); yUnits = parser.getAttributeValue(null, "yunits"); style.setHotSpot(xValue, yValue, xUnits, yUnits); }
Source:
public void reset() { _startTime = 0L; _endTime = 0L; }

Target:
public void reset() { _startTime = VALUE_NOT_SET; _endTime = VALUE_NOT_SET; }
Source:
public void setUp() throws Exception { createAccountingDocumentService = new TestCreateAccountingDocumentServiceImpl(buildMockPersonService()); createAccountingDocumentService.setAccountingDocumentBatchInputFileType(buildAccountingXmlDocumentInputFileType()); createAccountingDocumentService.setBatchInputFileService(new BatchInputFileServiceImpl()); createAccountingDocumentService.setFileStorageService(buildFileStorageService()); createAccountingDocumentService.setConfigurationService(buildMockConfigurationService()); createAccountingDocumentService.setDocumentService(buildMockDocumentService()); createAccountingDocumentService.setCreateAccountingDocumentReportSerivce(new TestCreateAccountingDocumentReportSerivce()); createAccountingDocumentService.setParameterService(buildParameterervice()); routedAccountingDocuments = new ArrayList<>(); creationOrderedBaseFileNames = new ArrayList<>(); createTargetTestDirectory(); }

Target:
public void setUp() throws Exception { createAccountingDocumentService = new TestCreateAccountingDocumentServiceImpl(buildMockPersonService()); createAccountingDocumentService.setAccountingDocumentBatchInputFileType(buildAccountingXmlDocumentInputFileType()); createAccountingDocumentService.setBatchInputFileService(new BatchInputFileServiceImpl()); createAccountingDocumentService.setFileStorageService(buildFileStorageService()); createAccountingDocumentService.setConfigurationService(buildMockConfigurationService()); createAccountingDocumentService.setDocumentService(buildMockDocumentService()); createAccountingDocumentService.setCreateAccountingDocumentReportService(new TestCreateAccountingDocumentReportService()); createAccountingDocumentService.setParameterService(buildParameterService()); routedAccountingDocuments = new ArrayList<>(); creationOrderedBaseFileNames = new ArrayList<>(); createTargetTestDirectory(); }
Source:
private void collectDependencies() throws IOException, InterruptedException, NoSuchAlgorithmException { backupModAnsSumFiles(); List<String> goModArgs = new ArrayList<>(); goModArgs.addAll(Arrays.asList(GO_MOD_GRAPH_CMD.split(" "))); CommandResults goGraphResult = runGoCmd(goModArgs); String cachePath = getCachePath(); String dependenciesGraph[] = goGraphResult.getRes().split("\\r?\\n"); for (String entry : dependenciesGraph) { String moduleToAdd = entry.split(" ")[1]; addModuleDependencies(moduleToAdd, cachePath); } restoreModAnsSumFiles(); }

Target:
private void collectDependencies() throws Exception { backupModAnsSumFiles(); CommandResults goGraphResult = runGoCmd(GO_MOD_GRAPH_CMD); String cachePath = getCachePath(); String[] dependenciesGraph = goGraphResult.getRes().split("\\r?\\n"); for (String entry : dependenciesGraph) { String moduleToAdd = entry.split(" ")[1]; addModuleDependencies(moduleToAdd, cachePath); } restoreModAnsSumFiles(); }
Source:
public static void openConsole(File file) throws IOException { if (file == null) { return; } String absolutePath = file.toPath().toAbsolutePath().getParent().toString(); boolean usingDefault = Globals.prefs.getBoolean(JabRefPreferences.USE_DEFAULT_CONSOLE_APPLICATION); if (usingDefault) { NATIVE_DESKTOP.openConsole(absolutePath); } else { String command = Globals.prefs.get(JabRefPreferences.CONSOLE_COMMAND); command = command.trim(); if (!command.isEmpty()) { command = command.replaceAll("\\s+", " "); String[] subcommands = command.split(" "); String commandLoggingText = command.replace("%DIR", absolutePath); JabRefGUI.getMainFrame().getDialogService().notify(Localization.lang("Executing command \"%0\"...", commandLoggingText)); LOGGER.info("Executing command \"" + commandLoggingText + "\"..."); try { new ProcessBuilder(subcommands).start(); } catch (IOException exception) { LOGGER.error("Open console", exception); JOptionPane.showMessageDialog(null, Localization.lang("Error occured while executing the command \"%0\".", commandLoggingText), Localization.lang("Open console") + " - " + Localization.lang("Error"), JOptionPane.ERROR_MESSAGE); } } } }

Target:
public static void openConsole(File file) throws IOException { if (file == null) { return; } String absolutePath = file.toPath().toAbsolutePath().getParent().toString(); boolean usingDefault = Globals.prefs.getBoolean(JabRefPreferences.USE_DEFAULT_CONSOLE_APPLICATION); if (usingDefault) { NATIVE_DESKTOP.openConsole(absolutePath); } else { String command = Globals.prefs.get(JabRefPreferences.CONSOLE_COMMAND); command = command.trim(); if (!command.isEmpty()) { command = command.replaceAll("\\s+", " "); String[] subcommands = command.split(" "); String commandLoggingText = command.replace("%DIR", absolutePath); JabRefGUI.getMainFrame().getDialogService().notify(Localization.lang("Executing command \"%0\"...", commandLoggingText)); LOGGER.info("Executing command \"" + commandLoggingText + "\"..."); try { new ProcessBuilder(subcommands).start(); } catch (IOException exception) { LOGGER.error("Open console", exception); JabRefGUI.getMainFrame().getDialogService().showErrorDialogAndWait( Localization.lang("Open console") + " - " + Localization.lang("Error", Localization.lang("Error occured while executing the command \"%0\".", commandLoggingText))); } } } }
Source:
private void handleDescription(List<Field<String>> descriptionList, DocumentMetadata.Builder metaBuilder) { if (CollectionUtils.isNotEmpty(descriptionList)) { for (Field<String> currentDescription : descriptionList) { if (fieldApprover.approve(currentDescription.getDataInfo()) && StringUtils.isNotBlank(currentDescription.getValue()) && !NULL_STRING_VALUE.equals(currentDescription.getValue())) { metaBuilder.setAbstract$(currentDescription.getValue()); break; } } } }

Target:
private void handleDescription(List<Field<String>> descriptionList, DocumentMetadata.Builder metaBuilder) { if (CollectionUtils.isNotEmpty(descriptionList)) { descriptionList.stream().filter(x -> fieldApprover.approve(x.getDataInfo())) .filter(x -> StringUtils.isNotBlank(x.getValue())) .filter(x -> !NULL_STRING_VALUE.equals(x.getValue())).findFirst() .ifPresent(x -> metaBuilder.setAbstract$(x.getValue())); } }
Source:
protected void upgradeComplete() { health += 10; maxHealth += 10; radius = upgradeRadius[upgradeLevel]; capacity = upgradeCapacities[upgradeLevel]; }

Target:
protected void upgradeComplete() { maxHealth += 10; health = maxHealth; radius = upgradeRadius[upgradeLevel]; capacity = upgradeCapacities[upgradeLevel]; }
Source:
public boolean validate() { if (getDiskStorageType().getEntity() == DiskStorageType.LUN && getSanStorageModelBase() != null) { getSanStorageModelBase().validate(); if (!getSanStorageModelBase().getIsValid()) { return false; } ArrayList<String> partOfSdLunsMessages = getSanStorageModelBase().getPartOfSdLunsMessages(); if (!partOfSdLunsMessages.isEmpty() && !getSanStorageModelBase().isForce()) { if (!isForceCreationWarningCreated) { forceCreationWarning(partOfSdLunsMessages); isForceCreationWarningCreated = true; } return false; } } StorageType storageType = getStorageDomain().getSelectedItem() == null ? StorageType.UNKNOWN : getStorageDomain().getSelectedItem().getStorageType(); IntegerValidation sizeValidation = new IntegerValidation(); sizeValidation.setMinimum(getMinimumDiskSize()); if (storageType.isBlockDomain()) { sizeValidation.setMaximum((Integer) AsyncDataProvider.getInstance().getConfigValuePreConverted(ConfigValues.MaxBlockDiskSizeInGibiBytes)); } getSize().validateEntity(new IValidation[] { new NotEmptyValidation(), sizeValidation }); getStorageDomain().validateSelectedItem(new IValidation[] { new NotEmptyValidation() }); return super.validate() && getSize().getIsValid() && getStorageDomain().getIsValid(); }

Target:
public boolean validate() { if (getDiskStorageType().getEntity() == DiskStorageType.LUN && getSanStorageModelBase() != null) { getSanStorageModelBase().validate(); if (!getSanStorageModelBase().getIsValid()) { return false; } ArrayList<String> partOfSdLunsMessages = getSanStorageModelBase().getPartOfSdLunsMessages(); if (!partOfSdLunsMessages.isEmpty() && !getSanStorageModelBase().isForce()) { forceCreationWarning(partOfSdLunsMessages); return false; } } StorageType storageType = getStorageDomain().getSelectedItem() == null ? StorageType.UNKNOWN : getStorageDomain().getSelectedItem().getStorageType(); IntegerValidation sizeValidation = new IntegerValidation(); sizeValidation.setMinimum(getMinimumDiskSize()); if (storageType.isBlockDomain()) { sizeValidation.setMaximum((Integer) AsyncDataProvider.getInstance().getConfigValuePreConverted(ConfigValues.MaxBlockDiskSizeInGibiBytes)); } getSize().validateEntity(new IValidation[] { new NotEmptyValidation(), sizeValidation }); getStorageDomain().validateSelectedItem(new IValidation[] { new NotEmptyValidation() }); return super.validate() && getSize().getIsValid() && getStorageDomain().getIsValid(); }
Source:
private MyShowsClient(Context context) { this.context = context; this.api = new RestAdapter.Builder() .setEndpoint(API_URL) .setLogLevel(RestAdapter.LogLevel.FULL) .setRequestInterceptor(request -> request.addHeader("Cookie", TextUtils.join("; ", getCookies()))) .build() .create(MyShowsApi.class); }

Target:
private MyShowsClient(Context context) { this.preferences = context.getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE); this.api = new RestAdapter.Builder() .setEndpoint(API_URL) .setLogLevel(BuildConfig.DEBUG ? RestAdapter.LogLevel.FULL : RestAdapter.LogLevel.NONE) .setRequestInterceptor(request -> request.addHeader(COOKIE, TextUtils.join(COOKIE_DELIMITER, getCookies()))) .build() .create(MyShowsApi.class); }
Source:
public ReplaceKeysResponse getReplaceKeysResponse(@RequestPayload final ReplaceKeysAsyncRequest request) throws OsgpException { ReplaceKeysResponse response = null; try { final ResponseData responseData = this.responseDataService.dequeue(request.getCorrelationUid(), ComponentType.WS_SMART_METERING); this.throwExceptionIfResultNotOk(responseData, "replace keys on device"); response = new ReplaceKeysResponse(); response.setResult(OsgpResultType.fromValue(responseData.getResultType().getValue())); if (responseData.getMessageData() instanceof String) { response.setDescription((String) responseData.getMessageData()); } } catch (final Exception e) { this.handleException(e); } return response; }

Target:
public ReplaceKeysResponse getReplaceKeysResponse(@RequestPayload final ReplaceKeysAsyncRequest request) throws OsgpException { ReplaceKeysResponse response = null; try { final ResponseData responseData = this.responseDataService.dequeue(request.getCorrelationUid(), ComponentType.WS_SMART_METERING); this.throwExceptionIfResultNotOk(responseData, "replacing keys on the device"); response = new ReplaceKeysResponse(); response.setResult(OsgpResultType.fromValue(responseData.getResultType().getValue())); if (responseData.getMessageData() instanceof String) { response.setDescription((String) responseData.getMessageData()); } } catch (final Exception e) { this.handleException(e); } return response; }
Source:
public void determineProfileTest() { assertEquals(Profile.BIOLOGICAL_METRIC, controller.determineProfile(null)); FilterParameters filter = new FilterParameters(); filter.setDataProfile("biologicalMetric"); assertEquals(Profile.BIOLOGICAL_METRIC, controller.determineProfile(filter)); }

Target:
public void determineProfileTest() { assertEquals(Profile.BIOLOGICAL_METRIC, controller.determineProfile(null)); FilterParameters filter = new FilterParameters(); filter.setDataProfile("biological"); assertEquals(Profile.BIOLOGICAL, controller.determineProfile(filter)); }
Source:
public static String getString() { String returnString = ""; returnString += "\n\n---------------------------------------------------------------\n"; returnString += "OS_VERSION= " + System.getProperty("os.version") + "\n"; returnString += "RELEASE= " + Build.VERSION.RELEASE + "\n"; returnString += "DEVICE= " + Build.DEVICE + "\n"; returnString += "MODEL= " + Build.MODEL + "\n"; returnString += "PRODUCT= " + Build.PRODUCT + "\n"; returnString += "BRAND= " + Build.BRAND + "\n"; returnString += "DISPLAY= " + Build.DISPLAY + "\n"; if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) { returnString += "CPU_ABI= " + Build.CPU_ABI + "\n"; returnString += "CPU_ABI2= " + Build.CPU_ABI2 + "\n"; } else { returnString += "SUPPORTED_ABIS= " + TextUtils.join(", ", Build.SUPPORTED_ABIS) + "\n"; } returnString += "UNKNOWN= " + Build.UNKNOWN + "\n"; returnString += "HARDWARE= " + Build.HARDWARE + "\n"; returnString += "ID= " + Build.ID + "\n"; returnString += "MANUFACTURER= " + Build.MANUFACTURER + "\n"; returnString += "USER= " + Build.USER + "\n"; returnString += "HOST= " + Build.HOST + "\n"; return returnString; }

Target:
public static String getString() { String returnString = ""; returnString += "\n\n---------------------------------------------------------------\n"; returnString += "OS_VERSION= " + System.getProperty("os.version") + "\n"; returnString += "RELEASE= " + Build.VERSION.RELEASE + "\n"; returnString += "DEVICE= " + Build.DEVICE + "\n"; returnString += "MODEL= " + Build.MODEL + "\n"; returnString += "PRODUCT= " + Build.PRODUCT + "\n"; returnString += "BRAND= " + Build.BRAND + "\n"; returnString += "DISPLAY= " + Build.DISPLAY + "\n"; if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) { returnString += "CPU_ABI= " + Build.CPU_ABI + "\n"; returnString += "CPU_ABI2= " + Build.CPU_ABI2 + "\n"; } else { returnString += "SUPPORTED_ABIS= " + TextUtils.join(", ", Build.SUPPORTED_ABIS) + "\n"; } returnString += "HARDWARE= " + Build.HARDWARE + "\n"; returnString += "ID= " + Build.ID + "\n"; returnString += "MANUFACTURER= " + Build.MANUFACTURER + "\n"; returnString += "USER= " + Build.USER + "\n"; returnString += "HOST= " + Build.HOST + "\n"; return returnString; }
Source:
public ParseTexResultViewModel(TexParserResult texParserResult) { this.referenceList = FXCollections.observableArrayList(); this.citationList = FXCollections.observableArrayList(); texParserResult.getCitationsKeySet().forEach(key -> referenceList.add( new ReferenceWrapper(key, texParserResult.getCitationsByKey(key)))); }

Target:
public ParseTexResultViewModel(TexParserResult texParserResult) { this.referenceList = FXCollections.observableArrayList(); this.citationList = FXCollections.observableArrayList(); texParserResult.getCitations() .asMap() .forEach((entry, citations) -> referenceList.add(new ReferenceViewModel(entry, citations))); }
Source:
public Environment findOne(String application, String profile, String label) { if (StringUtils.isEmpty(label)) { label = "master"; } if (StringUtils.isEmpty(profile)) { profile = "default"; } if (!profile.startsWith("default")) { profile = "default," + profile; } String[] profiles = StringUtils.commaDelimitedListToStringArray(profile); Environment result = new Environment(application, profile, label, null, null); if (tokenMandatory) { if (accessStrategy.checkRemotePermissions()) { addPropertySource(application, profiles, result); } } else { addPropertySource(application, profiles, result); } return result; }

Target:
public Environment findOne(String application, String profile, String label) { if (StringUtils.isEmpty(label)) { label = "master"; } if (StringUtils.isEmpty(profile)) { profile = "default"; } if (!profile.startsWith("default")) { profile = "default," + profile; } String[] profiles = org.springframework.util.StringUtils .trimArrayElements(org.springframework.util.StringUtils.commaDelimitedListToStringArray(profile)); Environment result = new Environment(application, profile, label, null, null); if (tokenMandatory) { if (accessStrategy.checkRemotePermissions()) { addPropertySource(application, profiles, result); } } else { addPropertySource(application, profiles, result); } return result; }
Source:
public void start() { if(State.NOT_STARTED.equals(this.state)) { logger.debug("Transcriber is now transcribing"); this.state = State.TRANSCRIBING; this.executorService = Executors.newSingleThreadExecutor(); List<String> names = new ArrayList<>(participants.size()); participants.values().forEach((p) -> names.add(p.getName())); this.transcript.started(roomName, names); } else { logger.warn("Trying to start Transcriber while it is" + "already started"); } }

Target:
public void start() { if(State.NOT_STARTED.equals(this.state)) { logger.debug("Transcriber is now transcribing"); this.state = State.TRANSCRIBING; this.executorService = Executors.newSingleThreadExecutor(); List<String> names = new ArrayList<>(participants.size()); participants.values().forEach((p) -> { String name; if((name = p.getName()) == null) { name = p.getId(); } names.add(name); }); this.transcript.started(roomName, names); } else { logger.warn("Trying to start Transcriber while it is" + "already started"); } }
Source:
private Optional<SequenceAndBound> getLearnedState(long seq) { if (seq <= PaxosAcceptor.NO_LOG_ENTRY) { return Optional.of(ImmutableSequenceAndBound.of(PaxosAcceptor.NO_LOG_ENTRY, 0L)); } PaxosResponses<PaxosLong> responses = PaxosQuorumChecker.collectQuorumResponses( ImmutableList.copyOf(learners), learner -> getLearnedValue(seq, learner), QUORUM_OF_ONE, executor, PaxosQuorumChecker.DEFAULT_REMOTE_REQUESTS_TIMEOUT); if (!responses.hasQuorum()) { return Optional.empty(); } return Optional.of(ImmutableSequenceAndBound.of(seq, responses.getResponses().get(0).getValue())); }

Target:
private Optional<SequenceAndBound> getLearnedState(long seq) { if (seq <= PaxosAcceptor.NO_LOG_ENTRY) { return Optional.of(ImmutableSequenceAndBound.of(PaxosAcceptor.NO_LOG_ENTRY, 0L)); } PaxosResponses<PaxosLong> responses = PaxosQuorumChecker.collectQuorumResponses( ImmutableList.copyOf(learners), learner -> getLearnedValue(seq, learner), QUORUM_OF_ONE, executor, PaxosQuorumChecker.DEFAULT_REMOTE_REQUESTS_TIMEOUT); return Optional.ofNullable(Iterables.getFirst(responses.get(), null)) .map(PaxosLong::getValue) .map(value -> ImmutableSequenceAndBound.of(seq, value)); }
Source:
public void testStrlen() { assertExpr("strlen(x)", 3L); assertExpr("strlen(nonexistent)", NullHandling.defaultLongValue()); assertExprFail("strlen(a)", AssertionError.class, null); }

Target:
public void testStrlen() { assertExpr("strlen(x)", 3L); assertExpr("strlen(nonexistent)", NullHandling.defaultLongValue()); }
Source:
private CompiledQuery compileUsingModel(SqlExecutionContext executionContext) throws SqlException { lexer.unparse(); codeGenerator.clear(); ExecutionModel executionModel = compileExecutionModel(executionContext); switch (executionModel.getModelType()) { case ExecutionModel.QUERY: LOG.info().$("Compiled model: ").$((QueryModel) executionModel).$(); return compiledQuery.of(generate((QueryModel) executionModel, executionContext)); case ExecutionModel.CREATE_TABLE: return createTableWithRetries(executionModel, executionContext); case ExecutionModel.COPY: return executeCopy(executionContext, (CopyModel) executionModel); case ExecutionModel.RENAME_TABLE: final RenameTableModel rtm = (RenameTableModel) executionModel; engine.rename(executionContext.getCairoSecurityContext(), path, GenericLexer.unquote(rtm.getFrom().token), renamePath, GenericLexer.unquote(rtm.getTo().token)); return compiledQuery.ofRenameTable(); default: InsertModel insertModel = (InsertModel) executionModel; if (insertModel.getQueryModel() != null) { return executeWithRetries( insertAsSelectMethod, executionModel, configuration.getCreateAsSelectRetryCount(), executionContext ); } return insert(executionModel, executionContext); } }

Target:
private CompiledQuery compileUsingModel(SqlExecutionContext executionContext) throws SqlException { lexer.unparse(); codeGenerator.clear(); ExecutionModel executionModel = compileExecutionModel(executionContext); switch (executionModel.getModelType()) { case ExecutionModel.QUERY: LOG.info().$("compiled ").$((QueryModel) executionModel).$(" [fd=").$(executionContext.getRequestFd()).$(']').$(); return compiledQuery.of(generate((QueryModel) executionModel, executionContext)); case ExecutionModel.CREATE_TABLE: return createTableWithRetries(executionModel, executionContext); case ExecutionModel.COPY: return executeCopy(executionContext, (CopyModel) executionModel); case ExecutionModel.RENAME_TABLE: final RenameTableModel rtm = (RenameTableModel) executionModel; engine.rename(executionContext.getCairoSecurityContext(), path, GenericLexer.unquote(rtm.getFrom().token), renamePath, GenericLexer.unquote(rtm.getTo().token)); return compiledQuery.ofRenameTable(); default: InsertModel insertModel = (InsertModel) executionModel; if (insertModel.getQueryModel() != null) { return executeWithRetries( insertAsSelectMethod, executionModel, configuration.getCreateAsSelectRetryCount(), executionContext ); } return insert(executionModel, executionContext); } }
Source:
public static ETwitterCardType getTwitterCardType(@Nullable String identifier) { return ID_MAP.get(identifier).get(); }

Target:
public static Optional<ETwitterCardType> getTwitterCardType(@Nullable String identifier) { return ID_MAP.get(identifier); }
Source:
public long getStartTimestamp() { return startTimestamp; }

Target:
public long getStartTimestamp() { return this.startTimestamp; }