auphong2707/dl4se-code-review-dataset huggingface dataset:
Source:
public ClosableIterator<Tuple> callStoredProcedure(String storedProcedureName, ProcedureQueryParameters queryParameters, TupleContext tupleContext) { Map.Entry<String, Map> queryAndParams = buildProcedureQueryWithParams( storedProcedureName, queryParameters ); Statement statement = new Statement( queryAndParams.getKey(), queryAndParams.getValue() ); statement.setResultDataContents( Collections.singletonList( Statement.AS_ROW ) ); Statements statements = new Statements(); statements.addStatement( statement ); Long txId = transactionId( tupleContext.getTransactionContext() ); StatementsResponse response; if ( txId != null ) { response = client.executeQueriesInOpenTransaction( txId, statements ); } else { response = client.executeQueriesInNewTransaction( statements ); } validate( response, queryAndParams.getKey() ); return CollectionHelper.newClosableIterator( extractTuples( response ) ); }

Target:
public ClosableIterator<Tuple> callStoredProcedure(String storedProcedureName, ProcedureQueryParameters queryParameters, TupleContext tupleContext) { Map.Entry<String, Map<String, Object>> queryAndParams = buildProcedureQueryWithParams( storedProcedureName, queryParameters ); Statement statement = new Statement( queryAndParams.getKey(), queryAndParams.getValue() ); statement.setResultDataContents( Collections.singletonList( Statement.AS_ROW ) ); Statements statements = new Statements(); statements.addStatement( statement ); Long txId = transactionId( tupleContext.getTransactionContext() ); StatementsResponse response = client.executeQueriesInOpenTransaction( txId, statements ); if ( !response.getErrors().isEmpty() ) { ErrorResponse errorResponse = response.getErrors().get( 0 ); switch ( errorResponse.getCode() ) { case BaseNeo4jDialect.PROCEDURE_CALL_FAILED_CODE: throw log.cannotExecuteStoredProcedure( storedProcedureName, null ); case BaseNeo4jDialect.PROCEDURE_NOT_FOUND_CODE: throw log.procedureWithResolvedNameDoesNotExist( storedProcedureName, null ); default: throw new HibernateException( errorResponse.getMessage() ); } } return new HttpNeo4jMapsTupleIterator( response.getResults().get( 0 ) ); }
Source:
public void execute(DiagnosticContext context) { RestClient restClient = context.getEsRestClient(); String user = context.getDiagnosticInputs().getUser(); Version version = context.getVersion(); String url = null; int major = version.getMajor(); int minor = version.getMinor(); if(major == 2){ url = "/_shield/user/" + user; } else if (major <= 6){ url = "/_xpack/security/user/" + user; } else{ url = "/_security/user/" + user; } boolean hasAuthorization = false; RestResult result = restClient.execQuery(url); if(result.getStatus() == 200){ String userJsonString = result.toString(); JsonNode userNode = JsonYamlUtils.createJsonNodeFromString(userJsonString); JsonNode rolesNode = userNode.path("roles"); List<String> roles = new ArrayList<>(); if(rolesNode.isArray()){ ObjectMapper mapper = new ObjectMapper(); roles = mapper.convertValue(rolesNode, List.class); } if(major < 6){ if(roles.contains("admin")){ hasAuthorization = true; } } else if(major == 6 ){ if(minor < 3){ if(roles.contains("admin")){ hasAuthorization = true; } } else{ if(roles.contains("superuser")){ hasAuthorization = true; } } } else if(major > 6){ if(roles.contains("superuser")){ hasAuthorization = true; } } } if(! hasAuthorization){ logger.warn("The elasticsearch user entered: does not appear to have sufficient authorization to access all collected information", user); logger.warn("If you are using a custom role please verify that it has the admin role for versions prior to 6.3 or the superuser role for subsequent versions."); } }

Target:
public void execute(DiagnosticContext context) { RestClient restClient = context.getEsRestClient(); String user = context.getDiagnosticInputs().getUser(); boolean hasAuthorization = false; Version version = context.getVersion(); String url = null; int major = version.getMajor(); int minor = version.getMinor(); if (major <= 2) { url = "/_shield/user/" + user; } else if (major <= 6) { url = "/_xpack/security/user/" + user; } else { url = "/_security/user/" + user; } RestResult result = restClient.execQuery(url); if (result.getStatus() == 200) { String userJsonString = result.toString(); JsonNode userNode = JsonYamlUtils.createJsonNodeFromString(userJsonString); JsonNode rolesNode = userNode.path("roles"); List<String> roles = new ArrayList<>(); if (rolesNode.isArray()) { ObjectMapper mapper = new ObjectMapper(); roles = mapper.convertValue(rolesNode, List.class); } if (major <= 6) { if (roles.contains("admin")) { hasAuthorization = true; } } else { if (roles.contains("superuser")) { hasAuthorization = true; } } context.setAuthorized(hasAuthorization); } }
Source:
public Resource getResource() { if (resource == null) { return resource; } return cloneResource(resource); }

Target:
public Resource getResource() { if (resource == null) { return null; } return cloneResource(resource); }
Source:
public boolean isSupportedArrayComponentType(Class<?> componentType) { return byte.class == componentType || boolean.class == componentType || short.class == componentType || int.class == componentType || long.class == componentType || double.class == componentType; }

Target:
public boolean isSupportedArrayComponentType(Class<?> componentType) { return boolean.class == componentType || byte.class == componentType || short.class == componentType || int.class == componentType || long.class == componentType || double.class == componentType; }
Source:
public void testUnmarshallSubprocessLevelEventEmptyProperties() throws Exception { Diagram<Graph, Metadata> diagram = unmarshall(marshaller, BPMN_START_EVENT_FILE_PATH); assertDiagram(diagram, AMOUNT_OF_NODES_IN_DIAGRAM); StartNoneEvent emptySubprocess = getStartNodeById(diagram, EMPTY_SUBPROCESS_LEVEL_EVENT_ID, StartNoneEvent.class); assertGeneralSet(emptySubprocess.getGeneral(), EMPTY_VALUE, EMPTY_VALUE); assertStartEventSlaDueDate(emptySubprocess.getExecutionSet(), EMPTY_VALUE); }

