id int64 1 49k | buggy stringlengths 34 37.5k | fixed stringlengths 2 37k |
|---|---|---|
40,101 | import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
<BUG>import javax.swing.JPopupMenu;
import javax.swing.KeyStroke;</BUG>
import javax.swing.ListCellRenderer;
import javax.swing.table.DefaultTableModel;
import javax.swing.text.JTextComponent;
| import javax.swing.JTable;
import javax.swing.KeyStroke;
|
40,102 | import org.openstreetmap.josm.io.XmlWriter;
import org.openstreetmap.josm.tools.GBC;
import org.openstreetmap.josm.tools.Shortcut;
import org.openstreetmap.josm.tools.Utils;
import org.openstreetmap.josm.tools.WindowGeometry;
<BUG>class TagEditHelper {
private final DefaultTableModel tagData;</BUG>
private final Map<String, Map<String, Integer>> valueCount;
private Collection<OsmPrimitive> sel;
private String changedKey;
| private final JTable tagTable;
private final DefaultTableModel tagData;
|
40,103 | AutoCompletionListItem item = iter.next();
if (item.getValue().equals(lastAddKey)) {
itemToSelect = item;
}
for (int i = 0; i < tagData.getRowCount(); ++i) {
<BUG>if (item.getValue().equals(tagData.getValueAt(i, 0))) {
</BUG>
if (itemToSelect == item) {
itemToSelect = null;
}
| if (item.getValue().equals(getDataKey(i))) {
|
40,104 | public void undoAllTagsAdding() {
Main.main.undoRedo.undo(commandCount);
}
private void disableTagIfNeeded(final Tag t, final JosmAction action) {
for (int j = 0; j < tagData.getRowCount(); ++j) {
<BUG>if (t.getKey().equals(tagData.getValueAt(j, 0))) {
</BUG>
action.setEnabled(false);
break;
}
| if (t.getKey().equals(getDataKey(j))) {
|
40,105 | private final JPopupMenu blankSpaceMenu = new JPopupMenu();
private final transient PopupMenuHandler tagMenuHandler = new PopupMenuHandler(tagMenu);
private final transient PopupMenuHandler membershipMenuHandler = new PopupMenuHandler(membershipMenu);
private final transient PopupMenuHandler blankSpaceMenuHandler = new PopupMenuHandler(blankSpaceMenu);
private final transient Map<String, Map<String, Integer>> valueCount = new TreeMap<>();
<BUG>private final transient TagEditHelper editHelper = new TagEditHelper(tagData, valueCount);
</BUG>
private final transient DataSetListenerAdapter dataChangedAdapter = new DataSetListenerAdapter(this);
private final HelpAction helpAction = new HelpAction();
private final TaginfoAction taginfoAction = new TaginfoAction();
| private final transient TagEditHelper editHelper = new TagEditHelper(tagTable, tagData, valueCount);
|
40,106 | if (nextKeyIndex == rows[rows.length-1]) {
nextKeyIndex = (nextKeyIndex + 1 < rowCount ? nextKeyIndex + 1 : rows[0] - 1);
} else {
nextKeyIndex++;
}
<BUG>nextKey = (String) tagData.getValueAt(nextKeyIndex, 0);
}</BUG>
Collection<OsmPrimitive> sel = Main.main.getInProgressSelection();
Main.main.undoRedo.add(new ChangePropertyCommand(sel, tags));
membershipTable.clearSelection();
| nextKey = editHelper.getDataKey(nextKeyIndex);
|
40,107 | rel.removeMembersFor(primitive);
}
Main.main.undoRedo.add(new ChangeCommand(cur, rel));
tagTable.clearSelection();
if (nextRelation != null) {
<BUG>membershipTable.changeSelection(findRow(membershipData, nextRelation), 0, false, false);
</BUG>
}
}
@Override
| membershipTable.changeSelection(findViewRow(membershipTable, membershipData, nextRelation), 0, false, false);
|
40,108 | String base = Main.pref.get("url.openstreetmap-wiki", "http://wiki.openstreetmap.org/wiki/");
String lang = LanguageInfo.getWikiLanguagePrefix();
final List<URI> uris = new ArrayList<>();
int row;
if (tagTable.getSelectedRowCount() == 1) {
<BUG>row = tagTable.getSelectedRow();
String key = Utils.encodeUrl(tagData.getValueAt(row, 0).toString());
@SuppressWarnings("unchecked")
Map<String, Integer> m = (Map<String, Integer>) tagData.getValueAt(row, 1);</BUG>
String val = Utils.encodeUrl(m.entrySet().iterator().next().getKey());
| String key = Utils.encodeUrl(editHelper.getDataKey(row));
Map<String, Integer> m = editHelper.getDataValues(row);
|
40,109 | int[] rows = tagTable.getSelectedRows();
Set<String> values = new TreeSet<>();
Collection<OsmPrimitive> sel = Main.main.getInProgressSelection();
if (rows.length == 0 || sel.isEmpty()) return;
for (int row: rows) {
<BUG>String key = tagData.getValueAt(row, 0).toString();
if (sel.isEmpty())</BUG>
return;
for (OsmPrimitive p : sel) {
Collection<String> s = getString(p, key);
| String key = editHelper.getDataKey(row);
if (sel.isEmpty())
|
40,110 | package cn.edu.buaa.crypto.encryption.hibe.bb04.params;
import cn.edu.buaa.crypto.pairingkem.params.PairingCiphertextParameters;
import it.unisa.dia.gas.jpbc.Element;
import it.unisa.dia.gas.jpbc.PairingParameters;
<BUG>import it.unisa.dia.gas.plaf.jpbc.util.ElementUtils;
public class HIBEBB04CiphertextParameters extends PairingCiphertextParameters {</BUG>
private int length;
private Element B;
private Element[] Cs;
| import cn.edu.buaa.crypto.Utils;
import java.util.Arrays;
public class HIBEBB04CiphertextParameters extends PairingCiphertextParameters {
|
40,111 | public HIBEBB04MasterSecretKeyParameters(PairingParameters pairingParameters, Element g2Alpha) {
super(true, pairingParameters);
this.g2Alpha = g2Alpha.getImmutable();
}
public Element getG2Alpha(){
<BUG>return this.g2Alpha;
</BUG>
}
@Override
public boolean equals(Object anObject) {
| return this.g2Alpha.duplicate();
|
40,112 | import cn.edu.buaa.crypto.encryption.hibe.bb04.HIBEBB04Engine;
import cn.edu.buaa.crypto.encryption.hibe.bb04.serialization.HIBEBB04SerializationFactory;
import cn.edu.buaa.crypto.pairingkem.params.PairingKeyEncapsulationPair;
import cn.edu.buaa.crypto.pairingkem.params.PairingKeyParameters;
import cn.edu.buaa.crypto.serialization.CipherParameterSerializationFactory;
<BUG>import it.unisa.dia.gas.jpbc.PairingParameters;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;</BUG>
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.InvalidCipherTextException;
import org.bouncycastle.util.encoders.Hex;
| import junit.framework.Test;
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
|
40,113 | CipherParameters sk01 = engine.keyGen(publicKey, masterKey, ids[0], ids[1]);
CipherParameters sk012 = engine.keyGen(publicKey, masterKey, ids[0], ids[1], ids[2]);
CipherParameters sk1 = engine.keyGen(publicKey, masterKey, ids[1]);
CipherParameters sk10 = engine.keyGen(publicKey, masterKey, ids[1], ids[0]);
CipherParameters sk021 = engine.keyGen(publicKey, masterKey, ids[0], ids[2], ids[1]);
<BUG>Document documentSk0 = serializationFactory.documentSerialization(sk0);
TestUtils.OutputXMLDocument("HIBE_Secret_Key_0.xml", documentSk0);
sk0 = serializationFactory.documentDeserialization(pairingParameters, documentSk0);
Document documentSk01 = serializationFactory.documentSerialization(sk01);
TestUtils.OutputXMLDocument("HIBE_Secret_Key_01.xml", documentSk01);
sk01 = serializationFactory.documentDeserialization(pairingParameters, documentSk01);
Document documentSk012 = serializationFactory.documentSerialization(sk012);
TestUtils.OutputXMLDocument("HIBE_Secret_Key_012.xml", documentSk012);
sk012 = serializationFactory.documentDeserialization(pairingParameters, documentSk012);</BUG>
String[] ids0 = new String[]{ids[0]};
| [DELETED] |
40,114 | e.printStackTrace();
System.exit(1);
}
try {
assertEquals(stringSessionKey01,
<BUG>new String(Hex.encode(engine.decapsulation(publicKey, sk01, ids01, ciphertext0)))
</BUG>
);
} catch (InvalidCipherTextException e) {
e.printStackTrace();
| new String(Hex.encode(engine.decapsulation(publicKey, sk01, ids01, ciphertext01)))
|
40,115 | this.g1 = g1.getImmutable();
this.g2 = g2.getImmutable();
this.h = ElementUtils.cloneImmutable(h);
this.maxLength = h.length;
}
<BUG>public Element getG() { return this.g; }
public Element getG1() { return this.g1; }
public Element getG2() { return this.g2; }
</BUG>
public Element[] getHs() { return Arrays.copyOf(this.h, this.h.length); }
| public Element getG() { return this.g.duplicate(); }
public Element getG1() { return this.g1.duplicate(); }
public Element getG2() { return this.g2.duplicate(); }
|
40,116 | private String stackName;
private Class<? extends PageEnum> pageEnumClass;
public StackConfig() {
super(StackModel.class);
}
<BUG>public StackConfig(Class<? extends Model> modelClass) {
</BUG>
super(modelClass);
}
public static StackConfig create() {
| public StackConfig(Class<StackModel> modelClass) {
|
40,117 | package org.jrebirth.af.component.ui.beans;
import org.jrebirth.af.api.ui.Model;
import org.jrebirth.af.core.ui.object.ModelConfig;
<BUG>public class PartConfig<PC extends PartConfig<PC>> extends ModelConfig<PC> {
public PartConfig(final Class<? extends Model> modelClass) {
super(modelClass);</BUG>
}
| public class PartConfig<M extends Model, PC extends PartConfig<M, PC>> extends ModelConfig<M, PC> {
public PartConfig(final Class<M> modelClass) {
super(modelClass);
|
40,118 | public class DockWaveBean implements WaveBean {
private String dockHolderKey;
private DockPaneConfig dockConfig;
private Model[] model;
private UniqueKey<? extends Model>[] modelKey;
<BUG>private PartConfig<?>[] parts;
</BUG>
public static DockWaveBean create() {
return new DockWaveBean();
}
| private PartConfig<?, ?>[] parts;
|
40,119 | listen(waveChecker, ADD);
listen(waveChecker, REMOVE);
if (ObjectUtility.nullOrEmpty(object().id())) {
object().id(DockPaneModel.class.getSimpleName() + DOCK_COUNTER++);
}
<BUG>for (final PartConfig<?> pc : object().panes()) {
</BUG>
callCommand(AddDockCommand.class, DockWaveBean.create().dockConfig(object()).parts(pc));
}
}
| for (final PartConfig<?, ?> pc : object().panes()) {
|
40,120 | object().panes().addListener(this::onPanesChanged);
}
private void onOrientationChanged(final ObservableValue<? extends DockPaneOrientation> property, final DockPaneOrientation oldValue, final DockPaneOrientation newValue) {
}
@SuppressWarnings("unchecked")
<BUG>private void onPanesChanged(final ListChangeListener.Change<? extends PartConfig<?>> change) {
</BUG>
while (change.next()) {
System.out.println(change);
if (change.wasPermutated()) {
| private void onPanesChanged(final ListChangeListener.Change<? extends PartConfig<?, ?>> change) {
|
40,121 | System.out.println(change);
if (change.wasPermutated()) {
System.err.println("PERMUTATION -------------------------------------------------------------------");
}
if (change.wasRemoved()) {
<BUG>final List<PartConfig<?>> rList = (List<PartConfig<?>>) change.getRemoved();
callCommand(RemoveDockCommand.class, DockWaveBean.create().dockConfig(object()).parts(rList.toArray(new PartConfig<?>[0])));
</BUG>
}
| final List<PartConfig<?, ?>> rList = (List<PartConfig<?, ?>>) change.getRemoved();
callCommand(RemoveDockCommand.class, DockWaveBean.create().dockConfig(object()).parts(rList.toArray(new PartConfig<?, ?>[0])));
|
40,122 | </BUG>
object().panes().remove(model.object());
view().removeItem(Collections.singletonList(model.node()));
}
<BUG>public void doInsertPart(int idx, final ModelObject<PartConfig<?>> model, final Wave wave) {
final PartConfig<?> partConfig = model.object();// BehaviorBean(TabBehavior.class);
</BUG>
if (idx < 0) {
idx = object().panes().isEmpty() ? 0 : object().panes().size();
| if (!object().panes().contains(model.object())) {
doInsertPart(-1, model, wave);
view().addItem(-1, model.node());
public void doRemovePart(final ModelObject<PartConfig<?, ?>> model, final Wave wave) {
public void doInsertPart(int idx, final ModelObject<PartConfig<?, ?>> model, final Wave wave) {
final PartConfig<?, ?> partConfig = model.object();// BehaviorBean(TabBehavior.class);
|
40,123 | import pebl.HasId;
@XmlAccessorType(XmlAccessType.NONE)
public class Metric implements HasId {
@XmlAttribute(required = true)
@XmlID
<BUG>private final String id;
@XmlAttribute(required = true)
@XmlIDREF</BUG>
private final MetricType metricType;
public Metric() {
| @XmlIDREF //TODO make it an attribute
|
40,124 | package pebl.result;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
<BUG>import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlIDREF;</BUG>
import pebl.benchmark.feature.Metric;
@XmlAccessorType(XmlAccessType.NONE)
public class Measurement {
| import javax.xml.bind.annotation.XmlElementRefs;
import javax.xml.bind.annotation.XmlIDREF;
|
40,125 | @XmlAccessorType(XmlAccessType.NONE)
public class Measurement {
@XmlIDREF
@XmlAttribute(required = true)
private final Metric metric;
<BUG>@XmlElement(required = true)
@XmlElementRef
private final Value value;
</BUG>
public Measurement() {
| private final String value;
|
40,126 | import java.util.Objects;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
<BUG>import javax.xml.bind.annotation.XmlID;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;</BUG>
import pebl.HasExtensions;
import pebl.HasId;
import pebl.HasName;
| import javax.xml.bind.annotation.XmlList;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
|
40,127 | public static final String DELIMITER = "--";
@XmlElement(required = true)
private final String name;
@XmlElement(required = true)
private final String version;
<BUG>@XmlElement(required = true)
private final List<String> configuration;</BUG>
@XmlElement(required = true)
private final String language;
@XmlJavaTypeAdapter(MapAdapter.class)
| @XmlList
private final List<String> configuration;
|
40,128 | package pebl.benchmark.test.assertions;
import java.util.Objects;
import javax.xml.bind.annotation.XmlAccessType;
<BUG>import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;</BUG>
import javax.xml.bind.annotation.XmlRootElement;
import pebl.benchmark.test.TestAssertion;
@XmlAccessorType(XmlAccessType.NONE)
| import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
|
40,129 | <BUG>package pebl.result.feature;
import javax.xml.bind.annotation.XmlAttribute;</BUG>
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlIDREF;
import pebl.result.Measurement;
| import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import javax.xml.bind.annotation.XmlAttribute;
|
40,130 | import javax.xml.bind.annotation.XmlIDREF;
import pebl.result.Measurement;
import pebl.result.engine.Engine;
import pebl.result.tool.Tool;
public class FeatureResult {
<BUG>@XmlElement(required = true)
private final Measurement measurement;
</BUG>
@XmlAttribute(required = true)
@XmlIDREF
| @XmlElement(required = true, name="measurement")
private final List<Measurement> measurements;
|
40,131 | @XmlAttribute(required = true)
private final String description;
@XmlAttribute(required = true)
private final String unit;
public MetricType() {
<BUG>this(new ValueType(), "", "", "");
</BUG>
}
public MetricType(ValueType dataType, String id, String description, String unit) {
this.dataType = Objects.requireNonNull(dataType);
| private final ValueType dataType;
@XmlID
private final String id;
this(ValueType.STRING, "", "", "");
|
40,132 | import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
<BUG>import javax.xml.bind.annotation.XmlID;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;</BUG>
import pebl.HasExtensions;
import pebl.HasName;
import pebl.HasId;
| import javax.xml.bind.annotation.XmlList;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
|
40,133 | @XmlElement(name="language")
private final List<Language> languages = new LinkedList<>();
@XmlElement(name="metric")
@XmlElementWrapper(name="metrics")
private final List<Metric> metrics = new LinkedList<>();
<BUG>@XmlElement(name="characteristic")
@XmlElementWrapper(name="characteristics")
private final List<Characteristic> characteristics = new LinkedList<>();</BUG>
@XmlJavaTypeAdapter(MapAdapter.class)
| @XmlElement(name="characteristics")
@XmlList
private final List<Characteristic> characteristics = new LinkedList<>();
|
40,134 | import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlID;
<BUG>import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;</BUG>
import pebl.HasExtensions;
import pebl.HasId;
import pebl.HasName;
| import javax.xml.bind.annotation.XmlList;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
|
40,135 | @XmlElement(required = true)
private final String description;
@XmlElement(name="testCase")
@XmlElementWrapper( name="testCases" )
private final List<TestCase> testCases;
<BUG>@XmlElement(name="file")
@XmlElementWrapper(name="files")
private final List<Path> files;</BUG>
@XmlElement(required = true)
| private final Path process;
@XmlElement(name="files")
@XmlList
private final List<Path> files;
|
40,136 | context.setAuthCache(authCache);
ApacheHttpClient4Engine engine = new ApacheHttpClient4Engine(httpclient, context);
ResteasyClient client = new ResteasyClientBuilder().httpEngine(engine).build();
client.register(JacksonJaxbJsonProvider.class);
client.register(JacksonObjectMapperProvider.class);
<BUG>client.register(RequestLogger.class);
client.register(ResponseLogger.class);
</BUG>
ProxyBuilder<T> proxyBuilder = client.target(uri).proxyBuilder(apiClassType);
| client.register(RestRequestFilter.class);
client.register(RestResponseFilter.class);
|
40,137 | import org.hawkular.alerts.api.model.condition.Condition;
import org.hawkular.inventory.api.model.CanonicalPath;
import org.hawkular.inventory.api.model.Tenant;
import org.hawkular.inventory.json.DetypedPathDeserializer;
import org.hawkular.inventory.json.InventoryJacksonConfig;
<BUG>import org.hawkular.inventory.json.mixins.CanonicalPathMixin;
</BUG>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.core.JsonParseException;
| import org.hawkular.inventory.json.mixins.model.CanonicalPathMixin;
|
40,138 | private final HystrixProperty<Integer> corePoolSize;
private final HystrixProperty<Integer> maximumPoolSize;
private final HystrixProperty<Integer> keepAliveTime;
private final HystrixProperty<Integer> maxQueueSize;
private final HystrixProperty<Integer> queueSizeRejectionThreshold;
<BUG>private final boolean allowMaximumSizeToDivergeFromCoreSize;
</BUG>
private final HystrixProperty<Integer> threadPoolRollingNumberStatisticalWindowInMilliseconds;
private final HystrixProperty<Integer> threadPoolRollingNumberStatisticalWindowBuckets;
protected HystrixThreadPoolProperties(HystrixThreadPoolKey key) {
| private final HystrixProperty<Boolean> allowMaximumSizeToDivergeFromCoreSize;
|
40,139 | }
protected HystrixThreadPoolProperties(HystrixThreadPoolKey key, Setter builder) {
this(key, builder, "hystrix");
}
protected HystrixThreadPoolProperties(HystrixThreadPoolKey key, Setter builder, String propertyPrefix) {
<BUG>this.allowMaximumSizeToDivergeFromCoreSize = getValueOnce(propertyPrefix, key, "allowMaximumSizeToDivergeFromCoreSize",
</BUG>
builder.getAllowMaximumSizeToDivergeFromCoreSize(), default_allow_maximum_size_to_diverge_from_core_size);
this.corePoolSize = getProperty(propertyPrefix, key, "coreSize", builder.getCoreSize(), default_coreSize);
this.maximumPoolSize = getProperty(propertyPrefix, key, "maximumSize", builder.getMaximumSize(), default_maximumSize);
| this.allowMaximumSizeToDivergeFromCoreSize = getProperty(propertyPrefix, key, "allowMaximumSizeToDivergeFromCoreSize",
|
40,140 | </BUG>
return forBoolean()
.add(propertyPrefix + ".threadpool." + key.name() + "." + instanceProperty, builderOverrideValue)
.add(propertyPrefix + ".threadpool.default." + instanceProperty, defaultValue)
<BUG>.build()
.get();</BUG>
}
public HystrixProperty<Integer> coreSize() {
return corePoolSize;
| return forInteger()
.build();
private static HystrixProperty<Boolean> getProperty(String propertyPrefix, HystrixThreadPoolKey key, String instanceProperty, Boolean builderOverrideValue, Boolean defaultValue) {
.build();
|
40,141 | return maxQueueSize;
}
public HystrixProperty<Integer> queueSizeRejectionThreshold() {
return queueSizeRejectionThreshold;
}
<BUG>public boolean getAllowMaximumSizeToDivergeFromCoreSize() {
</BUG>
return allowMaximumSizeToDivergeFromCoreSize;
}
public HystrixProperty<Integer> metricsRollingStatisticalWindowInMilliseconds() {
| public HystrixProperty<Boolean> getAllowMaximumSizeToDivergeFromCoreSize() {
|
40,142 | private Integer coreSize = null;
private Integer maximumSize = null;
private Integer keepAliveTimeMinutes = null;
private Integer maxQueueSize = null;
private Integer queueSizeRejectionThreshold = null;
<BUG>private boolean allowMaximumSizeToDivergeFromCoreSize = false;
</BUG>
private Integer rollingStatisticalWindowInMilliseconds = null;
private Integer rollingStatisticalWindowBuckets = null;
private Setter() {
| private Boolean allowMaximumSizeToDivergeFromCoreSize = null;
|
40,143 | return maxQueueSize;
}
public Integer getQueueSizeRejectionThreshold() {
return queueSizeRejectionThreshold;
}
<BUG>public boolean getAllowMaximumSizeToDivergeFromCoreSize() {
</BUG>
return allowMaximumSizeToDivergeFromCoreSize;
}
public Integer getMetricsRollingStatisticalWindowInMilliseconds() {
| public Boolean getAllowMaximumSizeToDivergeFromCoreSize() {
|
40,144 | threadPoolProperties.coreSize().get(),
threadPoolProperties.maximumSize().get(),
threadPoolProperties.maxQueueSize().get(),
threadPoolProperties.queueSizeRejectionThreshold().get(),
threadPoolProperties.keepAliveTimeMinutes().get(),
<BUG>threadPoolProperties.getAllowMaximumSizeToDivergeFromCoreSize(),
</BUG>
threadPoolProperties.metricsRollingStatisticalWindowBuckets().get(),
threadPoolProperties.metricsRollingStatisticalWindowInMilliseconds().get());
}
| threadPoolProperties.getAllowMaximumSizeToDivergeFromCoreSize().get(),
|
40,145 | public void testChildModel() {
Object firstValue = RandomStringUtils.randomAlphabetic(10);
ValueMap firstMap = new ValueMapDecorator(Collections.singletonMap("property", firstValue));
final Resource firstChild = mock(Resource.class);
when(firstChild.adaptTo(ValueMap.class)).thenReturn(firstMap);
<BUG>when(firstChild.adaptTo(ChildModel.class)).thenAnswer(new AdaptToChildMap());
</BUG>
Object firstGrandChildValue = RandomStringUtils.randomAlphabetic(10);
ValueMap firstGrandChildMap = new ValueMapDecorator(Collections.singletonMap("property", firstGrandChildValue));
Object secondGrandChildValue = RandomStringUtils.randomAlphabetic(10);
| when(firstChild.adaptTo(ChildModel.class)).thenAnswer(new AdaptToChildModel());
|
40,146 | ChildModel childModel = model.getFirstChild();
assertNotNull(childModel);
assertEquals(firstValue, childModel.getProperty());
assertEquals(2, model.getGrandChildren().size());
assertEquals(firstGrandChildValue, model.getGrandChildren().get(0).getProperty());
<BUG>assertEquals(secondGrandChildValue, model.getGrandChildren().get(1).getProperty());
}
private class AdaptToChildMap implements Answer<ChildModel> {
</BUG>
@Override
| assertEquals(0, model.getEmptyGrandChildren().size());
private class AdaptToChildModel implements Answer<ChildModel> {
|
40,147 | package org.apache.sling.models.impl;
import static org.junit.Assert.*;
<BUG>import static org.mockito.Mockito.*;
import java.util.Collections;</BUG>
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
| import java.util.Arrays;
import java.util.Collections;
|
40,148 | .getTagNameAndWffId(parentTag);
final byte[] parentWffIdBytes = tagNameAndWffId[1];
nameValue.setName(parentWffIdBytes);
final byte[] parentTagName = tagNameAndWffId[0];
nameValue.setValues(parentTagName,
<BUG>innerHtmlTag.toHtmlString("UTF-8").getBytes("UTF-8"));
final byte[] wffBMBytes = WffBinaryMessageUtil.VERSION_1</BUG>
.getWffBinaryMessageBytes(task, nameValue);
wsListener.push(wffBMBytes);
} else {
| innerHtmlTag.toWffBMBytes("UTF-8"));
final byte[] wffBMBytes = WffBinaryMessageUtil.VERSION_1
|
40,149 | .getTagNameAndWffId(parentTag);
final byte[] parentWffIdBytes = tagNameAndWffId[1];
nameValue.setName(parentWffIdBytes);
final byte[] parentTagName = tagNameAndWffId[0];
nameValue.setValues(parentTagName,
<BUG>appendedChildTag.toHtmlString("UTF-8").getBytes("UTF-8"));
final byte[] wffBMBytes = WffBinaryMessageUtil.VERSION_1</BUG>
.getWffBinaryMessageBytes(task, nameValue);
wsListener.push(wffBMBytes);
} catch (final UnsupportedEncodingException e) {
| appendedChildTag.toWffBMBytes("UTF-8"));
final byte[] wffBMBytes = WffBinaryMessageUtil.VERSION_1
|
40,150 | refcount * 16 + rootcount * 3 + blobrefcount * 2 + length,
16);
checkState(length <= buffer.length);
int pos = refcount * 16;
if (pos + length <= buffer.length) {
<BUG>System.arraycopy(buffer, 0, buffer, buffer.length-length, pos);
</BUG>
pos += buffer.length - length;
} else {
length = buffer.length;
| System.arraycopy(buffer, 0, buffer, buffer.length - length, pos);
|
40,151 | for (RecordId blobref : blobrefs) {
int offset = blobref.getOffset();
buffer[pos++] = (byte) (offset >> (8 + Segment.RECORD_ALIGN_BITS));
buffer[pos++] = (byte) (offset >> Segment.RECORD_ALIGN_BITS);
}
<BUG>SegmentId id = segment.getSegmentId();
log.debug("Writing data segment {} ({} bytes)", id, length);
store.writeSegment(id, buffer, buffer.length - length, length);
ByteBuffer data;</BUG>
if (buffer.length - length > 4096) {
| segmentId = segment.getSegmentId();
segmentBuffer = buffer;
segmentOffset = buffer.length - length;
segmentLength = length;
ByteBuffer data;
|
40,152 | data.put(buffer, buffer.length - length, length);
data.rewind();
} else {
data = ByteBuffer.wrap(buffer, buffer.length - length, length);
}
<BUG>tracker.setSegment(id, new Segment(tracker, id, data));
</BUG>
buffer = createNewBuffer(version);
roots.clear();
blobrefs.clear();
| tracker.setSegment(segmentId, new Segment(tracker, segmentId, data));
|
40,153 | performTestWithMain("bottles", "2", "2");
performTestWithMain("bottles", "");
}
public void testLife() throws Exception {
performTestWithMain("life", "", "2");
<BUG>}
public void testBuilder() throws Exception {
</BUG>
performTestWithMain("builder", "");
performTestWithMain("builder", "1", "over9000");
| @SuppressWarnings("UnusedDeclaration")
public void _testBuilder() throws Exception {
|
40,154 | }
@NotNull
public static BindingContext analyzeFilesAndCheckErrors(@NotNull List<JetFile> files,
@NotNull Config config) {
BindingContext bindingContext = analyzeFiles(files, Predicates.<PsiFile>alwaysTrue(), config).getBindingContext();
<BUG>checkForErrors(withJsLibAdded(files, config), bindingContext);
</BUG>
return bindingContext;
}
@SuppressWarnings("UnusedDeclaration")
| checkForErrors(Config.withJsLibAdded(files, config), bindingContext);
|
40,155 | project, topDownAnalysisParameters, trace, owner,
new JsConfiguration(project, libraryBindingContext));
try {
Collection<JetFile> allFiles = libraryBindingContext != null ?
files :
<BUG>withJsLibAdded(files, config);
</BUG>
injector.getTopDownAnalyzer().analyzeFiles(allFiles, Collections.<AnalyzerScriptParameter>emptyList());
BodiesResolveContext bodiesResolveContext = storeContextForBodiesResolve ?
new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) :
| Config.withJsLibAdded(files, config);
|
40,156 | for (JetFile file : allFiles) {
AnalyzingUtils.checkForSyntacticErrors(file);
}
}
@NotNull
<BUG>public static Collection<JetFile> withJsLibAdded(@NotNull Collection<JetFile> files, @NotNull Config config) {
Collection<JetFile> allFiles = new ArrayList<JetFile>();
allFiles.addAll(files);
allFiles.addAll(config.getLibFiles());
return allFiles;
}
@NotNull</BUG>
private static Predicate<PsiFile> notLibFiles(@NotNull final List<JetFile> jsLibFiles) {
| [DELETED] |
40,157 | private JsConfiguration(@NotNull Project project, @Nullable BindingContext contextToBaseOn) {
this.project = project;
this.contextToBaseOn = contextToBaseOn;
}
@Override
<BUG>public void addDefaultImports(@NotNull Collection<JetImportDirective> directives) {
directives.add(JetPsiFactory.createImportDirective(project, new ImportPath("js.*")));
directives.add(JetPsiFactory.createImportDirective(project, new ImportPath("java.lang.*")));
directives.add(JetPsiFactory.createImportDirective(project, new ImportPath(JetStandardClasses.STANDARD_CLASSES_FQNAME, true)));
directives.add(JetPsiFactory.createImportDirective(project, new ImportPath("kotlin.*")));</BUG>
}
| [DELETED] |
40,158 | DefaultModuleConfiguration.createStandardConfiguration(project, true)
.extendNamespaceScope(trace, namespaceDescriptor, namespaceMemberScope);
if (contextToBaseOn == null) {
return;
}
<BUG>if (!isRootNamespace(namespaceDescriptor)) {
return;
}
NamespaceDescriptor rootNamespaceScope = contextToBaseOn.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.ROOT);
assert rootNamespaceScope != null;
JetScope memberScope = rootNamespaceScope.getMemberScope();
namespaceMemberScope.importScope(memberScope);
}</BUG>
}
| [DELETED] |
40,159 | "/dom/html/window.kt",
"/junit/core.kt",
"/qunit/core.kt"
);
@NotNull
<BUG>public static final List<String> LIB_FILES_WITH_CODE = Arrays.asList(
"/stdlib/JUMaps.kt"
);</BUG>
@NotNull
| public static final List<String> LIB_FILES_WITH_CODE = Lists.newArrayList();
|
40,160 | import com.liferay.portal.kernel.exception.PortalException;
import com.liferay.portal.kernel.exception.SystemException;
import com.liferay.portal.model.Group;
import com.liferay.portal.model.Organization;
import com.liferay.portal.model.OrganizationConstants;
<BUG>import com.liferay.portal.security.auth.PrincipalException;
import com.liferay.portal.security.permission.PermissionChecker;</BUG>
import com.liferay.portal.service.OrganizationLocalServiceUtil;
public class OrganizationPermissionImpl implements OrganizationPermission {
@Override
| import com.liferay.portal.security.permission.ActionKeys;
import com.liferay.portal.security.permission.PermissionChecker;
|
40,161 | PermissionChecker permissionChecker, long groupId,
Organization organization, String actionId)
throws PortalException, SystemException {
while ((organization != null) &&
(organization.getOrganizationId() !=
<BUG>OrganizationConstants.DEFAULT_PARENT_ORGANIZATION_ID)) {
if (permissionChecker.hasPermission(
groupId, Organization.class.getName(),</BUG>
organization.getOrganizationId(), actionId)) {
return true;
| if (actionId.equals(ActionKeys.ADD_ORGANIZATION) &&
groupId, Organization.class.getName(),
organization.getOrganizationId(),
ActionKeys.MANAGE_SUBGROUPS) ||
PortalPermissionUtil.contains(
permissionChecker, ActionKeys.ADD_COMMUNITY)) {
|
40,162 | private LocalBroadcastManager mLocalBroadcastManager;
private String mActiveDownloadUrlString;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
<BUG>setContentView(R.layout.activity_app_details2);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);</BUG>
toolbar.setTitle(""); // Nice and clean toolbar
setSupportActionBar(toolbar);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
| setContentView(R.layout.app_details2);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
|
40,163 | .inflate(R.layout.app_details2_screenshots, parent, false);
return new ScreenShotsViewHolder(view);
} else if (viewType == VIEWTYPE_WHATS_NEW) {
View view = LayoutInflater.from(parent.getContext())
.inflate(R.layout.app_details2_whatsnew, parent, false);
<BUG>return new WhatsNewViewHolder(view);
} else if (viewType == VIEWTYPE_LINKS) {</BUG>
View view = LayoutInflater.from(parent.getContext())
.inflate(R.layout.app_details2_links, parent, false);
return new ExpandableLinearLayoutViewHolder(view);
| } else if (viewType == VIEWTYPE_DONATE) {
.inflate(R.layout.app_details2_donate, parent, false);
return new DonateViewHolder(view);
} else if (viewType == VIEWTYPE_LINKS) {
|
40,164 | import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.DigestOutputStream;
import java.security.MessageDigest;
<BUG>import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;</BUG>
public final class PatchUtils {
| import java.text.DateFormat;
import java.util.Date;
import java.util.List;
|
40,165 | package org.jboss.as.patching.runner;
<BUG>import org.jboss.as.boot.DirectoryStructure;
import org.jboss.as.patching.LocalPatchInfo;</BUG>
import org.jboss.as.patching.PatchInfo;
import org.jboss.as.patching.PatchLogger;
import org.jboss.as.patching.PatchMessages;
| import static org.jboss.as.patching.runner.PatchUtils.generateTimestamp;
import org.jboss.as.patching.CommonAttributes;
import org.jboss.as.patching.LocalPatchInfo;
|
40,166 | private static final String PATH_DELIMITER = "/";
public static final byte[] NO_CONTENT = PatchingTask.NO_CONTENT;
enum Element {
ADDED_BUNDLE("added-bundle"),
ADDED_MISC_CONTENT("added-misc-content"),
<BUG>ADDED_MODULE("added-module"),
BUNDLES("bundles"),</BUG>
CUMULATIVE("cumulative"),
DESCRIPTION("description"),
MISC_FILES("misc-files"),
| APPLIES_TO_VERSION("applies-to-version"),
BUNDLES("bundles"),
|
40,167 | final int count = reader.getAttributeCount();
for (int i = 0; i < count; i++) {
final String value = reader.getAttributeValue(i);
final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
switch (attribute) {
<BUG>case APPLIES_TO_VERSION:
builder.addAppliesTo(value);
break;</BUG>
case RESULTING_VERSION:
if(type == Patch.PatchType.CUMULATIVE) {
| [DELETED] |
40,168 | final StringBuilder path = new StringBuilder();
for(final String p : item.getPath()) {
path.append(p).append(PATH_DELIMITER);
}
path.append(item.getName());
<BUG>writer.writeAttribute(Attribute.PATH.name, path.toString());
if(type != ModificationType.REMOVE) {</BUG>
writer.writeAttribute(Attribute.HASH.name, bytesToHexString(item.getContentHash()));
}
if(type != ModificationType.ADD) {
| if (item.isDirectory()) {
writer.writeAttribute(Attribute.DIRECTORY.name, "true");
if(type != ModificationType.REMOVE) {
|
40,169 | package org.jboss.as.patching;
import org.jboss.as.controller.OperationFailedException;
import org.jboss.as.patching.runner.PatchingException;
import org.jboss.logging.Messages;
import org.jboss.logging.annotations.Message;
<BUG>import org.jboss.logging.annotations.MessageBundle;
import java.io.IOException;</BUG>
import java.util.List;
@MessageBundle(projectCode = "JBAS")
public interface PatchMessages {
| import org.jboss.logging.annotations.Cause;
import java.io.IOException;
|
40,170 | } else {
updateMemo();
callback.updateMemo();
}
dismiss();
<BUG>}else{
</BUG>
Toast.makeText(getActivity(), getString(R.string.toast_memo_empty), Toast.LENGTH_SHORT).show();
}
}
| [DELETED] |
40,171 | }
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_memo);
<BUG>ChinaPhoneHelper.setStatusBar(this,true);
</BUG>
topicId = getIntent().getLongExtra("topicId", -1);
if (topicId == -1) {
finish();
| ChinaPhoneHelper.setStatusBar(this, true);
|
40,172 | MemoEntry.COLUMN_REF_TOPIC__ID + " = ?"
, new String[]{String.valueOf(topicId)});
}
public Cursor selectMemo(long topicId) {
Cursor c = db.query(MemoEntry.TABLE_NAME, null, MemoEntry.COLUMN_REF_TOPIC__ID + " = ?", new String[]{String.valueOf(topicId)}, null, null,
<BUG>MemoEntry._ID + " DESC", null);
</BUG>
if (c != null) {
c.moveToFirst();
}
| MemoEntry.COLUMN_ORDER + " ASC", null);
|
40,173 | MemoEntry._ID + " = ?",
new String[]{String.valueOf(memoId)});
}
public long updateMemoContent(long memoId, String memoContent) {
ContentValues values = new ContentValues();
<BUG>values.put(MemoEntry.COLUMN_CONTENT, memoContent);
return db.update(</BUG>
MemoEntry.TABLE_NAME,
values,
MemoEntry._ID + " = ?",
| return db.update(
|
40,174 | import android.widget.RelativeLayout;
import android.widget.TextView;
import com.kiminonawa.mydiary.R;
import com.kiminonawa.mydiary.db.DBManager;
import com.kiminonawa.mydiary.shared.EditMode;
<BUG>import com.kiminonawa.mydiary.shared.ThemeManager;
import java.util.List;
public class MemoAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> implements EditMode {
</BUG>
private List<MemoEntity> memoList;
| import com.marshalchen.ultimaterecyclerview.dragsortadapter.DragSortAdapter;
public class MemoAdapter extends DragSortAdapter<DragSortAdapter.ViewHolder> implements EditMode {
|
40,175 | private DBManager dbManager;
private boolean isEditMode = false;
private EditMemoDialogFragment.MemoCallback callback;
private static final int TYPE_HEADER = 0;
private static final int TYPE_ITEM = 1;
<BUG>public MemoAdapter(FragmentActivity activity, long topicId, List<MemoEntity> memoList, DBManager dbManager, EditMemoDialogFragment.MemoCallback callback) {
this.mActivity = activity;</BUG>
this.topicId = topicId;
this.memoList = memoList;
| public MemoAdapter(FragmentActivity activity, long topicId, List<MemoEntity> memoList, DBManager dbManager, EditMemoDialogFragment.MemoCallback callback, RecyclerView recyclerView) {
super(recyclerView);
this.mActivity = activity;
|
40,176 | this.memoList = memoList;
this.dbManager = dbManager;
this.callback = callback;
}
@Override
<BUG>public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
</BUG>
View view;
if (isEditMode) {
if (viewType == TYPE_HEADER) {
| public DragSortAdapter.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
|
40,177 | editMemoDialogFragment.show(mActivity.getSupportFragmentManager(), "editMemoDialogFragment");
}
});
}
}
<BUG>protected class MemoViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener {
private View rootView;
private TextView TV_memo_item_content;</BUG>
private ImageView IV_memo_item_delete;
| protected class MemoViewHolder extends DragSortAdapter.ViewHolder implements View.OnClickListener, View.OnLongClickListener {
private ImageView IV_memo_item_dot;
private TextView TV_memo_item_content;
|
40,178 | log.info("Trying to schedule 24h reminder in the past ("+new Date(reminderTime)+"), no reminder will be sent for eval ("+eval.getTitle()+") ["+eval.getId()+"]");
reminderTime = 0;
} else {
log.info("Scheduling a reminder ("+new Date(reminderTime)+") for 24h before the end ("+new Date(dueTime)+") of the evaluation ("+eval.getTitle()+") ["+eval.getId()+"]");
}
<BUG>}
}</BUG>
return reminderTime;
}
protected void sendAvailableEmail(Long evalId) {
| } else if (reminderDays == -2) {
reminderTime = System.currentTimeMillis() + (1000l * 60l * 5l); // reminders every 5 minutes
log.warn("REMINDERS TESTING ONLY (-2): Scheduling a reminder in the near future ("+new Date(reminderTime)+") for testing: due date ("+new Date(dueTime)+") of the evaluation ("+eval.getTitle()+") ["+eval.getId()+"]");
|
40,179 | } else {
String[] stateList = statusStr.trim().split(" ");
logger.info("GroupMembershipSync.execute() syncing " + statusStr);
for(String state : stateList) {
List<EvalEvaluation> evals = evaluationService.getEvaluationsByState(state);
<BUG>int count = 0;
if(evals != null) {
count = evals.size();
}</BUG>
if(logger.isInfoEnabled()) {
| int count = evals.size();
|
40,180 | import java.text.DateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
<BUG>import java.util.Locale;
import org.sakaiproject.evaluation.constant.EvalConstants;</BUG>
import org.sakaiproject.evaluation.logic.EvalAuthoringService;
import org.sakaiproject.evaluation.logic.EvalCommonLogic;
import org.sakaiproject.evaluation.logic.EvalEvaluationService;
| import org.azeckoski.reflectutils.ArrayUtils;
import org.sakaiproject.evaluation.constant.EvalConstants;
|
40,181 | import org.eclipse.xtext.xbase.typesystem.legacy.StandardTypeReferenceOwner;
import org.eclipse.xtext.xbase.typesystem.references.ITypeReferenceOwner;
import org.eclipse.xtext.xbase.typesystem.references.LightweightTypeReference;
import org.eclipse.xtext.xbase.typesystem.references.ParameterizedTypeReference;
import org.eclipse.xtext.xbase.typesystem.util.CommonTypeComputationServices;
<BUG>import org.eclipse.xtext.xbase.ui.contentassist.ReplacingAppendable;
import org.eclipse.xtext.xbase.ui.quickfix.ILinkingIssueQuickfixProvider;</BUG>
import com.google.inject.Inject;
@NonNullByDefault
public class CreateMemberQuickfixes implements ILinkingIssueQuickfixProvider {
| import org.eclipse.xtext.xbase.ui.document.DocumentSourceAppender.Factory.OptionalParameters;
import org.eclipse.xtext.xbase.ui.quickfix.ILinkingIssueQuickfixProvider;
|
40,182 | XtendMember xtendMember = EcoreUtil2.getContainerOfType(element, XtendMember.class);
if (xtendMember != null) {
int offset = getFirstOffsetOfKeyword(xtendMember, "{");
IXtextDocument xtextDocument = context.getXtextDocument();
if (offset != -1 && xtextDocument != null) {
<BUG>final ReplacingAppendable appendable = appendableFactory.get(xtextDocument,
element, offset, 0, 1, false);
appendable.increaseIndentation().newLine().append("val ").append(variableName).append(" = ")</BUG>
.append(defaultValueLiteral);
| final ReplacingAppendable appendable = appendableFactory.create(xtextDocument,
(XtextResource) element.eResource(), offset, 0, new OptionalParameters() {{
baseIndentationLevel = 1;
}});
appendable.increaseIndentation().newLine().append("val ").append(variableName).append(" = ")
|
40,183 | import org.eclipse.xtext.ui.editor.quickfix.IssueResolutionAcceptor;
import org.eclipse.xtext.util.StopWatch;
import org.eclipse.xtext.validation.Issue;
import org.eclipse.xtext.xbase.XBlockExpression;
import org.eclipse.xtext.xbase.XExpression;
<BUG>import org.eclipse.xtext.xbase.ui.contentassist.ReplacingAppendable;
import org.eclipse.xtext.xbase.ui.quickfix.XbaseQuickfixProvider;</BUG>
import com.google.common.collect.Lists;
import com.google.inject.Inject;
import com.google.inject.Singleton;
| import org.eclipse.xtext.xbase.ui.document.DocumentSourceAppender.Factory.OptionalParameters;
import org.eclipse.xtext.xbase.ui.quickfix.XbaseQuickfixProvider;
|
40,184 | String xtendSignature = "new" + javaSignature.substring(javaSignature.indexOf('('));
acceptor.accept(issue, "Add constructor " + xtendSignature, "Add constructor " + xtendSignature, "fix_indent.gif",
new ISemanticModification() {
public void apply(EObject element, IModificationContext context) throws Exception {
XtendClass clazz = (XtendClass) element;
<BUG>ReplacingAppendable appendable = appendableFactory.get(context.getXtextDocument(), clazz,
insertionOffsets.getNewConstructorInsertOffset(null, clazz), 0, 1, true);
EObject constructor = clazz.eResource().getResourceSet().getEObject(constructorURI, true);</BUG>
if (constructor instanceof JvmConstructor) {
| ReplacingAppendable appendable = appendableFactory.create(context.getXtextDocument(), (XtextResource) clazz.eResource(),
insertionOffsets.getNewConstructorInsertOffset(null, clazz), 0, new OptionalParameters() {{
ensureEmptyLinesAround = true;
baseIndentationLevel = 1;
}});
EObject constructor = clazz.eResource().getResourceSet().getEObject(constructorURI, true);
|
40,185 | acceptor.accept(issue, "Add unimplemented methods", "Add unimplemented methods", "fix_indent.gif",
new ISemanticModification() {
public void apply(EObject element, IModificationContext context) throws Exception {
XtendClass clazz = (XtendClass) element;
IXtextDocument document = context.getXtextDocument();
<BUG>ReplacingAppendable appendable = appendableFactory.get(document, clazz,
insertionOffsets.getNewMethodInsertOffset(null, clazz), 0, 1, true);
boolean isFirst = true;</BUG>
for (String operationUriAsString : issue.getData()) {
| ReplacingAppendable appendable = appendableFactory.create(document, (XtextResource) clazz.eResource(),
insertionOffsets.getNewMethodInsertOffset(null, clazz), 0, new OptionalParameters() {{
ensureEmptyLinesAround = true;
baseIndentationLevel = 1;
}});
boolean isFirst = true;
|
40,186 | ICompositeNode expressionNode = NodeModelUtils.findActualNodeFor(xtendFunction.getExpression());
if (expressionNode == null)
throw new IllegalStateException("expressionNode may not be null");
insertPosition = expressionNode.getOffset();
}
<BUG>ReplacingAppendable appendable = appendableFactory.get(context.getXtextDocument(),
xtendFunction, insertPosition, 0);
if (xtendFunction.getExpression() == null)</BUG>
appendable.append(" ");
| ReplacingAppendable appendable = appendableFactory.create(context.getXtextDocument(),
(XtextResource) xtendFunction.eResource(), insertPosition, 0);
if (xtendFunction.getExpression() == null)
|
40,187 | for (ILeafNode leafNode : clazzNode.getLeafNodes()) {
if (leafNode.getText().equals("class")) {
offset = leafNode.getOffset();
}
}
<BUG>ReplacingAppendable appendable = appendableFactory.get(document, clazz,
</BUG>
offset, 0);
appendable.append("abstract ");
appendable.commitChanges();
| ReplacingAppendable appendable = appendableFactory.create(document, (XtextResource) clazz.eResource(),
|
40,188 | import org.eclipse.xtext.common.types.JvmTypeReference;
import org.eclipse.xtext.common.types.util.FeatureOverridesService;
import org.eclipse.xtext.common.types.util.ITypeArgumentContext;
import org.eclipse.xtext.common.types.util.TypeArgumentContextProvider;
import org.eclipse.xtext.common.types.util.TypeReferences;
<BUG>import org.eclipse.xtext.common.types.util.VisibilityService;
import org.eclipse.xtext.ui.IImageHelper;</BUG>
import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor;
import org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper;
| import org.eclipse.xtext.resource.XtextResource;
import org.eclipse.xtext.ui.IImageHelper;
|
40,189 | import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor;
import org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper;
import org.eclipse.xtext.ui.editor.contentassist.PrefixMatcher;
import org.eclipse.xtext.xbase.ui.contentassist.ImportOrganizingProposal;
<BUG>import org.eclipse.xtext.xbase.ui.contentassist.ReplacingAppendable;
import org.eclipse.xtext.xbase.ui.labeling.XbaseImageAdornments;</BUG>
import org.eclipse.xtext.xbase.validation.UIStrings;
import com.google.common.base.Function;
import com.google.inject.Inject;
| import org.eclipse.xtext.xbase.ui.document.DocumentSourceAppender;
import org.eclipse.xtext.xbase.ui.document.DocumentSourceAppender.Factory.OptionalParameters;
import org.eclipse.xtext.xbase.ui.labeling.XbaseImageAdornments;
|
40,190 | acceptor.accept(completionProposal);
}
}
protected ICompletionProposal createOverrideMethodProposal(XtendClass model, JvmExecutable overridden,
final ContentAssistContext context, IProposalConflictHelper conflictHelper) {
<BUG>ReplacingAppendable appendable = appendableFactory.get(context.getDocument(), model, context.getReplaceRegion()
.getOffset(), context.getReplaceRegion().getLength(), 1, true);
final String simpleName;</BUG>
if (overridden instanceof JvmOperation) {
| ReplacingAppendable appendable = appendableFactory.create(context.getDocument(), (XtextResource) model.eResource(), context.getReplaceRegion()
.getOffset(), context.getReplaceRegion().getLength(), new OptionalParameters() {{
ensureEmptyLinesAround = true;
baseIndentationLevel = 1;
}});
final String simpleName;
|
40,191 | package org.eclipse.xtend.ide.quickfix;
import com.google.common.base.Objects;
import com.google.inject.Inject;
import java.util.List;
import org.eclipse.core.runtime.NullProgressMonitor;
<BUG>import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.util.EcoreUtil;</BUG>
import org.eclipse.jdt.core.IAnnotatable;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IField;
| import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
|
40,192 | import org.eclipse.xtend.ide.codebuilder.ICodeBuilder.Xtend;
import org.eclipse.xtend.ide.codebuilder.JavaConstructorBuilder;
import org.eclipse.xtend.ide.codebuilder.JavaFieldBuilder;
import org.eclipse.xtend.ide.codebuilder.JavaMethodBuilder;
import org.eclipse.xtext.common.types.JvmVisibility;
<BUG>import org.eclipse.xtext.common.types.xtext.ui.JdtHyperlink;
import org.eclipse.xtext.ui.editor.IURIEditorOpener;</BUG>
import org.eclipse.xtext.ui.editor.XtextEditor;
import org.eclipse.xtext.ui.editor.model.IXtextDocument;
import org.eclipse.xtext.ui.editor.model.edit.IModification;
| import org.eclipse.xtext.resource.XtextResource;
import org.eclipse.xtext.ui.editor.IURIEditorOpener;
|
40,193 | import org.eclipse.xtext.xbase.lib.Exceptions;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.ObjectExtensions;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.eclipse.xtext.xbase.ui.contentassist.ReplacingAppendable;
<BUG>import org.eclipse.xtext.xbase.ui.contentassist.ReplacingAppendable.Factory;
@SuppressWarnings("all")</BUG>
public class CodeBuilderQuickfix {
@Inject
private IURIEditorOpener editorOpener;
| import org.eclipse.xtext.xbase.ui.document.DocumentSourceAppender.Factory.OptionalParameters;
@SuppressWarnings("all")
|
40,194 | throw new UnsupportedOperationException("ImportOrganizingProposal does not support custom text appliers");
}
@Override
public void apply(IDocument document) {
try {
<BUG>int shiftOffsetBy = appendable.commitChanges(getReplacementOffset(), getReplacementLength());
setSelectionStart(getSelectionStart() + shiftOffsetBy);</BUG>
setCursorPosition(getCursorPosition() + shiftOffsetBy);
if (isLinkedMode()) {
setUpLinkedMode(document);
| int shiftOffsetBy = appendable.commitChanges();
setSelectionStart(getSelectionStart() + shiftOffsetBy);
|
40,195 | return isDouble;
}
@Override
public IBlockState getStateForPlacement(World worldIn, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer)
{
<BUG>IBlockState state = getStateFromMeta(meta);
</BUG>
return isDouble() ? state : (facing != EnumFacing.DOWN && (facing == EnumFacing.UP || (double) hitY <= 0.5D) ? state.withProperty(HALF, BlockSlab.EnumBlockHalf.BOTTOM) : state.withProperty(HALF, BlockSlab.EnumBlockHalf.TOP));
}
private static Material singleClassHack(Material material, boolean isDoubleIn)
| IBlockState state = getDefaultState();
|
40,196 | setHardness(0.2F);
}
@Override
public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer)
{
<BUG>return getStateFromMeta(meta).withProperty(AXIS, EnumType.fromAxis(facing.getAxis()));
}</BUG>
@Override
public IBlockState getStateFromMeta(int meta)
{
| return super.getStateForPlacement(world, pos, facing, hitX, hitY, hitZ, meta, placer).withProperty(AXIS, EnumType.fromAxis(facing.getAxis()));
|
40,197 | import nex.handler.ConfigHandler;
import java.util.Arrays;
import java.util.Random;
public class BlockThornstalk extends BlockNetherEx
{
<BUG>private static final PropertyEnum<EnumPart> PART = PropertyEnum.create("part", EnumPart.class);
</BUG>
public BlockThornstalk()
{
super("plant_thornstalk", Material.PLANTS);
| public static final PropertyEnum<EnumPart> PART = PropertyEnum.create("part", EnumPart.class);
|
40,198 | registerModel(WALL_BASALT, type.ordinal(), String.format(WALL_BASALT.getRegistryName().toString() + "_%s", type.getName()), "inventory");
registerModel(FENCE_BASALT, type.ordinal(), String.format(FENCE_BASALT.getRegistryName().toString() + "_%s", type.getName()), "inventory");
}
for(BlockNetherrack.EnumType type : BlockNetherrack.EnumType.values())
{
<BUG>registerModel(BLOCK_NETHERRACK, type.ordinal(), BLOCK_NETHERRACK.getRegistryName().toString(), String.format("type=%s", type.getName()));
</BUG>
registerModel(ORE_QUARTZ, type.ordinal(), ORE_QUARTZ.getRegistryName().toString(), String.format("type=%s", type.getName()));
registerModel(BLOCK_BRICK_NETHER, type.ordinal(), BLOCK_BRICK_NETHER.getRegistryName().toString(), String.format("type=%s", type.getName()));
registerModel(SLAB_BRICK_NETHER, type.ordinal(), SLAB_BRICK_NETHER.getRegistryName().toString(), String.format("half=bottom,type=%s", type.getName()));
| registerModel(BLOCK_NETHERRACK, type.ordinal(), String.format(BLOCK_NETHERRACK.getRegistryName().toString() + "_%s", type.getName()), "inventory");
|
40,199 | import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.gen.feature.WorldGenerator;
import net.minecraft.world.gen.structure.template.PlacementSettings;
import net.minecraft.world.gen.structure.template.Template;
<BUG>import net.minecraft.world.gen.structure.template.TemplateManager;
import nex.init.NetherExBlocks;</BUG>
import nex.util.WeightedUtil;
import nex.util.WorldGenUtil;
import java.util.List;
| import nex.block.BlockNetherrack;
import nex.block.BlockThornstalk;
import nex.init.NetherExBlocks;
|
40,200 | new WeightedUtil.NamedItem("ruined", 4),
new WeightedUtil.NamedItem("intact", 1)
);
private final Set<IBlockState> allowedBlocks = Sets.newHashSet(
Blocks.SOUL_SAND.getDefaultState(),
<BUG>NetherExBlocks.BLOCK_NETHERRACK.getStateFromMeta(3),
NetherExBlocks.ORE_QUARTZ.getStateFromMeta(3),
NetherExBlocks.PLANT_THORNSTALK.getDefaultState(),
NetherExBlocks.PLANT_THORNSTALK.getStateFromMeta(1),
NetherExBlocks.PLANT_THORNSTALK.getStateFromMeta(2)
);</BUG>
@Override
| NetherExBlocks.BLOCK_NETHERRACK.getDefaultState().withProperty(BlockNetherrack.TYPE, BlockNetherrack.EnumType.GLOOMY),
NetherExBlocks.ORE_QUARTZ.getDefaultState().withProperty(BlockNetherrack.TYPE, BlockNetherrack.EnumType.GLOOMY),
NetherExBlocks.PLANT_THORNSTALK.getDefaultState().withProperty(BlockThornstalk.PART, BlockThornstalk.EnumPart.MIDDLE),
NetherExBlocks.PLANT_THORNSTALK.getDefaultState().withProperty(BlockThornstalk.PART, BlockThornstalk.EnumPart.BOTTOM)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.