auphong2707/dl4se-code-review-dataset huggingface dataset:
Source:
<code>public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } SubchainInfo that = (SubchainInfo) o; <START> if (storageDomainId != null ? !storageDomainId.equals(that.storageDomainId) : that.storageDomainId != null) { return false; } if (imageGroupId != null ? !imageGroupId.equals(that.imageGroupId) : that.imageGroupId != null) { return false; } if (baseImageId != null ? !baseImageId.equals(that.baseImageId) : that.baseImageId != null) { return false; } if (topImageId != null ? !topImageId.equals(that.topImageId) : that.topImageId != null) { return false; } if (baseImageGeneration != null ? !baseImageGeneration.equals(that.baseImageGeneration) : that.baseImageGeneration != null) { return false; } if (baseImage != null ? !baseImage.equals(that.baseImage) : that.baseImage != null) { return false; } <END> return topImage != null ? topImage.equals(that.topImage) : that.topImage == null; }</code><technical_language>Objects.equals() save null checks</technical_language>

Target:
public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; SubchainInfo that = (SubchainInfo) o; return Objects.equals(storageDomainId, that.storageDomainId) && Objects.equals(imageGroupId, that.imageGroupId) && Objects.equals(baseImageId, that.baseImageId) && Objects.equals(topImageId, that.topImageId) && Objects.equals(baseImageGeneration, that.baseImageGeneration) && Objects.equals(baseImage, that.baseImage) && Objects.equals(topImage, that.topImage); }
Source:
<code>private void setAttribute() { ITmfStateSystemBuilder ss = (ITmfStateSystemBuilder) fContainer.getStateSystem(); int startingNodeQuark = fScenarioInfo.getQuark(); String subPath = ATTRIBUTE_PATH; int attributeQuark; try { attributeQuark = <START> ss.getQuarkRelative(startingNodeQuark, <END> subPath); } catch (AttributeNotFoundException e) { fAttribute = UUID.randomUUID().toString(); return; } ITmfStateValue sValue = ss.queryOngoingState(attributeQuark); fAttribute = NonNullUtils.nullToEmptyString(String.valueOf(sValue.unboxInt())); }</code><technical_language>optQuarkRelative if (attributeQuark != ITmfStateSystem.INVALID_ATTRIBUTE). relying exception handling for normal cases</technical_language>

Target:
private void setAttribute() { ITmfStateSystemBuilder ss = (ITmfStateSystemBuilder) fContainer.getStateSystem(); int startingNodeQuark = fScenarioInfo.getQuark(); String subPath = ATTRIBUTE_PATH; int attributeQuark = ss.optQuarkRelative(startingNodeQuark, subPath); if (attributeQuark != ITmfStateSystem.INVALID_ATTRIBUTE) { fAttribute = UUID.randomUUID().toString(); } else { ITmfStateValue sValue = ss.queryOngoingState(attributeQuark); fAttribute = String.valueOf(sValue.unboxInt()); } }
Source:
<code>public void init(LogFeederProps logFeederProps) { checkPointExtension = logFeederProps.getCheckPointExtension(); LOG.info("Determining valid checkpoint folder"); boolean isCheckPointFolderValid = false; checkPointFolder = logFeederProps.getCheckpointFolder(); if (!StringUtils.isEmpty(checkPointFolder)) { checkPointFolderFile = new File(checkPointFolder); isCheckPointFolderValid = verifyCheckPointFolder(checkPointFolderFile); } if (!isCheckPointFolderValid) { checkPointFolderFile = new File(logFeederProps.getTmpDir(), CHECKPOINT_SUBFOLDER_NAME); LOG.info("Checking if tmp folder can be used for checkpoints. Folder=" + checkPointFolderFile); isCheckPointFolderValid = verifyCheckPointFolder(checkPointFolderFile); if (isCheckPointFolderValid) { LOG.warn("Using tmp folder " + checkPointFolderFile + " to store check points. This is not recommended." + "Please set logfeeder.checkpoint.folder property"); } } if (isCheckPointFolderValid) { LOG.info("Using folder " + checkPointFolderFile + " for storing checkpoints"); <START> Thread checkpointCleanupThread = new Thread(new CheckpointCleanupMonitor(this, 2000),"checkpoint_cleanup"); <END> checkpointCleanupThread.setDaemon(true); checkpointCleanupThread.start(); } else { throw new IllegalStateException("Could not determine the checkpoint folder."); } }</code><technical_language>Suggest executor native thread creation</technical_language>

Target:
public void init(LogFeederProps logFeederProps) { checkPointExtension = logFeederProps.getCheckPointExtension(); LOG.info("Determining valid checkpoint folder"); boolean isCheckPointFolderValid = false; String checkPointFolder = logFeederProps.getCheckpointFolder(); if (!StringUtils.isEmpty(checkPointFolder)) { checkPointFolderFile = new File(checkPointFolder); isCheckPointFolderValid = verifyCheckPointFolder(checkPointFolderFile); } if (!isCheckPointFolderValid) { checkPointFolderFile = new File(logFeederProps.getTmpDir(), CHECKPOINT_SUBFOLDER_NAME); LOG.info("Checking if tmp folder can be used for checkpoints. Folder=" + checkPointFolderFile); isCheckPointFolderValid = verifyCheckPointFolder(checkPointFolderFile); if (isCheckPointFolderValid) { LOG.warn("Using tmp folder " + checkPointFolderFile + " to store check points. This is not recommended." + "Please set logfeeder.checkpoint.folder property"); } } if (isCheckPointFolderValid) { LOG.info("Using folder " + checkPointFolderFile + " for storing checkpoints"); Thread checkpointCleanupThread = new Thread(new CheckpointCleanupMonitor(this, 2000),"checkpoint_cleanup"); checkpointCleanupThread.setDaemon(true); checkpointCleanupThread.start(); } else { throw new IllegalStateException("Could not determine the checkpoint folder."); } }
Source:
<code>public void testBroadcastSerialDataReceiveSubscribedRx64() throws Exception { Mockito.when(rx64Packet.getReceiveOptions()).thenReturn(RECEIVE_OPTIONS_BROADCAST); dataReader.addSerialDatatReceiveListener(receiveSerialDataListener); Whitebox.invokeMethod(dataReader, PACKET_RECEIVED_METHOD, rx64Packet); PowerMockito.verifyPrivate(dataReader, Mockito.times(1)).invoke(NOTIFY_SERIAL_DATA_RECEIVED_METHOD, XBEE_64BIT_ADDRESS.toString(), RECEIVED_DATA_BYTES, IS_BROADCAST_DATA); Mockito.verify(receiveSerialDataListener, Mockito.times(1)).broadcastSerialDataReceived(XBEE_64BIT_ADDRESS.toString(), RECEIVED_DATA_BYTES); <START> <END> assertEquals(XBEE_64BIT_ADDRESS.toString(), receiveSerialDataListener.getAddress()); assertArrayEquals(RECEIVED_DATA_BYTES, receiveSerialDataListener.getSerialData()); }</code><technical_language>Add a check verify serialDataReceived method called</technical_language>