Target:
public void testUnmarshallSubprocessLevelEventEmptyProperties() throws Exception { Diagram<Graph, Metadata> diagram = unmarshall(marshaller, BPMN_START_EVENT_FILE_PATH); assertDiagram(diagram, AMOUNT_OF_NODES_IN_DIAGRAM); StartNoneEvent emptySubprocess = getStartNodeById(diagram, EMPTY_SUBPROCESS_LEVEL_EVENT_ID, StartNoneEvent.class); assertGeneralSet(emptySubprocess.getGeneral(), EMPTY_VALUE, EMPTY_VALUE); assertNotNull(emptySubprocess.getExecutionSet()); assertStartEventSlaDueDate(emptySubprocess.getExecutionSet(), EMPTY_VALUE); }
Source:
public List<GenericVertex> search(String namespace, String providerId, String criteria, String context) { SearchCriteria searchCriteria = new SearchCriteria(providerId, namespace, criteria, context); return graphSearchService.search(searchCriteria); }

Target:
public Response search(String namespace, String providerId, String criteria, String context) { SearchCriteria searchCriteria = new SearchCriteria(providerId, namespace, criteria, context); List<GenericVertex> result = graphSearchService.search(searchCriteria); if(result.size() < 1) { return Response.noContent().build(); } return Response.ok(result).type(MediaType.APPLICATION_JSON_TYPE).build(); }
Source:
public boolean removeNodeId(final String location, final InetAddress address, final int nodeId) { if (address == null) { LOG.warn("removeNodeId: null IP address"); return false; } if (location == null) { List<Map.Entry<Key, Value>> keyValues = m_managedAddresses.entries().stream() .filter(keyValueEntry -> keyValueEntry.getValue().getNodeId() == nodeId).collect(Collectors.toList()); keyValues.forEach(keyValueEntry -> { LOG.debug("removeNodeId: removing IP address from cache:{}", str(address)); m_managedAddresses.remove(keyValueEntry.getKey(), keyValueEntry.getValue()); }); return true; } LOG.debug("removeNodeId: removing IP address from cache: {}:{}", location, str(address)); m_lock.writeLock().lock(); try { final Key key = new Key(location, address); return m_managedAddresses.remove(key, new Value(nodeId, PrimaryType.PRIMARY)) || m_managedAddresses.remove(key, new Value(nodeId, PrimaryType.SECONDARY)) || m_managedAddresses.remove(key, new Value(nodeId, PrimaryType.NOT_ELIGIBLE)); } finally { m_lock.writeLock().unlock(); } }

Target:
public boolean removeNodeId(final String location, final InetAddress address, final int nodeId) { if (address == null) { LOG.warn("removeNodeId: null IP address"); return false; } LOG.debug("removeNodeId: removing IP address from cache: {}:{}", location, str(address)); m_lock.writeLock().lock(); try { final Key key = new Key(location, address); return m_managedAddresses.remove(key, new Value(nodeId, PrimaryType.PRIMARY)) || m_managedAddresses.remove(key, new Value(nodeId, PrimaryType.SECONDARY)) || m_managedAddresses.remove(key, new Value(nodeId, PrimaryType.NOT_ELIGIBLE)); } finally { m_lock.writeLock().unlock(); } }
Source:
private boolean shouldRedraw(Repository db, AnyObjectId headId, List<FilterPath> paths) { boolean pathChanged = pathChanged(pathFilters, paths); boolean headChanged = headId == null || !headId.equals(currentHeadId); boolean repoChanged = false; boolean allBranchesChanged = currentShowAllBranches != store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_ALL_BRANCHES); currentShowAllBranches = store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_ALL_BRANCHES); boolean additionalRefsChange = currentShowAdditionalRefs != store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_ADDITIONAL_REFS); currentShowAdditionalRefs = store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_ADDITIONAL_REFS); boolean showNotesChanged = currentShowNotes != store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_NOTES); currentShowNotes = store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_NOTES); boolean followRenamesChanged = currentFollowRenames != getFollowRenames(); currentFollowRenames = getFollowRenames(); if (!db.equals(currentRepo)) { repoChanged = true; currentRepo = db; } return pathChanged || hasWalk == false || headChanged || repoChanged || allBranchesChanged || additionalRefsChange || showNotesChanged || followRenamesChanged; }

Target:
private boolean shouldRedraw(Repository db, AnyObjectId headId, List<FilterPath> paths) { boolean pathChanged = pathChanged(pathFilters, paths); boolean headChanged = headId == null || !headId.equals(currentHeadId); boolean repoChanged = false; boolean allBranchesChanged = currentShowAllBranches != store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_ALL_BRANCHES); currentShowAllBranches = store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_ALL_BRANCHES); boolean additionalRefsChange = currentShowAdditionalRefs != store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_ADDITIONAL_REFS); currentShowAdditionalRefs = store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_ADDITIONAL_REFS); boolean showNotesChanged = currentShowNotes != store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_NOTES); currentShowNotes = store .getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_NOTES); boolean followRenamesChanged = currentFollowRenames != getFollowRenames(); currentFollowRenames = getFollowRenames(); if (!db.equals(currentRepo)) { repoChanged = true; currentRepo = db; } return pathChanged || headChanged || repoChanged || allBranchesChanged || additionalRefsChange || showNotesChanged || followRenamesChanged; }
Source:
protected final void checkBooleanType(final Schema schema, final Schema stateSchema) { Type leftType = getLeft().getOutputType(schema, null); Type rightType = getRight().getOutputType(schema, null); Preconditions.checkArgument(leftType == Type.BOOLEAN_TYPE, "%s cannot handle left child [%s] of Type %s", getClass().getSimpleName(), getLeft(), leftType); Preconditions.checkArgument(rightType == Type.BOOLEAN_TYPE, "%s cannot handle right child [%s] of Type %s", getClass().getSimpleName(), getRight(), rightType); }

Target:
protected final void checkBooleanType(final Schema schema, final Schema stateSchema) { Type leftType = getLeft().getOutputType(schema, stateSchema); Type rightType = getRight().getOutputType(schema, stateSchema); Preconditions.checkArgument(leftType == Type.BOOLEAN_TYPE, "%s cannot handle left child [%s] of Type %s", getClass().getSimpleName(), getLeft(), leftType); Preconditions.checkArgument(rightType == Type.BOOLEAN_TYPE, "%s cannot handle right child [%s] of Type %s", getClass().getSimpleName(), getRight(), rightType); }
Source:
public static AggregateServerConnectionConfiguration from(String urlText, String username, char[] password) { URL url; try { url = new URL(urlText); } catch (MalformedURLException e) { throw new BriefcaseException("Invalid URL " + urlText); } return new AggregateServerConnectionConfiguration(url, Optional.ofNullable(Credentials.from(username, Arrays.toString(password)))); }

Target:
public static AggregateServerConnectionConfiguration from(String urlText, String username, char[] password) { URL url; try { url = new URL(urlText); } catch (MalformedURLException e) { throw new BriefcaseException("Invalid URL " + urlText, e); } Optional<String> optUsername = Optional.ofNullable(username); Optional<String> optPassword = Optional.of(password).map(Arrays::toString).filter(String::isEmpty); Optional<Credentials> from = optUsername.isPresent() && optPassword.isPresent() ? Optional.of(Credentials.from(optUsername.get(), optPassword.get())) : Optional.empty(); return new AggregateServerConnectionConfiguration(url, from); }
Source:
private void processString(String buildFileName) { IFile buildFile = AntUtil.getFileForLocation(buildFileName, null); if (!AntUtil.isKnownAntFile(buildFile)) { return; } String name = buildFile.getFullPath().toString(); for (AntProjectNode existingProject2 : view.getProjects()) { AntProjectNodeProxy existingProject = (AntProjectNodeProxy) existingProject2; if (existingProject.getBuildFileName().equals(name)) { return; } } AntProjectNode project = new AntProjectNodeProxy(name); view.addProject(project); }

Target:
private void processString(String buildFileName) { IFile buildFile = AntUtil.getFileForLocation(buildFileName, null); if (!AntUtil.isKnownAntFile(buildFile)) { return; } String name = buildFile.getFullPath().toString(); for (AntProjectNode node : view.getProjects()) { AntProjectNodeProxy existingProject = (AntProjectNodeProxy) node; if (existingProject.getBuildFileName().equals(name)) { return; } } AntProjectNode project = new AntProjectNodeProxy(name); view.addProject(project); }
Source:
public void onBuildStart(AbstractBuild<?, ?> build, TaskListener listener, GHRepository repo) throws GhprbCommitStatusException { String startedStatus = getDescriptor().getStartedStatusDefault(this); boolean showMatrixStatus = getDescriptor().getShowMatrixStatusDefault(this); if (StringUtils.equals(startedStatus, "--none--")) { return; } GhprbCause c = Ghprb.getCause(build); StringBuilder sb = new StringBuilder(); if (StringUtils.isEmpty(startedStatus)) { sb.append("Build started"); sb.append(c.isMerged() ? " sha1 is merged." : " sha1 is original commit."); } else { sb.append(Ghprb.replaceMacros(build, listener, startedStatus)); } if((showMatrixStatus && build.getProject() instanceof MatrixProject)){ return; } createCommitStatus(build, listener, sb.toString(), repo, GHCommitState.PENDING); }

Target:
public void onBuildStart(AbstractBuild<?, ?> build, TaskListener listener, GHRepository repo) throws GhprbCommitStatusException { String startedStatus = getDescriptor().getStartedStatusDefault(this); boolean showMatrixStatus = getDescriptor().getShowMatrixStatusDefault(this); if (StringUtils.equals(startedStatus, "--none--")) { return; } GhprbCause c = Ghprb.getCause(build); StringBuilder sb = new StringBuilder(); if (StringUtils.isEmpty(startedStatus)) { sb.append("Build started"); sb.append(c.isMerged() ? " sha1 is merged." : " sha1 is original commit."); } else { sb.append(Ghprb.replaceMacros(build, listener, startedStatus)); } if(showMatrixStatus && !(build.getProject() instanceof MatrixProject)){ return; } createCommitStatus(build, listener, sb.toString(), repo, GHCommitState.PENDING); }
Source:
public void notifyChanged(Notification notification) { super.notifyChanged(notification); final int eventType = notification.getEventType(); if (eventType == Notification.ADD || eventType == Notification.SET || eventType == Notification.ADD_MANY) { final ISelection selection; if (eventType == Notification.ADD || eventType == Notification.SET) { selection = new StructuredSelection(notification.getNewValue()); } else { final Collection<EObject> collection = (Collection<EObject>) notification.getNewValue(); selection = new StructuredSelection(collection.iterator().next()); } Display.getDefault().asyncExec(new Runnable() { @Override public void run() { treeViewer.setSelection(selection, true); } }); } }

Target:
public void notifyChanged(Notification notification) { super.notifyChanged(notification); final int eventType = notification.getEventType(); if (eventType == Notification.ADD || eventType == Notification.SET || eventType == Notification.ADD_MANY) { final ISelection selection; if (eventType == Notification.ADD || eventType == Notification.SET) { selection = new StructuredSelection(notification.getNewValue()); } else { final Collection<EObject> collection = (Collection<EObject>) notification.getNewValue(); selection = collection.iterator().hasNext() ? new StructuredSelection(collection.iterator().next()) : null; } if (selection == null) { return; } Display.getDefault().asyncExec(new Runnable() { @Override public void run() { treeViewer.setSelection(selection, true); } }); } }
Source:
public int getDespawnTime() { if (this.age == MAGIC_INFINITE_DESPAWN_TIME) { if ((this.pluginDespawnSet && this.infiniteDespawnDelay) || !this.pluginDespawnSet) { return -1; } } return this.lifespan - this.age; }

Target:
public int getDespawnTime() { if (this.age == MAGIC_INFINITE_DESPAWN_TIME) { if ((this.pluginDespawnSet && this.infiniteDespawnDelay) || !this.pluginDespawnSet) { return MAGIC_INFINITE; } } return this.lifespan - this.age; }
Source:
public void testGetTokenWithInvalidState(String opHost, String redirectUrl) throws Exception { final DevelopersApi client = Tester.api(); final RegisterSiteResponse site = RegisterSiteTest.registerSite(client, opHost, redirectUrl); final String invalidState = CoreUtils.secureRandomString(); final String authorizationStr = Tester.getAuthorization(site); final String code = CoreUtils.secureRandomString(); final GetTokensByCodeParams params = new GetTokensByCodeParams(); params.setOxdId(site.getOxdId()); params.setCode(code); params.setState(invalidState); try { client.getTokensByCode(authorizationStr, params); } catch (ApiException ex) { assertEquals(400, ex.getCode()); } }