Target:
public void testBroadcastSerialDataReceiveSubscribedRx64() throws Exception { Mockito.when(rx64Packet.getReceiveOptions()).thenReturn(RECEIVE_OPTIONS_BROADCAST); dataReader.addSerialDatatReceiveListener(receiveSerialDataListener); Whitebox.invokeMethod(dataReader, PACKET_RECEIVED_METHOD, rx64Packet); PowerMockito.verifyPrivate(dataReader, Mockito.times(1)).invoke(NOTIFY_SERIAL_DATA_RECEIVED_METHOD, XBEE_64BIT_ADDRESS.toString(), RECEIVED_DATA_BYTES, IS_BROADCAST_DATA); Mockito.verify(receiveSerialDataListener, Mockito.times(1)).broadcastSerialDataReceived(XBEE_64BIT_ADDRESS.toString(), RECEIVED_DATA_BYTES); Mockito.verify(receiveSerialDataListener, Mockito.never()).serialDataReceived(Mockito.anyString(), (byte[])Mockito.any()); assertEquals(XBEE_64BIT_ADDRESS.toString(), receiveSerialDataListener.getAddress()); assertArrayEquals(RECEIVED_DATA_BYTES, receiveSerialDataListener.getSerialData()); }
Source:
<code>public ExtensionInstanceList getInstances( @PathParam("job-name") final String jobName, @QueryParam("start") final String nominalStart, @QueryParam("end") final String nominalEnd, @DefaultValue("") @QueryParam("instanceStatus") String instanceStatus, @DefaultValue("") @QueryParam("fields") String fields, @DefaultValue("") @QueryParam("orderBy") String orderBy, @DefaultValue("") @QueryParam("sortOrder") String sortOrder, @DefaultValue("0") @QueryParam("offset") final Integer offset, @QueryParam("numResults") Integer resultsPerPage, @DefaultValue("") @QueryParam("doAs") String doAsUser) { <START> LOG.error("instances is not supported on falcon extensions. Use falcon instance api on individual entities."); <END> throw FalconWebException.newAPIException("instances is not supported on falcon extensions. Use falcon instance " + "api on individual entities."); }</code><technical_language>Nit: Capitalize F in "falcon" in occurrences</technical_language>

Target:
public ExtensionInstanceList getInstances( @PathParam("job-name") final String jobName, @QueryParam("start") final String nominalStart, @QueryParam("end") final String nominalEnd, @DefaultValue("") @QueryParam("instanceStatus") String instanceStatus, @DefaultValue("") @QueryParam("fields") String fields, @DefaultValue("") @QueryParam("orderBy") String orderBy, @DefaultValue("") @QueryParam("sortOrder") String sortOrder, @DefaultValue("0") @QueryParam("offset") final Integer offset, @QueryParam("numResults") Integer resultsPerPage, @DefaultValue("") @QueryParam("doAs") String doAsUser) { LOG.error("instances is not supported on Falcon extensions. Use Falcon instance api on individual entities."); throw FalconWebException.newAPIException("instances is not supported on Falcon extensions. Use Falcon instance " + "api on individual entities."); }
Source:
<code><START> public Mono<Response<Flux<ByteBuffer>>> download() { <END> return this.download(null, null, false, null, null); }</code><technical_language>chat this return type...Please file a github issue part of a post-preview 1 API review discussion</technical_language>

Target:
public Mono<Response<Flux<ByteBuffer>>> download() { return this.download(null, null, false, null); }
Source:
<code>public void shutdown() { stopped = true; deadWatchers.clear(); cleaners.stop(); <START> super.interrupt(); <END> }</code><technical_language>change this.interrupt(), overwriting it</technical_language>

Target:
public void shutdown() { stopped = true; deadWatchers.clear(); cleaners.stop(); this.interrupt(); if (LOG.isInfoEnabled()) { LOG.info("WatcherCleaner thread shutdown is initiated"); } }
Source:
<code>public void resultReturned(int requestCode, int resultCode, Intent data) { if (requestCode == this.requestCode && resultCode == Activity.RESULT_OK) { if (data.hasExtra(RecognizerIntent.EXTRA_RESULTS)) { ArrayList<String> results = data.getExtras().getStringArrayList(RecognizerIntent.EXTRA_RESULTS); result = results.get(0); speechListener.onResult(result); } else { result = ""; <START> } <END> } }</code><technical_language>In current version of code, result is reported of branch is here. I recommend semantics consistent move call onResult in if branch</technical_language>

Target:
public void resultReturned(int requestCode, int resultCode, Intent data) { if (requestCode == this.requestCode && resultCode == Activity.RESULT_OK) { if (data.hasExtra(RecognizerIntent.EXTRA_RESULTS)) { ArrayList<String> results = data.getExtras().getStringArrayList(RecognizerIntent.EXTRA_RESULTS); result = results.get(0); } else { result = ""; } speechListener.onResult(result); } }
Source:
<code>protected void loadFormValues() { final Map<String, List<String>> dropDowns = new HashMap<String, List<String>>(); processDefinitionsListBox.clear(); processDeploymentIdListBox.clear(); currentFilter = new PortableQueryFilter(0, PAGE_SIZE_UNLIMITED, false, "", <START> FIELD_ID_PROCESSNAME, <END> true ); processDefinitionService.call( new RemoteCallback<List<ProcessSummary>>() { @Override public void callback( List<ProcessSummary> processSummaries ) { for ( ProcessSummary sum : processSummaries ) { if ( dropDowns.get( sum.getDeploymentId() ) == null ) { dropDowns.put( sum.getDeploymentId(), new ArrayList<String>() ); } dropDowns.get( sum.getDeploymentId() ).add( sum.getProcessDefId() ); } processDeploymentIdListBox.clear(); processDeploymentIdListBox.addItem( "--------" ); processDeploymentIdListBox.setSelectedIndex( 0 ); for ( String deploymentId : dropDowns.keySet() ) { processDeploymentIdListBox.addItem( deploymentId ); } } } ).getAll( currentFilter ); processDeploymentIdListBox.addChangeHandler( new ChangeHandler() { @Override public void onChange( ChangeEvent event ) { processDefinitionsListBox.clear(); processDefinitionsListBox.addItem( "-------" ); processDefinitionsListBox.setSelectedIndex( 0 ); int selected = processDeploymentIdListBox.getSelectedIndex(); if ( dropDowns.get( processDeploymentIdListBox.getValue( selected ) ) != null ) { for ( String processDef : dropDowns.get( processDeploymentIdListBox.getValue( selected ) ) ) { processDefinitionsListBox.addItem( processDef ); } } } } ); }</code><technical_language>I this sort is in place master, good send this PR in well</technical_language>