Target:
public void testGetTokenWithInvalidState(String opHost, String redirectUrl) throws Exception { final DevelopersApi client = Tester.api(); final RegisterSiteResponse site = RegisterSiteTest.registerSite(client, opHost, redirectUrl); final String invalidState = CoreUtils.secureRandomString(); final String authorizationStr = Tester.getAuthorization(site); final String code = CoreUtils.secureRandomString(); final GetTokensByCodeParams params = new GetTokensByCodeParams(); params.setOxdId(site.getOxdId()); params.setCode(code); params.setState(invalidState); try { client.getTokensByCode(authorizationStr, params); fail("Test should throw an exception"); } catch (ApiException ex) { assertEquals(400, ex.getCode()); } }
Source:
public String getDomain() { if ("nodeid".equalsIgnoreCase(m_domain)) { return Integer.toString(getIfInfo().getNodeId()); } else if ("nodelabel".equalsIgnoreCase(m_domain)) { try { return new NodeLabelDaoImpl().retrieveLabel(getIfInfo().getNodeId()).getLabel(); } catch (Throwable e) { return "nodeid-" + Integer.toString(getIfInfo().getNodeId()); } } else { return m_domain; } }

Target:
public String getDomain() { if ("nodeid".equalsIgnoreCase(m_domain)) { return Integer.toString(getIfInfo().getNodeId()); } else if ("nodelabel".equalsIgnoreCase(m_domain)) { try { return new NodeLabelJDBCImpl().retrieveLabel(getIfInfo().getNodeId()).getLabel(); } catch (Throwable e) { return "nodeid-" + Integer.toString(getIfInfo().getNodeId()); } } else { return m_domain; } }
Source:
public static WorkerMetricsProcessor configureMetricProcessor(Map conf) throws MetricException { try { String processorClass = (String)conf.get(DaemonConfig.STORM_METRIC_PROCESSOR_CLASS); WorkerMetricsProcessor processor = (WorkerMetricsProcessor) (Class.forName(processorClass)).newInstance(); processor.prepare(conf); return processor; } catch (Throwable t) { throw new MetricException("Failed to create metric processor", t); } }

Target:
public static WorkerMetricsProcessor configureMetricProcessor(Map conf) throws MetricException { try { String processorClass = (String)conf.get(DaemonConfig.STORM_METRIC_PROCESSOR_CLASS); WorkerMetricsProcessor processor = (WorkerMetricsProcessor) (Class.forName(processorClass)).newInstance(); processor.prepare(conf); return processor; } catch (Exception e) { throw new MetricException("Failed to create metric processor", e); } }
Source:
private void cancelSearch() { if (searchTask == null || searchTask.isCancelled() || searchTask.isDone()) { return; } searchTask.cancel(true); if (searchTask.isCancelled()) { LOGGER.debug("Last search has been cancelled"); status.set(Status.INACTIVE); } else { LOGGER.warn("Could not cancel last search"); } }

Target:
private void cancelSearch() { if (searchTask == null || searchTask.isCancelled() || searchTask.isDone()) { return; } status.set(Status.IN_PROGRESS); searchTask.cancel(true); }
Source:
public Change createChange(IProgressMonitor pm) throws CoreException, OperationCanceledException { CompositeChange change = new CompositeChange(MessageFormat.format(PDEUIMessages.RenameExtensionPointProcessor_changeTitle, new Object[] {fInfo.getCurrentValue(), fInfo.getNewValue()})); SubMonitor subMonitor = SubMonitor.convert(pm, "", 2); changeExtensionPoint(change, subMonitor.newChild(1)); if (fInfo.isUpdateReferences()) findReferences(change, subMonitor.newChild(1)); return change; }

Target:
public Change createChange(IProgressMonitor pm) throws CoreException, OperationCanceledException { CompositeChange change = new CompositeChange(MessageFormat.format(PDEUIMessages.RenameExtensionPointProcessor_changeTitle, new Object[] {fInfo.getCurrentValue(), fInfo.getNewValue()})); SubMonitor subMonitor = SubMonitor.convert(pm, 2); changeExtensionPoint(change, subMonitor.newChild(1)); if (fInfo.isUpdateReferences()) findReferences(change, subMonitor.newChild(1)); return change; }
Source:
private String createJsonObject(final Map<String, Object> parameterMap) throws IOException { Buffer b = new Buffer(); JsonWriter writer = JsonWriter.of(b); writer.beginObject(); for (Entry<String, Object> pair : parameterMap.entrySet()) { String name = pair.getKey(); Object value = pair.getValue(); if (value instanceof Number) { writer.name(name).value((Number) value); } else if (value instanceof String) { writer.name(name).value((String) value); } else if (value instanceof Boolean) { writer.name(name).value((Boolean) value); } else { writer.name(name).value(value.toString()); } } writer.endObject(); return b.readString(Charset.forName("utf-8")); }

Target:
private String createJsonObject(final Map<String, Object> parameterMap) throws IOException { Buffer b = new Buffer(); JsonWriter writer = JsonWriter.of(b); writer.beginObject(); for (Entry<String, Object> pair : parameterMap.entrySet()) { String name = pair.getKey(); Object value = pair.getValue(); if (value instanceof Number) { Number number = (Number) value; writer.name(name).value(number); } else if (value instanceof String) { writer.name(name).value((String) value); } else if (value instanceof Boolean) { writer.name(name).value((Boolean) value); } else { writer.name(name).value(String.valueOf(value)); } } writer.endObject(); return b.readString(Charset.forName("utf-8")); }
Source:
public List<Ref> call() throws GitAPIException { checkCallable(); List<Ref> resultRefs; try { Collection<Ref> refs = new ArrayList<>(); Ref head = repo.exactRef(HEAD); if (head != null && head.getLeaf().getName().equals(HEAD)) { refs.add(head); } if (null == listMode) { refs.addAll(repo.getRefDatabase().getRefsByPrefix(R_HEADS)); } else switch (listMode) { case REMOTE: refs.addAll(repo.getRefDatabase().getRefsByPrefix(R_REMOTES)); break; default: refs.addAll(repo.getRefDatabase().getRefsByPrefix(R_HEADS, R_REMOTES)); break; } resultRefs = new ArrayList<>(filterRefs(refs)); } catch (IOException e) { throw new JGitInternalException(e.getMessage(), e); } Collections.sort(resultRefs, new Comparator<Ref>() { @Override public int compare(Ref o1, Ref o2) { return o1.getName().compareTo(o2.getName()); } }); setCallable(false); return resultRefs; }

Target:
public List<Ref> call() throws GitAPIException { checkCallable(); List<Ref> resultRefs; try { Collection<Ref> refs = new ArrayList<>(); Ref head = repo.exactRef(HEAD); if (head != null && head.getLeaf().getName().equals(HEAD)) { refs.add(head); } if (listMode == null) { refs.addAll(repo.getRefDatabase().getRefsByPrefix(R_HEADS)); } else if (listMode == ListMode.REMOTE) { refs.addAll(repo.getRefDatabase().getRefsByPrefix(R_REMOTES)); } else { refs.addAll(repo.getRefDatabase().getRefsByPrefix(R_HEADS, R_REMOTES)); } resultRefs = new ArrayList<>(filterRefs(refs)); } catch (IOException e) { throw new JGitInternalException(e.getMessage(), e); } Collections.sort(resultRefs, new Comparator<Ref>() { @Override public int compare(Ref o1, Ref o2) { return o1.getName().compareTo(o2.getName()); } }); setCallable(false); return resultRefs; }
Source:
public Observable<Trade> getTrades(CurrencyPair currencyPair, Object... args) { String channelName = "channel/trades/" + CoinmateStreamingAdapter.getChannelPostfix(currencyPair); ObjectReader reader = StreamingObjectMapperHelper.getObjectMapper().readerFor(new TypeReference<List<CoinmateWebSocketTrade>>() {}); CoinmateStreamingService service = serviceFactory.createAndConnect(channelName, false); return service.subscribeMessages() .map( s -> { List<CoinmateWebSocketTrade> list = reader.readValue(s); return list; }) .flatMapIterable(coinmateWebSocketTrades -> coinmateWebSocketTrades) .map( coinmateWebSocketTrade -> CoinmateStreamingAdapter.adaptTrade(coinmateWebSocketTrade, currencyPair) ); }

Target:
public Observable<Trade> getTrades(CurrencyPair currencyPair, Object... args) { String channelName = "channel/trades/" + CoinmateStreamingAdapter.getChannelPostfix(currencyPair); ObjectReader reader = StreamingObjectMapperHelper.getObjectMapper().readerFor(new TypeReference<List<CoinmateWebSocketTrade>>() {}); return serviceFactory.createConnection(channelName, false) .map( s -> reader.<List<CoinmateWebSocketTrade>>readValue(s)) .flatMapIterable(coinmateWebSocketTrades -> coinmateWebSocketTrades) .map( coinmateWebSocketTrade -> CoinmateStreamingAdapter.adaptTrade(coinmateWebSocketTrade, currencyPair) ); }
Source:
public void startElement(final String uri, final String localName, final String qName, final Attributes atts) throws SAXException { final DitaClass cls = atts.getValue(ATTRIBUTE_NAME_CLASS) != null ? new DitaClass(atts.getValue(ATTRIBUTE_NAME_CLASS)) : null; classes.addFirst(cls); if (cls != null && (TOPIC_TOPIC.matches(cls) || MAP_MAP.matches(cls))) { final String domains = atts.getValue(ATTRIBUTE_NAME_DOMAINS); if (domains == null) { logger.info(MessageUtils.getInstance().getMessage("DOTJ029I", localName).toString()); } else { props = StringUtils.getExtProps(domains); } } if (exclude) { level++; } else { if (cls!=null && filterUtils.needExclude(atts, props)) { exclude = true; level = 0; } else { elementOutput = true; for (final Map.Entry<String, String> prefix: prefixes.entrySet()) { getContentHandler().startPrefixMapping(prefix.getKey(), prefix.getValue()); } prefixes.clear(); getContentHandler().startElement(uri, localName, qName, atts); } } }

Target:
public void startElement(final String uri, final String localName, final String qName, final Attributes atts) throws SAXException { final DitaClass cls = atts.getValue(ATTRIBUTE_NAME_CLASS) != null ? new DitaClass(atts.getValue(ATTRIBUTE_NAME_CLASS)) : new DitaClass(""); if (cls.isValid()) { classes.addFirst(cls); } else { classes.addFirst(null); } if (cls.isValid() && (TOPIC_TOPIC.matches(cls) || MAP_MAP.matches(cls))) { final String domains = atts.getValue(ATTRIBUTE_NAME_DOMAINS); if (domains == null) { logger.info(MessageUtils.getInstance().getMessage("DOTJ029I", localName).toString()); } else { props = StringUtils.getExtProps(domains); } } if (exclude) { level++; } else { if (cls.isValid() && filterUtils.needExclude(atts, props)) { exclude = true; level = 0; } else { elementOutput = true; for (final Map.Entry<String, String> prefix: prefixes.entrySet()) { getContentHandler().startPrefixMapping(prefix.getKey(), prefix.getValue()); } prefixes.clear(); getContentHandler().startElement(uri, localName, qName, atts); } } }
Source:
private static Collection<?> getRows(DBObject document, AssociationKey associationKey, AssociationStorageStrategy storageStrategy) { Collection<?> rows; if ( storageStrategy == AssociationStorageStrategy.IN_ENTITY ) { if ( associationKey.getMetadata().isOneToOne() ) { Object oneToOneValue = getValueOrNull( (Map<?,?>) document, associationKey.getMetadata().getCollectionRole(), Object.class ); rows = oneToOneValue != null ? Collections.singletonList( oneToOneValue ) : Collections.emptyList(); } else { rows = getValueOrNull( (Map<?,?>) document, associationKey.getMetadata().getCollectionRole(), Collection.class ); } } else { rows = (Collection<?>) document.get( MongoDBDialect.ROWS_FIELDNAME ); } return rows != null ? rows : Collections.emptyList(); }