Target:
protected void loadFormValues() { final Map<String, List<String>> dropDowns = new HashMap<String, List<String>>(); processDefinitionsListBox.clear(); processDeploymentIdListBox.clear(); currentFilter = new PortableQueryFilter(0, Integer.MAX_VALUE - 1, false, "", FIELD_ID_PROCESSNAME, true); processDefinitionService.call( new RemoteCallback<List<ProcessSummary>>() { @Override public void callback( List<ProcessSummary> processSummaries ) { for ( ProcessSummary sum : processSummaries ) { if ( dropDowns.get( sum.getDeploymentId() ) == null ) { dropDowns.put( sum.getDeploymentId(), new ArrayList<String>() ); } dropDowns.get( sum.getDeploymentId() ).add( sum.getProcessDefId() ); } processDeploymentIdListBox.clear(); processDeploymentIdListBox.addItem( "--------" ); processDeploymentIdListBox.setSelectedIndex( 0 ); for ( String deploymentId : dropDowns.keySet() ) { processDeploymentIdListBox.addItem( deploymentId ); } } } ).getAll( currentFilter ); processDeploymentIdListBox.addChangeHandler( new ChangeHandler() { @Override public void onChange( ChangeEvent event ) { processDefinitionsListBox.clear(); processDefinitionsListBox.addItem( "-------" ); processDefinitionsListBox.setSelectedIndex( 0 ); int selected = processDeploymentIdListBox.getSelectedIndex(); if ( dropDowns.get( processDeploymentIdListBox.getValue( selected ) ) != null ) { for ( String processDef : dropDowns.get( processDeploymentIdListBox.getValue( selected ) ) ) { processDefinitionsListBox.addItem( processDef ); } } } } ); }
Source:
<code><START> private String surfaceRotationToString(int surfaceRotation) { <END> switch (surfaceRotation) { case Surface.ROTATION_0: return "0"; case Surface.ROTATION_90: return "90"; case Surface.ROTATION_180: return "180"; case Surface.ROTATION_270: return "270"; } throw new IllegalArgumentException("Unsupported surface rotation value" + surfaceRotation); }</code><technical_language>This method static static methods typically bottom of class</technical_language>

Target:
private static String surfaceRotationToString(int surfaceRotation) { switch (surfaceRotation) { case Surface.ROTATION_0: return "0"; case Surface.ROTATION_90: return "90"; case Surface.ROTATION_180: return "180"; case Surface.ROTATION_270: return "270"; } throw new IllegalArgumentException("Unsupported surface rotation value" + surfaceRotation); }
Source:
<code>public void registerDefaults() { this.equipmentTypeMap.put("any", new SpongeEquipmentType("any")); this.equipmentTypeMap.put("equipped", new SpongeEquipmentType("equipped")); final SpongeWornEquipmentType head = new SpongeWornEquipmentType("head", EntityEquipmentSlot.HEAD); this.equipmentTypeMap.put("headwear", head); this.equipmentTypeMap.put("head", head); <START> this.equipmentTypeMap.put("chestplate", new SpongeWornEquipmentType("chestplate", EntityEquipmentSlot.CHEST)); <END> this.equipmentTypeMap.put("leggings", new SpongeWornEquipmentType("leggings", EntityEquipmentSlot.LEGS)); this.equipmentTypeMap.put("boots", new SpongeWornEquipmentType("boots", EntityEquipmentSlot.FEET)); this.equipmentTypeMap.put("worn", new SpongeWornEquipmentType("worn", EntityEquipmentSlot.HEAD, EntityEquipmentSlot.CHEST, EntityEquipmentSlot.LEGS, EntityEquipmentSlot.FEET)); this.equipmentTypeMap.put("main_hand", new SpongeHeldEquipmentType("main_hand", EntityEquipmentSlot.MAINHAND)); this.equipmentTypeMap.put("off_hand", new SpongeHeldEquipmentType("off_hand", EntityEquipmentSlot.MAINHAND)); this.equipmentTypeMap.put("held", new SpongeHeldEquipmentType("held", EntityEquipmentSlot.MAINHAND, EntityEquipmentSlot.OFFHAND)); }</code><technical_language>this point, registrations method calls instead of repeating field access strings used</technical_language>

Target:
public void registerDefaults() { this.registerType("any"); this.registerType("equipped"); final SpongeWornEquipmentType head = this.registerWornType("head", EntityEquipmentSlot.HEAD); this.equipmentTypeMap.put("headwear", head); this.registerWornType("chestplate", EntityEquipmentSlot.CHEST); this.registerWornType("leggings", EntityEquipmentSlot.LEGS); this.registerWornType("boots", EntityEquipmentSlot.FEET); this.registerWornType("worn", EntityEquipmentSlot.HEAD, EntityEquipmentSlot.CHEST, EntityEquipmentSlot.LEGS, EntityEquipmentSlot.FEET); this.registerHeldType("main_hand", EntityEquipmentSlot.MAINHAND); this.registerHeldType("off_hand", EntityEquipmentSlot.OFFHAND); this.registerHeldType("held", EntityEquipmentSlot.MAINHAND, EntityEquipmentSlot.OFFHAND); }
Source:
<code>public boolean hasParent() { <START> return this.m_elements.size()>1; <END> }</code><technical_language>this.m_</technical_language>

Target:
public boolean hasParent() { return this.elements.size()>1; }
Source:
<code>public static void set( Object object, String path, Object value ) { final String[] split = StringUtils.split( path, '.' ); Object next = object; for( int i = 0; i < split.length - 1; i++ ) { <START> if( next == null ) break; <END> final Object instance = next; next = reflect( next.getClass() ) .field( split[i] ) .map( f -> f.get( instance ) ) .map( v -> v instanceof Optional ? ( ( Optional ) v ).orElse( null ) : v ) .orElse( null ); } if( next == null ) return; final MutableObject<Object> mutableObject = new MutableObject<>( next ); reflect( next.getClass() ) .field( split[split.length - 1] ) .ifPresent( f -> f.set( mutableObject.getValue(), value ) ); }</code><technical_language>throw NPE</technical_language>

Target:
public static void set( Object object, String path, Object value ) { final String[] split = StringUtils.split( path, '.' ); Object next = object; for( int i = 0; i < split.length - 1; i++ ) { Preconditions.checkState( next != null, format("Path [%s] contains nullable objects", path ) ); final Object instance = next; next = reflect( next.getClass() ) .field( split[i] ) .map( f -> f.get( instance ) ) .map( v -> v instanceof Optional ? ( ( Optional ) v ).orElse( null ) : v ) .orElse( null ); } Preconditions.checkState( next != null, format("Path [%s] contains nullable objects", path ) ); final MutableObject<Object> mutableObject = new MutableObject<>( next ); reflect( next.getClass() ) .field( split[split.length - 1] ) .ifPresent( f -> f.set( mutableObject.getValue(), f.type().isOptional() ? Optional.ofNullable( value ) : value ) ); }
Source:
<code>protected void executeCommand() { VmStatic vmStatic = getParameters().getVmStaticData(); boolean vmAddedSuccessfully = false; VdcReturnValueBase returnValueFromAddVm = null; if (VmTemplateHandler.BlankVmTemplateId.equals(vmStatic.getVmtGuid())) { AddVmFromScratchParameters tempVar = new AddVmFromScratchParameters(vmStatic, getParameters() .getDiskInfoList(), getParameters().getStorageDomainId()); tempVar.setSessionId(getParameters().getSessionId()); tempVar.setDontAttachToDefaultTag(true); returnValueFromAddVm = <START> Backend.getInstance().runInternalAction(VdcActionType.AddVmFromScratch, <END> tempVar, ExecutionHandler.createDefaultContexForTasks(getExecutionContext())); } else { VmManagementParametersBase tempVar2 = new VmManagementParametersBase(vmStatic); tempVar2.setSessionId(getParameters().getSessionId()); tempVar2.setDontCheckTemplateImages(true); tempVar2.setDontAttachToDefaultTag(true); tempVar2.setDiskInfoDestinationMap(diskInfoDestinationMap); returnValueFromAddVm = Backend.getInstance().runInternalAction(VdcActionType.AddVm, tempVar2, ExecutionHandler.createDefaultContexForTasks(getExecutionContext())); } vmAddedSuccessfully = returnValueFromAddVm.getSucceeded(); if (vmAddedSuccessfully) { getTaskIdList().addAll(returnValueFromAddVm.getInternalTaskIdList()); AddVmToPoolParameters tempVar3 = new AddVmToPoolParameters(getParameters().getPoolId(), vmStatic.getId()); tempVar3.setShouldBeLogged(false); setSucceeded(Backend.getInstance().runInternalAction(VdcActionType.AddVmToPool, tempVar3).getSucceeded()); addVmPermission(); } }</code><technical_language>pass compensation context calling this command</technical_language>

Target:
protected void executeCommand() { VmStatic vmStatic = getParameters().getVmStaticData(); VdcReturnValueBase returnValueFromAddVm; if (VmTemplateHandler.BlankVmTemplateId.equals(vmStatic.getVmtGuid())) { returnValueFromAddVm = addVmFromScratch(vmStatic); } else { returnValueFromAddVm = addVm(vmStatic); } if (returnValueFromAddVm.getSucceeded()) { getTaskIdList().addAll(returnValueFromAddVm.getInternalTaskIdList()); addVmToPool(vmStatic); } }
Source:
<code>public QueryFunc(String query) { super(); <START> Matcher m = Pattern.compile("q\\((.*?),\\s*(.*?)\\)").matcher(query); <END> if (!m.matches() || m.groupCount() != 2) { throw new ExpressionException( "Query segment [" + query + "] failed to parse. Groups=[" + m.groupCount() + "]"); } this.queryName = m.group(1).trim(); this.function = m.group(2).trim(); }</code><technical_language>here. Pattern static class</technical_language>

Target:
public QueryFunc(String query) { super(); Matcher m = PATTERN_QUERY_FUNC.matcher(query); if (!m.matches() || m.groupCount() != 2) { throw new IllegalArgumentException( "Query segment [" + query + "] failed to parse. Groups=[" + m.groupCount() + "]"); } this.queryName = m.group(1).trim(); this.function = m.group(2).trim(); }
Source:
<code>public String toString() { <START> return "LwM2mJsonElement [baseName=" + baseName + ", baseTime=" <END> + baseTime + ", resourceList=" + jsonArray + "]"; }</code><technical_language>StringFormat</technical_language>

Target:
public String toString() { return String.format("LwM2mJsonElement [baseName=%s, baseTime=%d, resourceList=%s]", baseName, baseTime, jsonArray); }
Source:
<code>private void processOptions(RepositoryState state) throws JGitInternalException { if (author == null) author = new PersonIdent(repo); if (name == null) throw new JGitInternalException(JGitText.get().tagNameNotSpecified); if (signed == true) <START> throw new UnsupportedOperationException(); <END> }</code><technical_language>explain in a message signed supported</technical_language>

Target:
private void processOptions(RepositoryState state) throws JGitInternalException { if (author == null) author = new PersonIdent(repo); if (name == null || !Repository.isValidRefName(Constants.R_TAGS + name)) throw new JGitInternalException(MessageFormat .format(JGitText.get().tagNameInvalid, name == null ? "<null>" : name)); if (signed == true) throw new UnsupportedOperationException(JGitText.get().signingNotSupportedOnTag); }
Source:
<code>AttributeChangeTracker(AttributeSet attributeSet) { attributeSet.attributes().forEach(a -> a.addListener((attr, oldVal) -> { if (this.isTracking) { String name = attr.name(); Object value = attr.get(); <START> changedAttributes.add(name.concat("=").concat(value == null ? "" : value.toString())); <END> } })); }</code><technical_language>calling concat here? I worry this prevent StringBuilder optimization for +'s</technical_language>