Target:
private static Collection<?> getRows(DBObject document, AssociationKey associationKey, AssociationStorageStrategy storageStrategy) { Collection<?> rows = null; if ( associationKey.getMetadata().isOneToOne() ) { Object oneToOneValue = getValueOrNull( document, associationKey.getMetadata().getCollectionRole(), Object.class ); if ( oneToOneValue != null ) { rows = Collections.singletonList( oneToOneValue ); } } else { Object toManyValue; if ( storageStrategy == AssociationStorageStrategy.IN_ENTITY ) { toManyValue = getValueOrNull( document, associationKey.getMetadata().getCollectionRole() ); } else { toManyValue = document.get( MongoDBDialect.ROWS_FIELDNAME ); } if ( toManyValue instanceof Collection ) { rows = (Collection<?>) toManyValue; } else if ( toManyValue instanceof DBObject ) { rows = getRowsFromMapAssociation( associationKey, (DBObject) toManyValue ); } } return rows != null ? rows : Collections.emptyList(); }
Source:
protected void renderProperties(ContentRenderer renderer) throws IOException { super.renderProperties(renderer); if (Strings.isEmpty(_src)) throw new UiException("src must be specified."); if ("subtitles".equals(_kind) && Strings.isEmpty(_srclang)) throw new UiException("srclang must be specified if kind is \"subtitles\""); render(renderer, "default", _default); render(renderer, "kind", _kind); render(renderer, "label", _label); render(renderer, "src", getEncodedSrc()); render(renderer, "srclang", _srclang); }

Target:
protected void renderProperties(ContentRenderer renderer) throws IOException { super.renderProperties(renderer); _init = false; if (Strings.isEmpty(_src)) throw new UiException("src must be specified."); if ("subtitles".equals(_kind) && Strings.isEmpty(_srclang)) throw new UiException("srclang must be specified if kind is \"subtitles\""); render(renderer, "default", _default); render(renderer, "kind", _kind); render(renderer, "label", _label); render(renderer, "src", getEncodedSrc()); render(renderer, "srclang", _srclang); }
Source:
public static void writeProperties(Properties toWrite) { try { FileOutputStream fileOutputStream; String homeDirectory = System.getProperty("user.home"); File file = new File(homeDirectory + "/" + PROPERTIES_DIRECTORY); file.mkdirs(); file = new File(PROPERTIES_FILEPATH); if(file.exists()) { file.delete(); } file.createNewFile(); fileOutputStream = new FileOutputStream(file); toWrite.store(fileOutputStream, null); fileOutputStream.close(); } catch(IOException exception) { Exceptions.printStackTrace(exception); } }

Target:
public static void writeProperties(Properties toWrite) { FileOutputStream fileOutputStream = null; try { String homeDirectory = System.getProperty("user.home"); File file = new File(homeDirectory + "/" + PROPERTIES_DIRECTORY); file.mkdirs(); file = new File(PROPERTIES_FILEPATH); if(file.exists()) { file.delete(); } file.createNewFile(); fileOutputStream = new FileOutputStream(file); toWrite.store(fileOutputStream, null); } catch(IOException exception) { Exceptions.printStackTrace(exception); } finally { IOUtils.closeQuietly(fileOutputStream); } }
Source:
public void typeAmountOfRows(int rows) { tablePropertiesInputs.get(0).clear(); tablePropertiesInputs.get(0).sendKeys(Integer.toString(rows)); PageObjectLogging.log("typeAmountOfRows", "amount of rows was typed", true, driver); }

Target:
public void typeAmountOfRows(int rows) { tablePropertiesInputs.get(0).clear(); tablePropertiesInputs.get(0).sendKeys(Integer.toString(rows)); PageObjectLogging.log( "typeAmountOfRows", "amount of rows was typed: " + rows, true ); }
Source:
protected static void verifyXml(String expectedOutputFile, ByteArrayOutputStream actualOutputStream, BiPredicate<Node, Node> ordered, String... messages) throws Exception { String expectedContents = readFile(expectedOutputFile); for (int i = 0; i < messages.length; i++) { expectedContents = expectedContents.replace("$" + i, messages[i]); } final Document expectedDocument = XmlUtil.getRawXml("audit output", expectedContents, expectedContents); final Document actualDocument = getOutputStreamXml(actualOutputStream); Assert.assertEquals("xml encoding should be the same: ", expectedDocument.getXmlEncoding(), actualDocument.getXmlEncoding()); Assert.assertEquals("xml version should be the same: ", expectedDocument.getXmlVersion(), actualDocument.getXmlVersion()); verifyXmlNode(expectedDocument, actualDocument, "/", ordered); }

Target:
protected static void verifyXml(String expectedOutputFile, ByteArrayOutputStream actualOutputStream, BiPredicate<Node, Node> ordered, String... messages) throws Exception { String expectedContents = readFile(expectedOutputFile); for (int i = 0; i < messages.length; i++) { expectedContents = expectedContents.replace("$" + i, messages[i]); } final Document expectedDocument = XmlUtil.getRawXml("audit output", expectedContents, expectedContents); final Document actualDocument = getOutputStreamXml(actualOutputStream); Assert.assertEquals("xml encoding should be the same", expectedDocument.getXmlEncoding(), actualDocument.getXmlEncoding()); Assert.assertEquals("xml version should be the same", expectedDocument.getXmlVersion(), actualDocument.getXmlVersion()); verifyXmlNode(expectedDocument, actualDocument, "/", ordered); }
Source:
public static ApiEndpointValidationResponseDTO sendHttpHEADRequest(String urlVal) { ApiEndpointValidationResponseDTO apiEndpointValidationResponseDTO = new ApiEndpointValidationResponseDTO(); HttpHead head = new HttpHead(urlVal); org.apache.commons.httpclient.HttpClient client = new org.apache.commons.httpclient.HttpClient(); head.addHeader("Host", urlVal.replaceAll("https?://", ""). replaceAll("(/.*)?", "")); client.getParams().setParameter("http.socket.timeout", 4000); client.getParams().setParameter("http.connection.timeout", 4000); HttpMethod method = new HeadMethod(urlVal); if (System.getProperty(APIConstants.HTTP_PROXY_HOST) != null && System.getProperty(APIConstants.HTTP_PROXY_PORT) != null) { log.debug("Proxy configured, hence routing through configured proxy"); String proxyHost = System.getProperty(APIConstants.HTTP_PROXY_HOST); String proxyPort = System.getProperty(APIConstants.HTTP_PROXY_PORT); client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, new HttpHost(proxyHost, Integer.parseInt(proxyPort))); } try { int statusCode = client.executeMethod(method); apiEndpointValidationResponseDTO.setStatusCode(statusCode); apiEndpointValidationResponseDTO.setStatusMessage(HttpStatus.getStatusText(statusCode)); } catch (Exception e) { log.error("Error occurred while sending the request to the given endpoint url:" + e); apiEndpointValidationResponseDTO.setError(e.getMessage()); } finally { method.releaseConnection(); } return apiEndpointValidationResponseDTO; }