Target:
AttributeChangeTracker(AttributeSet attributeSet) { attributeSet.attributes().forEach(a -> a.addListener((attr, oldVal) -> { if (this.isTracking) { String name = attr.name(); Object value = attr.get(); changedAttributes.add(name + "=" + (value == null ? "" : value.toString())); } })); }
Source:
<code>private SelectItem createTagsSelect() { SelectItem tagsCb = new SelectItem(); tagsCb.setTitle("<b>Dirac tag</b>"); tagsCb.setType("comboBox"); final AsyncCallback<List<String>> callback = new AsyncCallback<List<String>>() { @Override public void onFailure(Throwable caught) { Layout.getInstance().setWarningMessage("Unable to retrieve configurated list of requirements, setting it to None:<br />" + caught.getMessage()); tagsCb.setValueMap("None"); } @Override public void onSuccess(List<String> result) { if(!result.contains("None")){ result.add("None"); } <START> LinkedHashMap<String, String> requirementsValues = new LinkedHashMap<String, String>(); <END> for (String requirement : result) { requirementsValues.put(requirement, requirement); } tagsCb.setValueMap(requirementsValues); } }; ApplicationImporterService.Util.getInstance().getApplicationImporterRequirements(callback); tagsCb.setValue("None"); return tagsCb; }</code><technical_language>Map type for declaration. diamond <> construction work. I suggest Map<String, String> requirementsValues = new LinkedHashMap<>();</technical_language>

Target:
private SelectItem createTagsSelect() { SelectItem tagsCb = new SelectItem(); tagsCb.setTitle("<b>Dirac tag</b>"); tagsCb.setType("comboBox"); final AsyncCallback<List<String>> callback = new AsyncCallback<List<String>>() { @Override public void onFailure(Throwable caught) { Layout.getInstance().setWarningMessage("Unable to retrieve configurated list of requirements, setting it to None:<br />" + caught.getMessage()); tagsCb.setValueMap("None"); } @Override public void onSuccess(List<String> result) { if(!result.contains("None")){ result.add("None"); } Map<String, String> requirementsValues = new LinkedHashMap<>(); for (String requirement : result) { requirementsValues.put(requirement, requirement); } tagsCb.setValueMap(requirementsValues); } }; ApplicationImporterService.Util.getInstance().getApplicationImporterRequirements(callback); tagsCb.setValue("None"); return tagsCb; }
Source:
<code>public Map<String,String> classify(String s) { Map<String,String> ret=new HashMap<String,String>(); <START> if(dclass_index!=0 && s!=null) <END> { long kv; kv=classify(dclass_index,s); if(kv!=0) { int len=kvlength(kv); String id=kvgetid(kv); for(int i=0;i<len;i++) { String key=kvgetkey(kv,i); String value=kvgetvalue(kv,i); ret.put(key,value); } ret.put("id",id); } } return ret; }</code><technical_language>isDClassInitialized hold initialization worked, do trading dclass_index!=0 for isDClassInitialized</technical_language>

Target:
public Map<String,String> classify(String s) { Map<String,String> ret=new HashMap<String,String>(); if(isDClassInitialized && s!=null) { long kv; kv=classify(dclass_index,s); if(kv!=0) { int len=kvlength(kv); String id=kvgetid(kv); for(int i=0;i<len;i++) { String key=kvgetkey(kv,i); String value=kvgetvalue(kv,i); ret.put(key,value); } ret.put("id",id); } } return ret; }
Source:
<code>public static X500Principal asX500Principal(Principal principal, boolean convert) { if (principal instanceof X500Principal) { return (X500Principal) principal; } if (X500_NAME_CLASS != null && X500_NAME_CLASS.isAssignableFrom(principal.getClass())) { try { return (X500Principal) AS_X500_PRINCIPAL_HANLDE.invoke(principal); } catch(RuntimeException | Error ex) { throw ex; } catch(final Throwable t) { <START> throw new RuntimeException(t); <END> } } if (convert) { try { return new X500Principal(principal.getName()); } catch (IllegalArgumentException ignored) { log.trace("Unable to convert to X500Principal", ignored); } } return null; }</code><technical_language>undeclared exception type wrapped UndeclaredThrowableException</technical_language>

Target:
public static X500Principal asX500Principal(Principal principal, boolean convert) { if (principal instanceof X500Principal) { return (X500Principal) principal; } if (X500_NAME_CLASS != null && X500_NAME_CLASS.isAssignableFrom(principal.getClass())) { try { return (X500Principal) AS_X500_PRINCIPAL_HANDLE.invoke(principal); } catch (RuntimeException | Error ex) { throw ex; } catch (Throwable t) { throw new UndeclaredThrowableException(t); } } if (convert) { try { return new X500Principal(principal.getName()); } catch (IllegalArgumentException ignored) { log.trace("Unable to convert to X500Principal", ignored); } } return null; }
Source:
<code>public synchronized void allocateEvaluators(final int evalNum, final int megaBytes, final int cores, final EventHandler<AllocatedEvaluator> evaluatorAllocatedHandler, final List<EventHandler<ActiveContext>> contextActiveHandlerList) { try { ongoingEvaluatorRequest.get().await(); } catch (final InterruptedException e) { <START> LOG.log(Level.WARNING, "Interrupted while waiting for ongoing request to be finished", e); <END> } LOG.log(Level.INFO, "Requesting {0} evaluators...", evalNum); for (int i = 0; i < evalNum; i++) { final Queue<EventHandler<ActiveContext>> handlerQueue = new ConcurrentLinkedQueue<>(contextActiveHandlerList); pendingEvalRequests.add(new Tuple2<>(evaluatorAllocatedHandler, handlerQueue)); } final EvaluatorRequest request = EvaluatorRequest.newBuilder() .setNumber(evalNum) .setNumberOfCores(cores) .setMemory(megaBytes) .build(); ongoingEvaluatorRequest.set(new CountDownLatch(request.getNumber())); evaluatorRequestor.submit(request); }</code><technical_language>If is interrupt, thread wait for count of latch proceed. safe if assume thread interrupt suddenly happen</technical_language>