Target:
public static ApiEndpointValidationResponseDTO sendHttpHEADRequest(String urlVal) { ApiEndpointValidationResponseDTO apiEndpointValidationResponseDTO = new ApiEndpointValidationResponseDTO(); HttpHead head = new HttpHead(urlVal); org.apache.commons.httpclient.HttpClient client = new org.apache.commons.httpclient.HttpClient(); head.addHeader("Host", urlVal.replaceAll("https?://", ""). replaceAll("(/.*)?", "")); client.getParams().setParameter("http.socket.timeout", 4000); client.getParams().setParameter("http.connection.timeout", 4000); HttpMethod method = new HeadMethod(urlVal); if (System.getProperty(APIConstants.HTTP_PROXY_HOST) != null && System.getProperty(APIConstants.HTTP_PROXY_PORT) != null) { log.debug("Proxy configured, hence routing through configured proxy"); String proxyHost = System.getProperty(APIConstants.HTTP_PROXY_HOST); String proxyPort = System.getProperty(APIConstants.HTTP_PROXY_PORT); client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, new HttpHost(proxyHost, Integer.parseInt(proxyPort))); } try { int statusCode = client.executeMethod(method); apiEndpointValidationResponseDTO.setStatusCode(statusCode); apiEndpointValidationResponseDTO.setStatusMessage(HttpStatus.getStatusText(statusCode)); } catch (Exception e) { log.error("Error occurred while sending the request to the given endpoint url:", e); apiEndpointValidationResponseDTO.setError(e.getMessage()); } finally { method.releaseConnection(); } return apiEndpointValidationResponseDTO; }
Source:
private void doRefresh() { try { AccessToken newToken = credentials.refreshAccessToken(); if (newToken == null) { this.tokenCache.set(new TokenCache(new IOException("Could not load the token for credentials: " + credentials))); } else { long expiresTime = newToken.getExpirationTime().getTime(); String header = "Bearer " + newToken.getTokenValue(); long stateTime = expiresTime - TOKEN_STALENESS_MS; long cacheExpiration = expiresTime - TOKEN_EXPIRES_MS; this.tokenCache.set(new TokenCache(header, stateTime, cacheExpiration)); } } catch (IOException e) { this.tokenCache.set(new TokenCache(e)); } catch (RuntimeException e) { this.tokenCache.set(new TokenCache(new IOException("Could not read headers", e))); } finally { synchronized (isRefreshing) { isRefreshing.set(false); isRefreshing.notifyAll(); } } }

Target:
private void doRefresh() { boolean requiresRefresh = false; synchronized (isRefreshing) { if (!isRefreshing.get()) { isRefreshing.set(true); requiresRefresh = true; HeaderCacheElement headerCache = this.headerCache.get(); CacheState state = (headerCache == null) ? CacheState.Expired : headerCache.getCacheState(); requiresRefresh = state != CacheState.Good; } } if (!requiresRefresh) { return; } HeaderCacheElement cacheElement = null; try { AccessToken newToken = credentials.refreshAccessToken(); if (newToken == null) { cacheElement = new HeaderCacheElement( new IOException("Could not load the token for credentials: " + credentials)); } else { cacheElement = new HeaderCacheElement(newToken); } } catch (IOException e) { cacheElement = new HeaderCacheElement(e); } catch (Exception e) { cacheElement = new HeaderCacheElement(new IOException("Could not read headers", e)); } finally { synchronized (isRefreshing) { this.headerCache.set(cacheElement); isRefreshing.set(false); isRefreshing.notifyAll(); } } }
Source:
protected void processFiltered(File file, List<String> lines) throws CheckstyleException { if (CommonUtils.matchesFileExtension(file, getFileExtensions())) { final String msg = "%s occurred during the analysis of file %s."; final String fileName = file.getPath(); try { if (!ordinaryChecks.isEmpty() || !commentChecks.isEmpty()) { final FileText text = FileText.fromLines(file, lines); final FileContents contents = new FileContents(text); final DetailAST rootAST = parse(contents); getMessageCollector().reset(); if (!ordinaryChecks.isEmpty()) { walk(rootAST, contents, AstState.ORDINARY); } if (!commentChecks.isEmpty()) { final DetailAST astWithComments = appendHiddenCommentNodes(rootAST); walk(astWithComments, contents, AstState.WITH_COMMENTS); } } } catch (final TokenStreamRecognitionException tre) { final String exceptionMsg = String.format(Locale.ROOT, msg, "TokenStreamRecognitionException", fileName); throw new CheckstyleException(exceptionMsg, tre); } catch (RecognitionException | TokenStreamException ex) { final String exceptionMsg = String.format(Locale.ROOT, msg, ex.getClass().getSimpleName(), fileName); throw new CheckstyleException(exceptionMsg, ex); } } }

Target:
protected void processFiltered(File file, List<String> lines) throws CheckstyleException { if (CommonUtils.matchesFileExtension(file, getFileExtensions())) { final String msg = "%s occurred during the analysis of file %s."; final String fileName = file.getPath(); try { if (!ordinaryChecks.isEmpty() || !commentChecks.isEmpty()) { final FileText text = FileText.fromLines(file, lines); final FileContents contents = new FileContents(text); final DetailAST rootAST = parse(contents); if (!ordinaryChecks.isEmpty()) { walk(rootAST, contents, AstState.ORDINARY); } if (!commentChecks.isEmpty()) { final DetailAST astWithComments = appendHiddenCommentNodes(rootAST); walk(astWithComments, contents, AstState.WITH_COMMENTS); } } } catch (final TokenStreamRecognitionException tre) { final String exceptionMsg = String.format(Locale.ROOT, msg, "TokenStreamRecognitionException", fileName); throw new CheckstyleException(exceptionMsg, tre); } catch (RecognitionException | TokenStreamException ex) { final String exceptionMsg = String.format(Locale.ROOT, msg, ex.getClass().getSimpleName(), fileName); throw new CheckstyleException(exceptionMsg, ex); } } }
Source:
private List<String> tabCompleteLongFlag(String longFlag, CommandSource src, CommandArgs args, CommandContext context) { String[] flagSplit = longFlag.split("=", 2); CommandElement element = this.longFlags.get(flagSplit[0].toLowerCase()); if (element == null) { return this.longFlags.keySet().stream() .filter(new StartsWithPredicate(flagSplit[0])) .map(f -> "--" + f) .collect(Collectors.toList()); } else if (flagSplit.length == 2) { args.insertArg(flagSplit[1]); } Object state = args.getState(); try { element.parse(src, args, context); } catch (ArgumentParseException ex) { args.setState(state); String start = flagSplit.length == 2 ? flagSplit[0] + "=" : args.hasNext() ? "" : flagSplit[0] + " "; return element.complete(src, args, context).stream() .map(s -> start + s) .collect(Collectors.toList()); } return null; }

Target:
private List<String> tabCompleteLongFlag(String longFlag, CommandSource src, CommandArgs args, CommandContext context) { String[] flagSplit = longFlag.split("=", 2); CommandElement element = this.longFlags.get(flagSplit[0].toLowerCase()); if (element == null || flagSplit.length == 1 && !args.hasNext()) { return this.longFlags.keySet().stream() .filter(new StartsWithPredicate(flagSplit[0])) .map(f -> "--" + f) .collect(Collectors.toList()); } else if (flagSplit.length == 2) { args.insertArg(flagSplit[1]); } Object state = args.getState(); try { element.parse(src, args, context); return null; } catch (ArgumentParseException ex) { args.setState(state); String prefix = flagSplit.length == 2 ? flagSplit[0] + "=" : ""; return element.complete(src, args, context).stream() .map(s -> prefix + s) .collect(Collectors.toList()); } }
Source:
public void shouldNotCreateAnyStandByTasksForStateStoreWithLoggingDisabled() throws Exception { final StreamsBuilder builder = new StreamsBuilder(); final String stateStoreName = "myTransformState"; final StoreBuilder<KeyValueStore<Integer, Integer>> keyValueStoreBuilder = Stores.keyValueStoreBuilder(Stores.persistentKeyValueStore(stateStoreName), Serdes.Integer(), Serdes.Integer()).withLoggingDisabled(); builder.addStateStore(keyValueStoreBuilder); builder.stream(INPUT_TOPIC, Consumed.with(Serdes.Integer(), Serdes.Integer())) .transform(() -> new Transformer<Integer, Integer, KeyValue<Integer, Integer>>() { @SuppressWarnings("unchecked") @Override public void init(final ProcessorContext context) @Override public KeyValue<Integer, Integer> transform(final Integer key, final Integer value) { return null; } @Override public void close() }, stateStoreName); final Topology topology = builder.build(); client1 = new KafkaStreams(topology, streamsConfiguration()); client2 = new KafkaStreams(topology, streamsConfiguration()); client1.setStateListener((newState, oldState) -> { if (newState == State.RUNNING && client1.localThreadsMetadata().stream().allMatch(thread -> thread.standbyTasks().isEmpty())) { client1IsOk = true; } }); client2.setStateListener((newState, oldState) -> { if (newState == State.RUNNING && client2.localThreadsMetadata().stream().allMatch(thread -> thread.standbyTasks().isEmpty())) { client2IsOk = true; } }); client1.start(); client2.start(); TestUtils.waitForCondition( () -> client1IsOk && client2IsOk, 30 * 1000, "At least one client did not reach state RUNNING without any stand-by tasks"); }

Target:
public void shouldNotCreateAnyStandByTasksForStateStoreWithLoggingDisabled() throws Exception { final StreamsBuilder builder = new StreamsBuilder(); final String stateStoreName = "myTransformState"; final StoreBuilder<KeyValueStore<Integer, Integer>> keyValueStoreBuilder = Stores.keyValueStoreBuilder(Stores.persistentKeyValueStore(stateStoreName), Serdes.Integer(), Serdes.Integer()).withLoggingDisabled(); builder.addStateStore(keyValueStoreBuilder); builder.stream(INPUT_TOPIC, Consumed.with(Serdes.Integer(), Serdes.Integer())) .transform(() -> new Transformer<Integer, Integer, KeyValue<Integer, Integer>>() { @SuppressWarnings("unchecked") @Override public void init(final ProcessorContext context) @Override public KeyValue<Integer, Integer> transform(final Integer key, final Integer value) { return null; } @Override public void close() }, stateStoreName); final Topology topology = builder.build(); createClients(topology, streamsConfiguration(), topology, streamsConfiguration()); setStateListenersForVerification(thread -> thread.standbyTasks().isEmpty() && !thread.activeTasks().isEmpty()); startClients(); waitUntilBothClientAreOK( "At least one client did not reach state RUNNING with active tasks but no stand-by tasks" ); }
Source:
static Process establishSocksProxyProcess(String proxyHost, int proxyPort) { LOG.info("Establishing SOCKS proxy..."); return ShellUtils.runASyncProcess(String.format("ssh -ND %d %s", proxyPort, proxyHost)); }

Target:
static Process establishSocksProxyProcess(String proxyHost, int proxyPort) { LOG.info(String.format("Establishing SOCKS proxy to: %s:%d", proxyHost, proxyPort)); return ShellUtils.runASyncProcess(String.format("ssh -ND %d %s", proxyPort, proxyHost)); }
Source:
public void equal() throws Exception { execute("a == null"); assertSingleValueInStack(EqualitySymbolicValue.class); RelationalSymbolicValue sv = (RelationalSymbolicValue) stack.peek(); assertThat(sv.leftOperand()).isEqualTo(simple1); assertThat(sv.rightOperand()).isEqualTo(SpecialSymbolicValue.NULL); assertSingleValueInStackWithConstraint(Constraint.BOOLEAN); }

Target:
public void equal() throws Exception { execute("a == null"); assertSingleValueInStack(RelationalSymbolicValue.create(Kind.EQUAL_TO, simple1, SpecialSymbolicValue.NULL)); }