Target:
public synchronized void allocateEvaluators(final int evalNum, final int megaBytes, final int cores, final EventHandler<AllocatedEvaluator> evaluatorAllocatedHandler, final List<EventHandler<ActiveContext>> contextActiveHandlerList) { while (true) { try { ongoingEvaluatorRequest.get().await(); break; } catch (final InterruptedException e) { LOG.log(Level.WARNING, "Interrupted while waiting for ongoing request to be finished", e); } } LOG.log(Level.INFO, "Requesting {0} evaluators with {1} MB memory and {2} cores...", new Object[]{evalNum, megaBytes, cores}); for (int i = 0; i < evalNum; i++) { final Queue<EventHandler<ActiveContext>> handlerQueue = new ConcurrentLinkedQueue<>(contextActiveHandlerList); pendingEvalRequests.add(new Tuple2<>(evaluatorAllocatedHandler, handlerQueue)); } final EvaluatorRequest request = EvaluatorRequest.newBuilder() .setNumber(evalNum) .setNumberOfCores(cores) .setMemory(megaBytes) .build(); ongoingEvaluatorRequest.set(new CountDownLatch(request.getNumber())); evaluatorRequestor.submit(request); }
Source:
<code>public void onPageStarted(WebView view, String urlClient, Bitmap favicon) { if (webViewLoadingDialog == null) { webViewLoadingDialog = new ProgressDialog(view.getContext(), R.style.WebViewLoadingCircle); webViewLoadingDialog.setCancelable(true); webViewLoadingDialog.setCanceledOnTouchOutside(false); webViewLoadingDialog.setProgressStyle(android.R.style.Widget_ProgressBar_Small); webViewLoadingDialog.show(); } if (callMainMenu && urlClient.equals(Constants.BASE_URL_HTTPS)) { Intent intent = null; if (BuildConfig.CREATE_AT_SCHOOL) { try { intent = new Intent(getBaseContext(), Class.forName("org.catrobat.catroid.createatschool.ui" + ".CreateAtSchoolMainMenuActivity")); } catch (ClassNotFoundException e) { Log.e(TAG, e.getMessage()); } <START> } else if (BuildConfig.PHIRO_CODE) { <END> try { intent = new Intent(getBaseContext(), Class.forName("org.catrobat.catroid.phiro.ui" + ".PhiroMainMenuActivity")); } catch (ClassNotFoundException e) { Log.e(TAG, e.getMessage()); } } else { intent = new Intent(getBaseContext(), MainMenuActivity.class); } startActivity(intent); } }</code><technical_language>here, flavored classes do this instead of Class.forName based a build flag</technical_language>

Target:
public void onPageStarted(WebView view, String urlClient, Bitmap favicon) { if (webViewLoadingDialog == null) { webViewLoadingDialog = new ProgressDialog(view.getContext(), R.style.WebViewLoadingCircle); webViewLoadingDialog.setCancelable(true); webViewLoadingDialog.setCanceledOnTouchOutside(false); webViewLoadingDialog.setProgressStyle(android.R.style.Widget_ProgressBar_Small); webViewLoadingDialog.show(); } if (callMainMenu && urlClient.equals(Constants.BASE_URL_HTTPS)) { startActivity(new Intent(getBaseContext(), MainMenuActivity.class)); } }
Source:
<code>public void testInitVersionRecordManager() { final ObservablePath path = mock(ObservablePath.class); final PlaceRequest placeRequest = mock(PlaceRequest.class); final String version = "version"; <START> final Callback<VersionRecord> callback = (v) -> { <END> }; when(versionRecordManager.getCurrentPath()).thenReturn(path); when(placeRequest.getParameter(anyString(), any())).thenReturn(version); doReturn(callback).when(editor).getSelectVersion(); doReturn(placeRequest).when(editor).getPlace(); editor.initVersionRecordManager(); verify(versionRecordManager).init(version, path, callback); }</code><technical_language>more readable simply a mock Callback</technical_language>

Target:
public void testInitVersionRecordManager() { final ObservablePath path = mock(ObservablePath.class); final PlaceRequest placeRequest = mock(PlaceRequest.class); final String version = "version"; final Callback<VersionRecord> selectionCallback = (v) -> { }; when(versionRecordManager.getCurrentPath()).thenReturn(path); when(placeRequest.getParameter(anyString(), any())).thenReturn(version); doReturn(selectionCallback).when(editor).getSelectVersion(); doReturn(placeRequest).when(editor).getPlace(); editor.initVersionRecordManager(); verify(versionRecordManager).init(version, path, selectionCallback); }
Source:
<code>public void run() { Looper.prepare(); try { initRealm(); setLooper(Looper.myLooper()); base.evaluate(); Looper.loop(); } catch (Throwable t) { setAssertionError(t); setUnitTestFailed(); } finally { try { looperTearDown(); closeResources(); <START> if (!runAfterTestIsComplete.isEmpty()) { <END> for (Runnable task : runAfterTestIsComplete) { task.run(); } } } catch (Throwable t) { setAssertionError(t); setUnitTestFailed(); } testComplete(); closeRealms(); signalClosedRealm.countDown(); } }</code><technical_language>required, fine :P</technical_language>

Target:
public void run() { Looper.prepare(); try { initRealm(); setLooper(Looper.myLooper()); base.evaluate(); Looper.loop(); } catch (Throwable t) { setAssertionError(t); setUnitTestFailed(); } finally { try { looperTearDown(); closeResources(); for (Runnable task : runAfterTestIsComplete) { task.run(); } } catch (Throwable t) { setAssertionError(t); setUnitTestFailed(); } testComplete(); closeRealms(); signalClosedRealm.countDown(); } }
Source:
<code>public void move() { if (!canMove) { return; } x += dx; y += dy; r += dr; <START> observers.get(1).update(this); <END> }</code><technical_language>Hardcoded, this done in a way. <bug</technical_language>

Target:
public void move() { if (!canMove) { return; } x += dx; y += dy; r += dr; observers.forEach(observer -> observer.update(this)); }
Source:
<code>protected void _check(String attributeValue) { <START> if ("a".equals(attributeValue)) { <END> addError("there is an error"); } }</code><technical_language>exhaustive 'a' is right password</technical_language>

Target:
protected void _check(String attributeValue) { if ("this password is not accepted by the TestValidator validator".equals(attributeValue)) { addError("the validator TestValidator rejected this password"); } }
Source:
<code>public static void main(String... args) { ManageDomainsArguments mdArgs = null; try { mdArgs = new ManageDomainsArguments(); mdArgs.parse(args); if (mdArgs.contains(ARG_LOG_FILE)) { <START> JavaLoggingUtils.addFileHandler(mdArgs.get(ARG_LOG_FILE), mdArgs.get(ARG_LOG_LEVEL)); <END> } } catch (Throwable t) { System.out.println(t.getMessage()); System.exit(1); } try { if (mdArgs.contains(ARG_HELP)) { mdArgs.printHelp(); System.exit(0); } else { ManageDomains util = new ManageDomains(mdArgs); util.init(); util.createConfigurationProvider(); util.runCommand(); } } catch (ManageDomainsResult e) { ManageDomains.exitOnError(e); } System.out.println(ManageDomainsResultEnum.OK.getDetailedMessage()); System.exit(ManageDomainsResultEnum.OK.getExitCode()); }</code><technical_language>separate arguments for log file log level? do create relationship them</technical_language>

Target:
public static void main(String... args) { ManageDomainsArguments mdArgs = null; try { mdArgs = new ManageDomainsArguments(); mdArgs.parse(args); if (mdArgs.contains(ARG_LOG_FILE)) { JavaLoggingUtils.addFileHandler(mdArgs.get(ARG_LOG_FILE)); } if (mdArgs.contains(ARG_LOG_LEVEL)) { JavaLoggingUtils.setLogLevel(mdArgs.get(ARG_LOG_LEVEL)); } } catch (Throwable t) { System.out.println(t.getMessage()); System.exit(1); } try { if (mdArgs.contains(ARG_HELP)) { mdArgs.printHelp(); System.exit(0); } else { ManageDomains util = new ManageDomains(mdArgs); util.init(); util.createConfigurationProvider(); util.runCommand(); } } catch (ManageDomainsResult e) { ManageDomains.exitOnError(e); } System.out.println(ManageDomainsResultEnum.OK.getDetailedMessage()); System.exit(ManageDomainsResultEnum.OK.getExitCode()); }
Source:
<code>public void start(BundleContext context) throws Exception { <START> super.start(context); <END> }</code><technical_language>missing uninstall "ws.jar" bundle code</technical_language>

Target:
public void start(BundleContext context) throws Exception { super.start(context); String jdkversion = System.getProperty("java.version"); if (!jdkversion.startsWith("11")) { Bundle bundle = Platform.getBundle("org.talend.mdm.ws.jars"); if (bundle != null && (bundle.getState() == Bundle.ACTIVE || bundle.getState() == Bundle.RESOLVED || bundle.getState() == Bundle.STARTING)) { bundle.uninstall(); } } }
Source:
<code>protected String getTraceNotApplyHelpText(ITmfTrace trace) { <START> return "Cannot perform the analysis on this trace because the trace is of the wrong type"; END> }</code><technical_language>externalize string</technical_language>

Target:
protected String getTraceNotApplyHelpText(ITmfTrace trace) { return Messages.TmfAbstractAnalysisModule_AnalysisDoesNotApply; }
Source:
<code>public Object evaluate(String colorMap, final double min, final double max) { GradientColorMapGenerator generator = null; Resource xmlFile = null; if (!colorMap.startsWith(GradientColorMapGenerator.RGB_INLINEVALUE_MARKER) && !colorMap.startsWith(GradientColorMapGenerator.HEX_INLINEVALUE_MARKER)) { GeoServerResourceLoader loader = GeoServerExtensions.bean(GeoServerResourceLoader.class); colorMap = colorMap.replace('\\', '/'); String path = Paths.path("styles","ramps", colorMap+"svg"); xmlFile = loader.get( path ); if( xmlFile.getType() != Type.RESOURCE ){ throw new IllegalArgumentException( "The specified colorMap do not exist in the styles/ramp folder\n" + "Check that " + path <START> + " exsusts abd is an .svg file"); <END> } } try { if (xmlFile != null) { generator = GradientColorMapGenerator.getColorMapGenerator(xmlFile.file()); } else { generator = GradientColorMapGenerator.getColorMapGenerator(colorMap); } return generator.generateColorMap(min, max); } catch (Exception e) { throw new IllegalArgumentException("Filter Function problem for function colormap", e); } }</code><technical_language>"exsusts abd" hem.... (typos in original exception)</technical_language>

Target:
public Object evaluate(String colorMap, final double min, final double max) { GradientColorMapGenerator generator = null; Resource xmlFile = null; if (!colorMap.startsWith(GradientColorMapGenerator.RGB_INLINEVALUE_MARKER) && !colorMap.startsWith(GradientColorMapGenerator.HEX_INLINEVALUE_MARKER)) { GeoServerResourceLoader loader = GeoServerExtensions.bean(GeoServerResourceLoader.class); colorMap = colorMap.replace('\\', '/'); String path = Paths.path("styles","ramps", colorMap+"svg"); xmlFile = loader.get( path ); if( xmlFile.getType() != Type.RESOURCE ){ throw new IllegalArgumentException( "The specified colorMap do not exist in the styles/ramp folder\n" + "Check that " + path + " exists and is an .svg file"); } } try { if (xmlFile != null) { generator = GradientColorMapGenerator.getColorMapGenerator(xmlFile.file()); } else { generator = GradientColorMapGenerator.getColorMapGenerator(colorMap); } return generator.generateColorMap(min, max); } catch (Exception e) { throw new IllegalArgumentException("Filter Function problem for function colormap", e); } }
Source:
<code>protected FileSystem doCreateFileSystem(final FileName name, final FileSystemOptions fileSystemOptions) throws FileSystemException { final GenericFileName rootName = (GenericFileName) name; Session session; UserAuthenticationData authData = null; try { authData = UserAuthenticatorUtils.authenticate(fileSystemOptions, AUTHENTICATOR_TYPES); session = SftpClientFactory.createConnection(rootName.getHostName(), rootName.getPort(), UserAuthenticatorUtils.getData(authData, UserAuthenticationData.USERNAME, UserAuthenticatorUtils.toChar(rootName.getUserName())), UserAuthenticatorUtils.getData(authData, UserAuthenticationData.PASSWORD, UserAuthenticatorUtils.toChar(rootName.getPassword())), fileSystemOptions); } catch (final Exception e) { <START> logger.info("Creat sftp connection fail: {}", e.getMessage()); <END> throw new FileSystemException("vfs.provider.sftp/connect.error", name, e); } finally { UserAuthenticatorUtils.cleanup(authData); } return new SftpFileSystem(rootName, session, fileSystemOptions); }</code><technical_language>1. log in warn error level instead of info? 2. Typo, Creat -> Create. full sentence e.g. Create SFTP connection failed: {}</technical_language>

Target:
protected FileSystem doCreateFileSystem(final FileName name, final FileSystemOptions fileSystemOptions) throws FileSystemException { final GenericFileName rootName = (GenericFileName) name; Session session; UserAuthenticationData authData = null; try { authData = UserAuthenticatorUtils.authenticate(fileSystemOptions, AUTHENTICATOR_TYPES); session = SftpClientFactory.createConnection(rootName.getHostName(), rootName.getPort(), UserAuthenticatorUtils.getData(authData, UserAuthenticationData.USERNAME, UserAuthenticatorUtils.toChar(rootName.getUserName())), UserAuthenticatorUtils.getData(authData, UserAuthenticationData.PASSWORD, UserAuthenticatorUtils.toChar(rootName.getPassword())), fileSystemOptions); } catch (final Exception e) { logger.error("Create SFTP connection was failed: {}", e.getMessage()); throw new FileSystemException("vfs.provider.sftp/connect.error", name, e); } finally { UserAuthenticatorUtils.cleanup(authData); } return new SftpFileSystem(rootName, session, fileSystemOptions); }
Source:
<code>public void run() { try { do { Thread.sleep(1000); } while (!gameStarted && !gameFinishedByOtherServer); while (!gameFinishedByOtherServer && !field.gameHasFinished()) { for (int clientId : connectedPlayers.keySet()) { ClientInterface ci = connectedPlayers.get(clientId); try { ci.ping(); clientPings.put(clientId, true); } catch (RemoteException e) { if (clientPings.containsKey(clientId) && !clientPings.get(clientId)) { clientCrashed(clientId); } else { clientPings.put(clientId, false); } } } <START> if (!otherServers.isEmpty()) { <END> for (int serverId : otherServers.keySet()) { try { otherServers.get(serverId).heartBeat(serverId); serverPings.put(serverId, 0); } catch (RemoteException e) { serverPings.put(serverId, serverPings.get(serverId) + 1); } } for (int serverId : serverPings.keySet()) { if (serverPings.get(serverId) > 1) { serverCrashed(serverId); } } } Set<Action> actionSet = field.dragonRage(connectedPlayers.keySet()); for (Action a : actionSet) { broadcastActionToClients(a); broadcastActionToServers(a); } Thread.sleep(1000); } if (!gameFinishedByOtherServer) { logger.info("Server " + ID + " finished the game."); EndOfGameAction endAction = new EndOfGameAction(this.ID); broadcastActionToClients(endAction); broadcastActionToServers(endAction); } logger.info("Server " + ID + " is going to sleep and exit now"); Thread.sleep(1000); System.exit(0); } catch (Exception e) { e.printStackTrace(); } }</code><technical_language>In this case isEmpty check is redundant I</technical_language>

Target:
public void run() { try { do { Thread.sleep(1000); } while (!gameStarted && !gameFinishedByOtherServer); while (!gameFinishedByOtherServer && !field.gameHasFinished()) { for (int clientId : connectedPlayers.keySet()) { ClientInterface ci = connectedPlayers.get(clientId); try { ci.ping(); clientPings.put(clientId, true); } catch (RemoteException e) { if (clientPings.containsKey(clientId) && !clientPings.get(clientId)) { clientCrashed(clientId); } else { clientPings.put(clientId, false); } } } for (int serverId : otherServers.keySet()) { try { otherServers.get(serverId).heartBeat(serverId); serverPings.put(serverId, 0); } catch (RemoteException e) { serverPings.put(serverId, serverPings.get(serverId) + 1); } } for (int serverId : serverPings.keySet()) { if (serverPings.get(serverId) > 1) { serverCrashed(serverId); } } Set<Action> actionSet = field.dragonRage(connectedPlayers.keySet()); for (Action a : actionSet) { broadcastActionToClients(a); broadcastActionToServers(a); } Thread.sleep(1000); } if (!gameFinishedByOtherServer) { logger.info("Server " + ID + " finished the game."); EndOfGameAction endAction = new EndOfGameAction(this.ID); broadcastActionToClients(endAction); broadcastActionToServers(endAction); } logger.info("Server " + ID + " is going to sleep and exit now"); Thread.sleep(1000); System.exit(0); } catch (Exception e) { e.printStackTrace(); } }
Source:
<code>public synchronized double getMaxCapacityUsageGauge() { return _maxCapacityUsageGauge.getValue(); <START> } <END></code><technical_language>required for test</technical_language>

Target:
protected synchronized double getMaxCapacityUsageGauge() { return _maxCapacityUsageGauge.getValue(); }
Source:
<code>protected Optional<DyeColor> getVal(TileEntityShulkerBox container) { <START> return Optional.ofNullable(((IMixinTileEntityShulkerBox) container).getColor()) <END> .map(enumValue -> (DyeColor) (Object) enumValue); }</code><technical_language>before. Unnecessary extra operations for minimal gain</technical_language>

Target:
protected Optional<DyeColor> getVal(TileEntityShulkerBox container) { EnumDyeColor enumType = ((IMixinTileEntityShulkerBox) container).getColor(); if (enumType != null) { return Optional.of((DyeColor) (Object) enumType); } return Optional.empty(); }
Source:
<code>public AccessToken refreshAccessToken() throws IOException { <START> if (!(this.sourceCredentials instanceof IdTokenProvider)) { <END> throw new IOException("Provided sourceToken does not implement IdTokenProvider"); } if (this.sourceCredentials.getAccessToken() == null) { this.sourceCredentials = this.sourceCredentials.createScoped(Arrays.asList(CLOUD_PLATFORM_SCOPE)); } try { this.sourceCredentials.refreshIfExpired(); } catch (IOException e) { throw new IOException("Unable to refresh sourceCredentials", e); } this.idToken = ((IdTokenProvider) this.sourceCredentials).idTokenWithAudience(targetAudience, options); return this.idToken; }</code><technical_language>If store IdTokenProvider GoogleCredentials, implement this as: java return idTokenProvider.idTokenWithAudience(targetAudience, options); I expect idTokenProvider refresh if possible</technical_language>

Target:
public AccessToken refreshAccessToken() throws IOException { return this.idTokenProvider.idTokenWithAudience(targetAudience, options); }