id int64 1 49k | buggy stringlengths 34 37.5k | fixed stringlengths 2 37k |
|---|---|---|
3,101 | import org.spongepowered.api.world.Locatable;
import org.spongepowered.api.world.Location;
import org.spongepowered.api.world.World;
import javax.annotation.Nullable;
import java.util.*;
<BUG>import java.util.stream.Collectors;
import static net.foxdenstudio.sponge.foxcore.plugin.util.Aliases.*;</BUG>
public class CommandHere extends FCCommandBase {
private static final String[] PRIORITY_ALIASES = {"priority", "prio", "p"};
private static final FlagMapper MAPPER = map -> key -> value -> {
| import java.util.stream.Stream;
import static net.foxdenstudio.sponge.foxcore.plugin.util.Aliases.*;
|
3,102 | .excludeCurrent(true)
.autoCloseQuotes(true)
.parse();
if (parse.current.type.equals(AdvCmdParser.CurrentElement.ElementType.ARGUMENT)) {
if (parse.current.index == 0)
<BUG>return ImmutableList.of("region", "handler").stream()
.filter(new StartsWithPredicate(parse.current.token))</BUG>
.map(args -> parse.current.prefix + args)
.collect(GuavaCollectors.toImmutableList());
else if (parse.current.index > 0) {
| return Stream.of("region", "handler")
.filter(new StartsWithPredicate(parse.current.token))
|
3,103 | private static FGStorageManager instance;
private final Logger logger = FoxGuardMain.instance().getLogger();</BUG>
private final Set<LoadEntry> loaded = new HashSet<>();
private final Path directory = getDirectory();
private final Map<String, Path> worldDirectories;
<BUG>private FGStorageManager() {
defaultModifiedMap = new CacheMap<>((k, m) -> {</BUG>
if (k instanceof IFGObject) {
m.put((IFGObject) k, true);
return true;
| public final HashMap<IFGObject, Boolean> defaultModifiedMap;
private final UserStorageService userStorageService;
private final Logger logger = FoxGuardMain.instance().getLogger();
userStorageService = FoxGuardMain.instance().getUserStorage();
defaultModifiedMap = new CacheMap<>((k, m) -> {
|
3,104 | String name = fgObject.getName();
Path singleDir = dir.resolve(name.toLowerCase());
</BUG>
boolean shouldSave = fgObject.shouldSave();
if (force || shouldSave) {
<BUG>logger.info((shouldSave ? "S" : "Force s") + "aving handler \"" + name + "\" in directory: " + singleDir);
</BUG>
constructDirectory(singleDir);
try {
fgObject.save(singleDir);
| UUID owner = fgObject.getOwner();
boolean isOwned = !owner.equals(SERVER_UUID);
Optional<User> userOwner = userStorageService.get(owner);
String logName = (userOwner.isPresent() ? userOwner.get().getName() + ":" : "") + (isOwned ? owner + ":" : "") + name;
if (fgObject.autoSave()) {
Path singleDir = serverDir.resolve(name.toLowerCase());
logger.info((shouldSave ? "S" : "Force s") + "aving handler " + logName + " in directory: " + singleDir);
|
3,105 | if (fgObject.autoSave()) {
Path singleDir = dir.resolve(name.toLowerCase());
</BUG>
boolean shouldSave = fgObject.shouldSave();
if (force || shouldSave) {
<BUG>logger.info((shouldSave ? "S" : "Force s") + "aving world region \"" + name + "\" in directory: " + singleDir);
</BUG>
constructDirectory(singleDir);
try {
fgObject.save(singleDir);
| Path singleDir = serverDir.resolve(name.toLowerCase());
logger.info((shouldSave ? "S" : "Force s") + "aving world region " + logName + " in directory: " + singleDir);
|
3,106 | public synchronized void loadRegionLinks() {
logger.info("Loading region links");
try (DB mainDB = DBMaker.fileDB(directory.resolve("regions.foxdb").normalize().toString()).make()) {
Map<String, String> linksMap = mainDB.hashMap("links", Serializer.STRING, Serializer.STRING).createOrOpen();
linksMap.entrySet().forEach(entry -> {
<BUG>IRegion region = FGManager.getInstance().getRegion(entry.getKey());
if (region != null) {
logger.info("Loading links for region \"" + region.getName() + "\"");</BUG>
String handlersString = entry.getValue();
| Optional<IRegion> regionOpt = FGManager.getInstance().getRegion(entry.getKey());
if (regionOpt.isPresent()) {
IRegion region = regionOpt.get();
logger.info("Loading links for region \"" + region.getName() + "\"");
|
3,107 | public synchronized void loadWorldRegionLinks(World world) {
logger.info("Loading world region links for world \"" + world.getName() + "\"");
try (DB mainDB = DBMaker.fileDB(worldDirectories.get(world.getName()).resolve("wregions.foxdb").normalize().toString()).make()) {
Map<String, String> linksMap = mainDB.hashMap("links", Serializer.STRING, Serializer.STRING).createOrOpen();
linksMap.entrySet().forEach(entry -> {
<BUG>IRegion region = FGManager.getInstance().getWorldRegion(world, entry.getKey());
if (region != null) {
logger.info("Loading links for world region \"" + region.getName() + "\"");</BUG>
String handlersString = entry.getValue();
| Optional<IWorldRegion> regionOpt = FGManager.getInstance().getWorldRegion(world, entry.getKey());
if (regionOpt.isPresent()) {
IWorldRegion region = regionOpt.get();
logger.info("Loading links for world region \"" + region.getName() + "\"");
|
3,108 | StringBuilder builder = new StringBuilder();
for (Iterator<IHandler> it = handlers.iterator(); it.hasNext(); ) {
builder.append(it.next().getName());
if (it.hasNext()) builder.append(",");
}
<BUG>return builder.toString();
}</BUG>
private final class LoadEntry {
public final String name;
public final Type type;
| public enum Type {
REGION, WREGION, HANDLER
|
3,109 | .autoCloseQuotes(true)
.leaveFinalAsIs(true)
.parse();
if (parse.current.type.equals(AdvCmdParser.CurrentElement.ElementType.ARGUMENT)) {
if (parse.current.index == 0)
<BUG>return ImmutableList.of("region", "worldregion", "handler", "controller").stream()
</BUG>
.filter(new StartsWithPredicate(parse.current.token))
.collect(GuavaCollectors.toImmutableList());
else if (parse.current.index == 1) {
| return Stream.of("region", "worldregion", "handler", "controller")
|
3,110 | package com.projecttango.examples.java.augmentedreality;
import com.google.atap.tangoservice.Tango;
import com.google.atap.tangoservice.Tango.OnTangoUpdateListener;
import com.google.atap.tangoservice.TangoCameraIntrinsics;
import com.google.atap.tangoservice.TangoConfig;
<BUG>import com.google.atap.tangoservice.TangoCoordinateFramePair;
import com.google.atap.tangoservice.TangoEvent;</BUG>
import com.google.atap.tangoservice.TangoOutOfDateException;
import com.google.atap.tangoservice.TangoPoseData;
import com.google.atap.tangoservice.TangoXyzIjData;
| import com.google.atap.tangoservice.TangoErrorException;
import com.google.atap.tangoservice.TangoEvent;
|
3,111 | super.onResume();
if (!mIsConnected) {
mTango = new Tango(AugmentedRealityActivity.this, new Runnable() {
@Override
public void run() {
<BUG>try {
connectTango();</BUG>
setupRenderer();
mIsConnected = true;
} catch (TangoOutOfDateException e) {
| TangoSupport.initialize();
connectTango();
|
3,112 | if (lastFramePose.statusCode == TangoPoseData.POSE_VALID) {
mRenderer.updateRenderCameraPose(lastFramePose, mExtrinsics);
mCameraPoseTimestamp = lastFramePose.timestamp;</BUG>
} else {
<BUG>Log.w(TAG, "Can't get device pose at time: " + mRgbTimestampGlThread);
}</BUG>
}
}
}
@Override
| mRenderer.updateRenderCameraPose(lastFramePose);
mCameraPoseTimestamp = lastFramePose.timestamp;
Log.w(TAG, "Can't get device pose at time: " +
|
3,113 | import org.rajawali3d.materials.Material;
import org.rajawali3d.materials.methods.DiffuseMethod;
import org.rajawali3d.materials.textures.ATexture;
import org.rajawali3d.materials.textures.StreamingTexture;
import org.rajawali3d.materials.textures.Texture;
<BUG>import org.rajawali3d.math.Matrix4;
import org.rajawali3d.math.vector.Vector3;</BUG>
import org.rajawali3d.primitives.ScreenQuad;
import org.rajawali3d.primitives.Sphere;
import org.rajawali3d.renderer.RajawaliRenderer;
| import org.rajawali3d.math.Quaternion;
import org.rajawali3d.math.vector.Vector3;
|
3,114 | translationMoon.setRepeatMode(Animation.RepeatMode.INFINITE);
translationMoon.setTransformable3D(moon);
getCurrentScene().registerAnimation(translationMoon);
translationMoon.play();
}
<BUG>public void updateRenderCameraPose(TangoPoseData devicePose, DeviceExtrinsics extrinsics) {
Pose cameraPose = ScenePoseCalculator.toOpenGlCameraPose(devicePose, extrinsics);
getCurrentCamera().setRotation(cameraPose.getOrientation());
getCurrentCamera().setPosition(cameraPose.getPosition());
}</BUG>
public int getTextureId() {
| public void updateRenderCameraPose(TangoPoseData cameraPose) {
float[] rotation = cameraPose.getRotationAsFloats();
float[] translation = cameraPose.getTranslationAsFloats();
Quaternion quaternion = new Quaternion(rotation[3], rotation[0], rotation[1], rotation[2]);
getCurrentCamera().setRotation(quaternion.conjugate());
getCurrentCamera().setPosition(translation[0], translation[1], translation[2]);
|
3,115 | package com.projecttango.examples.java.helloareadescription;
import com.google.atap.tangoservice.Tango;
<BUG>import com.google.atap.tangoservice.Tango.OnTangoUpdateListener;
import com.google.atap.tangoservice.TangoConfig;</BUG>
import com.google.atap.tangoservice.TangoCoordinateFramePair;
import com.google.atap.tangoservice.TangoErrorException;
import com.google.atap.tangoservice.TangoEvent;
| import com.google.atap.tangoservice.TangoAreaDescriptionMetaData;
import com.google.atap.tangoservice.TangoConfig;
|
3,116 | 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;
|
3,117 | 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;
|
3,118 | 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"),
|
3,119 | 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] |
3,120 | 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) {
|
3,121 | 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;
|
3,122 | import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
<BUG>import android.support.v4.app.NavUtils;
import android.support.v7.app.AppCompatActivity;</BUG>
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.ContextMenu;
| import android.support.v4.view.MenuItemCompat;
import android.support.v7.app.AppCompatActivity;
|
3,123 | import android.database.ContentObserver;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
<BUG>import android.support.v4.app.NavUtils;
import android.support.v7.app.AppCompatActivity;</BUG>
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.ContextMenu;
| import android.support.v4.view.MenuItemCompat;
import android.support.v7.app.AppCompatActivity;
|
3,124 | import android.os.Handler;
import android.os.Looper;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.preference.PreferenceManager;
<BUG>import android.support.design.widget.FloatingActionButton;
import android.support.v7.widget.Toolbar;</BUG>
import android.util.Log;
import android.view.ContextMenu;
import android.view.KeyEvent;
| import android.support.v4.view.MenuItemCompat;
import android.support.v7.widget.Toolbar;
|
3,125 | mAltitude.setOnCheckedChangeListener(mCheckedChangeListener);
mDistance.setOnCheckedChangeListener(mCheckedChangeListener);
mCompass.setOnCheckedChangeListener(mCheckedChangeListener);
mLocation.setOnCheckedChangeListener(mCheckedChangeListener);
builder.setTitle(R.string.dialog_layer_title).setIcon(android.R.drawable.ic_dialog_map).setPositiveButton
<BUG>(R.string.btn_okay, null).setView(view);
</BUG>
dialog = builder.create();
return dialog;
case DIALOG_NOTRACK:
| (android.R.string.ok, null).setView(view);
|
3,126 | }
@RootTask
static Task<Exec.Result> exec(String parameter, int number) {
Task<String> task1 = MyTask.create(parameter);
Task<Integer> task2 = Adder.create(number, number + 2);
<BUG>return Task.ofType(Exec.Result.class).named("exec", "/bin/sh")
.in(() -> task1)</BUG>
.in(() -> task2)
.process(Exec.exec((str, i) -> args("/bin/sh", "-c", "\"echo " + i + "\"")));
}
| return Task.named("exec", "/bin/sh").ofType(Exec.Result.class)
.in(() -> task1)
|
3,127 | return args;
}
static class MyTask {
static final int PLUS = 10;
static Task<String> create(String parameter) {
<BUG>return Task.ofType(String.class).named("MyTask", parameter)
.in(() -> Adder.create(parameter.length(), PLUS))</BUG>
.in(() -> Fib.create(parameter.length()))
.process((sum, fib) -> something(parameter, sum, fib));
}
| return Task.named("MyTask", parameter).ofType(String.class)
.in(() -> Adder.create(parameter.length(), PLUS))
|
3,128 | final String instanceField = "from instance";
final TaskContext context = TaskContext.inmem();
final AwaitingConsumer<String> val = new AwaitingConsumer<>();
@Test
public void shouldJavaUtilSerialize() throws Exception {
<BUG>Task<Long> task1 = Task.ofType(Long.class).named("Foo", "Bar", 39)
.process(() -> 9999L);
Task<String> task2 = Task.ofType(String.class).named("Baz", 40)
.in(() -> task1)</BUG>
.ins(() -> singletonList(task1))
| Task<Long> task1 = Task.named("Foo", "Bar", 39).ofType(Long.class)
Task<String> task2 = Task.named("Baz", 40).ofType(String.class)
.in(() -> task1)
|
3,129 | assertEquals(des.id().name(), "Baz");
assertEquals(val.awaitAndGet(), "[9999] hello 10004");
}
@Test(expected = NotSerializableException.class)
public void shouldNotSerializeWithInstanceFieldReference() throws Exception {
<BUG>Task<String> task = Task.ofType(String.class).named("WithRef")
.process(() -> instanceField + " causes an outer reference");</BUG>
serialize(task);
}
@Test
| Task<String> task = Task.named("WithRef").ofType(String.class)
.process(() -> instanceField + " causes an outer reference");
|
3,130 | serialize(task);
}
@Test
public void shouldSerializeWithLocalReference() throws Exception {
String local = instanceField;
<BUG>Task<String> task = Task.ofType(String.class).named("WithLocalRef")
.process(() -> local + " won't cause an outer reference");</BUG>
serialize(task);
Task<String> des = deserialize();
context.evaluate(des).consume(val);
| Task<String> task = Task.named("WithLocalRef").ofType(String.class)
.process(() -> local + " won't cause an outer reference");
|
3,131 | }
@RootTask
public static Task<String> standardArgs(int first, String second) {
firstInt = first;
secondString = second;
<BUG>return Task.ofType(String.class).named("StandardArgs", first, second)
.process(() -> second + " " + first * 100);</BUG>
}
@Test
public void shouldParseFlags() throws Exception {
| return Task.named("StandardArgs", first, second).ofType(String.class)
.process(() -> second + " " + first * 100);
|
3,132 | assertThat(parsedEnum, is(CustomEnum.BAR));
}
@RootTask
public static Task<String> enums(CustomEnum enm) {
parsedEnum = enm;
<BUG>return Task.ofType(String.class).named("Enums", enm)
.process(enm::toString);</BUG>
}
@Test
public void shouldParseCustomTypes() throws Exception {
| return Task.named("Enums", enm).ofType(String.class)
.process(enm::toString);
|
3,133 | assertThat(parsedType.content, is("blarg parsed for you!"));
}
@RootTask
public static Task<String> customType(CustomType myType) {
parsedType = myType;
<BUG>return Task.ofType(String.class).named("Types", myType.content)
.process(() -> myType.content);</BUG>
}
public enum CustomEnum {
BAR
| return Task.named("Types", myType.content).ofType(String.class)
.process(() -> myType.content);
|
3,134 | TaskContext taskContext = TaskContext.inmem();
TaskContext.Value<Long> value = taskContext.evaluate(fib92);
value.consume(f92 -> System.out.println("fib(92) = " + f92));
}
static Task<Long> create(long n) {
<BUG>TaskBuilder<Long> fib = Task.ofType(Long.class).named("Fib", n);
</BUG>
if (n < 2) {
return fib
.process(() -> n);
| TaskBuilder<Long> fib = Task.named("Fib", n).ofType(Long.class);
|
3,135 | && targetClass != null
&& !targetClass.isInterface()
;
}
@NotNull
<BUG>private static Collection<SmartPsiElementPointer<PsiParameter>> getUnboundedParams(PsiParameter parameter) {
final PsiElement psiElement = parameter.getDeclarationScope();
if (!(psiElement instanceof PsiMethod)) return Collections.emptyList();
final PsiMethod psiMethod = (PsiMethod)psiElement;</BUG>
Map<SmartPsiElementPointer<PsiParameter>, Boolean> params = psiMethod.getUserData(PARAMS);
| private static Collection<SmartPsiElementPointer<PsiParameter>> getUnboundedParams(PsiMethod psiMethod) {
|
3,136 | members[i++] = classMember;
if (parameter == myParameter) {
selection = classMember;
}
}
<BUG>final PsiParameterList parameterList = ((PsiMethod)myParameter.getDeclarationScope()).getParameterList();
</BUG>
Arrays.sort(members, new Comparator<ClassMember>() {
@Override
public int compare(ClassMember o1, ClassMember o2) {
| final PsiParameterList parameterList = method.getParameterList();
|
3,137 | <BUG>package com.google.cloud.pubsub.spi;
import com.google.api.gax.grpc.ApiException;</BUG>
import com.google.api.gax.grpc.ChannelProvider;
import com.google.api.gax.grpc.ExecutorProvider;
import com.google.api.gax.grpc.FixedChannelProvider;
| import com.google.api.gax.core.ForwardingRpcFuture;
import com.google.api.gax.core.Function;
import com.google.api.gax.core.RpcFuture;
import com.google.api.gax.core.RpcFutureCallback;
import com.google.api.gax.grpc.ApiException;
|
3,138 | noTimeoutSubscriberClient = SubscriberClient.create(subBuilder.build());
} catch (Exception ex) {
throw new IOException(ex);
}
}
<BUG>private static <V> ListenableFuture<V> translate(ListenableFuture<V> from,
final boolean idempotent, int... returnNullOn) {
</BUG>
final Set<Integer> returnNullOnSet = Sets.newHashSetWithExpectedSize(returnNullOn.length);
for (int value : returnNullOn) {
| private static <V> RpcFuture<V> translate(
RpcFuture<V> from, final boolean idempotent, int... returnNullOn) {
|
3,139 | <BUG>package com.google.cloud.logging.spi;
import com.google.api.gax.grpc.ApiException;</BUG>
import com.google.api.gax.grpc.ChannelProvider;
import com.google.api.gax.grpc.ExecutorProvider;
import com.google.api.gax.grpc.FixedChannelProvider;
| import com.google.api.gax.core.Function;
import com.google.api.gax.core.RpcFuture;
import com.google.api.gax.grpc.ApiException;
|
3,140 | import com.google.cloud.logging.spi.v2.ConfigServiceV2Settings;
import com.google.cloud.logging.spi.v2.LoggingServiceV2Client;
import com.google.cloud.logging.spi.v2.LoggingServiceV2Settings;
import com.google.cloud.logging.spi.v2.MetricsServiceV2Client;
import com.google.cloud.logging.spi.v2.MetricsServiceV2Settings;
<BUG>import com.google.common.base.Function;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;</BUG>
import com.google.logging.v2.CreateLogMetricRequest;
| [DELETED] |
3,141 | import com.google.protobuf.Empty;
import io.grpc.ManagedChannel;
import io.grpc.Status.Code;
import io.grpc.netty.NegotiationType;
import io.grpc.netty.NettyChannelBuilder;
<BUG>import java.io.IOException;
import java.util.Set;</BUG>
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
public class DefaultLoggingRpc implements LoggingRpc {
| import java.util.Collections;
import java.util.EnumSet;
import java.util.Set;
|
3,142 | public Future<LogSink> update(UpdateSinkRequest request) {
return translate(configClient.updateSinkCallable().futureCall(request), true);
}
@Override
public Future<LogSink> get(GetSinkRequest request) {
<BUG>return translate(configClient.getSinkCallable().futureCall(request), true, Code.NOT_FOUND.value());
}</BUG>
@Override
public Future<ListSinksResponse> list(ListSinksRequest request) {
return translate(configClient.listSinksCallable().futureCall(request), true);
| return translate(configClient.getSinkCallable().futureCall(request), true, Code.NOT_FOUND);
|
3,143 | public Future<ListSinksResponse> list(ListSinksRequest request) {
return translate(configClient.listSinksCallable().futureCall(request), true);
}
@Override
public Future<Empty> delete(DeleteSinkRequest request) {
<BUG>return translate(configClient.deleteSinkCallable().futureCall(request), true,
Code.NOT_FOUND.value());</BUG>
}
@Override
| return translate(configClient.deleteSinkCallable().futureCall(request), true, Code.NOT_FOUND);
|
3,144 |
Code.NOT_FOUND.value());</BUG>
}
@Override
public Future<Empty> delete(DeleteLogRequest request) {
<BUG>return translate(loggingClient.deleteLogCallable().futureCall(request), true,
Code.NOT_FOUND.value());</BUG>
}
@Override
| public Future<ListSinksResponse> list(ListSinksRequest request) {
return translate(configClient.listSinksCallable().futureCall(request), true);
public Future<Empty> delete(DeleteSinkRequest request) {
return translate(configClient.deleteSinkCallable().futureCall(request), true, Code.NOT_FOUND);
return translate(loggingClient.deleteLogCallable().futureCall(request), true, Code.NOT_FOUND);
|
3,145 | @Override
public Future<LogMetric> update(UpdateLogMetricRequest request) {
return translate(metricsClient.updateLogMetricCallable().futureCall(request), true);
}
@Override
<BUG>public Future<LogMetric> get(GetLogMetricRequest request) {
return translate(metricsClient.getLogMetricCallable().futureCall(request), true,
Code.NOT_FOUND.value());</BUG>
}
| public Future<LogSink> update(UpdateSinkRequest request) {
return translate(configClient.updateSinkCallable().futureCall(request), true);
|
3,146 | myState = null;
myLookupData = null;
myLookupItem = null;
myContext = null;
}
<BUG>public boolean handleInsertInner(final CompletionContext context,
int startOffset, LookupData data, LookupItem item,</BUG>
final boolean signatureSelected, final char completionChar) {
LOG.assertTrue(CommandProcessor.getInstance().getCurrentCommand() != null);
PsiDocumentManager.getInstance(context.project).commitDocument(context.editor.getDocument());
| public boolean handleInsertInner(CompletionContext context,
int startOffset, LookupData data, LookupItem item,
|
3,147 | myState.caretOffset = processTail(tailType, myState.caretOffset, myState.tailOffset);
myEditor.getCaretModel().moveToOffset(myState.caretOffset);
myEditor.getScrollingModel().scrollToCaret(ScrollType.RELATIVE);
myEditor.getSelectionModel().removeSelection();
try{
<BUG>addImportForItem(myFile, myStartOffset, myLookupItem);
</BUG>
}
catch(IncorrectOperationException e){
LOG.error(e);
| myStartOffset = addImportForItem(myFile, myStartOffset, myLookupItem);
|
3,148 | PsiDocumentManager.getInstance(file.getProject()).commitAllDocuments();
Object o = item.getObject();
if (o instanceof PsiClass){
PsiClass aClass = (PsiClass)o;
int length = aClass.getName().length();
<BUG>addImportForClass(file, startOffset, startOffset + length, aClass);
</BUG>
}
else if (o instanceof PsiType){
PsiType type = ((PsiType)o).getDeepComponentType();
| return addImportForClass(file, startOffset, startOffset + length, aClass);
|
3,149 | PsiType type = ((PsiType)o).getDeepComponentType();
if (type instanceof PsiClassType) {
PsiClass refClass = ((PsiClassType) type).resolve();
if (refClass != null){
int length = refClass.getName().length();
<BUG>addImportForClass(file, startOffset, startOffset + length, refClass);
</BUG>
}
}
}
| return addImportForClass(file, startOffset, startOffset + length, refClass);
|
3,150 | import org.springframework.util.Assert;
public final class TcpEventReceiver implements EventReceiver, TcpEventReceiverMBean {
public static final int UNLIMITED_EVENTS = -1;
private Thread m_worker;
private TcpServer m_server;
<BUG>private List<EventHandler> m_handlers;
</BUG>
private volatile int m_status;
private int m_tcpPort;
private String m_logPrefix;
| private List<EventHandler> m_eventHandlers;
|
3,151 | private int m_recsPerConn;
public TcpEventReceiver() {
this(TcpServer.TCP_PORT);
}
public TcpEventReceiver(int port) {
<BUG>m_handlers = new ArrayList<EventHandler>(3);
</BUG>
m_status = START_PENDING;
m_tcpPort = port;
m_server = null;
| m_eventHandlers = new ArrayList<EventHandler>(3);
|
3,152 | package org.opennms.netmgt.eventd;
import org.opennms.netmgt.daemon.AbstractServiceDaemon;
import org.opennms.netmgt.eventd.adaptors.EventReceiver;
<BUG>import org.opennms.netmgt.xml.event.Event;
import org.opennms.netmgt.xml.event.EventReceipt;
import org.springframework.util.Assert;
public final class Eventd extends AbstractServiceDaemon implements org.opennms.netmgt.eventd.adaptors.EventHandler {
private EventIpcManager m_eventIpcManager;</BUG>
public static final String LOG4J_CATEGORY = "OpenNMS.Eventd";
| import java.util.Collection;
public final class Eventd extends AbstractServiceDaemon {
|
3,153 | import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.gatk.io.StingSAMFileWriter;
import org.broadinstitute.sting.utils.exceptions.ReviewedStingException;
import java.io.File;
import java.io.OutputStream;
<BUG>import java.lang.annotation.Annotation;
import java.util.Arrays;</BUG>
import java.util.List;
public class SAMFileWriterArgumentTypeDescriptor extends ArgumentTypeDescriptor {
public static final String DEFAULT_ARGUMENT_FULLNAME = "outputBAM";
| import java.lang.reflect.Type;
import java.util.Arrays;
|
3,154 | SAMFileWriterStub stub = new SAMFileWriterStub(engine,defaultOutputStream);
engine.addOutput(stub);
return stub;
}
@Override
<BUG>public Object parse( ParsingEngine parsingEngine, ArgumentSource source, Class type, ArgumentMatches matches ) {
</BUG>
ArgumentDefinition bamArgumentDefinition = createBAMArgumentDefinition(source);
String writerFileName = getArgumentValue( bamArgumentDefinition, matches );
String compressionLevelText = getArgumentValue( createBAMCompressionArgumentDefinition(source), matches );
| public Object parse( ParsingEngine parsingEngine, ArgumentSource source, Type type, ArgumentMatches matches ) {
|
3,155 | public Object createTypeDefault(ParsingEngine parsingEngine,ArgumentSource source,Class<?> type) { throw new UnsupportedOperationException("Unable to create default for type " + getClass()); }
public List<ArgumentDefinition> createArgumentDefinitions( ArgumentSource source ) {
return Collections.singletonList(createDefaultArgumentDefinition(source));
}
public Object parse(ParsingEngine parsingEngine, ArgumentSource source, ArgumentMatches matches) {
<BUG>return parse(parsingEngine, source, source.field.getType(), matches);
</BUG>
}
public boolean isMultiValued( ArgumentSource source ) {
Class argumentType = source.field.getType();
| return parse(parsingEngine, source, source.field.getGenericType(), matches);
|
3,156 | ArgumentDefinition.getDoc(argumentAnnotation),
source.isRequired() && !createsTypeDefault(source) && !source.isFlag() && !source.isDeprecated(),
source.isFlag(),
source.isMultiValued(),
source.isHidden(),
<BUG>getCollectionComponentType(source.field),
</BUG>
ArgumentDefinition.getExclusiveOf(argumentAnnotation),
ArgumentDefinition.getValidationRegex(argumentAnnotation),
getValidOptions(source) );
| makeRawTypeIfNecessary(getCollectionComponentType(source.field)),
|
3,157 | catch( Exception ex ) {
return false;
}
}
@Override
<BUG>public Object parse(ParsingEngine parsingEngine, ArgumentSource source, Class type, ArgumentMatches matches) {
if (source.isFlag())</BUG>
return true;
ArgumentDefinition defaultDefinition = createDefaultArgumentDefinition(source);
| public Object parse(ParsingEngine parsingEngine, ArgumentSource source, Type fulltype, ArgumentMatches matches) {
Class type = makeRawTypeIfNecessary(fulltype);
if (source.isFlag())
|
3,158 | public boolean supports( Class type ) {
return ( Collection.class.isAssignableFrom(type) || type.isArray() );
}
@Override
@SuppressWarnings("unchecked")
<BUG>public Object parse(ParsingEngine parsingEngine,ArgumentSource source, Class type, ArgumentMatches matches) {
Class componentType;
</BUG>
Object result;
| public Object parse(ParsingEngine parsingEngine,ArgumentSource source, Type fulltype, ArgumentMatches matches) {
Class type = makeRawTypeIfNecessary(fulltype);
Type componentType;
|
3,159 | if( java.util.List.class.isAssignableFrom(type) ) type = ArrayList.class;
else if( java.util.Queue.class.isAssignableFrom(type) ) type = java.util.ArrayDeque.class;
else if( java.util.Set.class.isAssignableFrom(type) ) type = java.util.TreeSet.class;
}
componentType = getCollectionComponentType( source.field );
<BUG>ArgumentTypeDescriptor componentArgumentParser = parsingEngine.selectBestTypeDescriptor(componentType);
</BUG>
Collection collection;
try {
collection = (Collection)type.newInstance();
| ArgumentTypeDescriptor componentArgumentParser = parsingEngine.selectBestTypeDescriptor(makeRawTypeIfNecessary(componentType));
|
3,160 | else
throw new ReviewedStingException("Unsupported compound argument type: " + type);
return result;
}
@Override
<BUG>protected Class getCollectionComponentType( Field field ) {
</BUG>
if( field.getGenericType() instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType)field.getGenericType();
if( parameterizedType.getActualTypeArguments().length > 1 )
| protected Type getCollectionComponentType( Field field ) {
|
3,161 | </BUG>
if( field.getGenericType() instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType)field.getGenericType();
if( parameterizedType.getActualTypeArguments().length > 1 )
throw new IllegalArgumentException("Unable to determine collection type of field: " + field.toString());
<BUG>return (Class)parameterizedType.getActualTypeArguments()[0];
}</BUG>
else
return String.class;
}
| throw new ReviewedStingException("Unsupported compound argument type: " + type);
return result;
@Override
protected Type getCollectionComponentType( Field field ) {
return parameterizedType.getActualTypeArguments()[0];
|
3,162 | </BUG>
if(multiplexedIds == null)
throw new ReviewedStingException("Cannot directly parse a MultiplexArgumentTypeDescriptor; must create a derivative type descriptor first.");
Map<Object,Object> multiplexedMapping = new HashMap<Object,Object>();
<BUG>Class componentType = getCollectionComponentType(source.field);
</BUG>
for(Object id: multiplexedIds) {
Object value = parsingEngine.selectBestTypeDescriptor(componentType).parse(parsingEngine,source,componentType,matches.transform(multiplexer,id));
multiplexedMapping.put(id,value);
}
| return multiplexedMapping;
@Override
public Object parse(ParsingEngine parsingEngine, ArgumentSource source, Type type, ArgumentMatches matches) {
Class componentType = makeRawTypeIfNecessary(getCollectionComponentType(source.field));
|
3,163 | throw new ReviewedStingException(String.format("Can't invoke constructor of class %s with parameters %s",multiplexerType.getName(),Arrays.deepToString(sourceFields)),ex);
}
return new MultiplexArgumentTypeDescriptor(multiplexer,multiplexer.multiplex());
}
@Override
<BUG>protected Class getCollectionComponentType( Field field ) {
</BUG>
if( field.getGenericType() instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType)field.getGenericType();
if( parameterizedType.getActualTypeArguments().length != 2 )
| protected Type getCollectionComponentType( Field field ) {
|
3,164 | import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.utils.exceptions.DynamicClassResolutionException;
import org.broadinstitute.sting.utils.exceptions.ReviewedStingException;
import java.io.File;
import java.io.OutputStream;
<BUG>import java.lang.reflect.Constructor;
public class OutputStreamArgumentTypeDescriptor extends ArgumentTypeDescriptor {</BUG>
private final GenomeAnalysisEngine engine;
private final OutputStream defaultOutputStream;
public OutputStreamArgumentTypeDescriptor(GenomeAnalysisEngine engine,OutputStream defaultOutputStream) {
| import java.lang.reflect.Type;
public class OutputStreamArgumentTypeDescriptor extends ArgumentTypeDescriptor {
|
3,165 | OutputStreamStub stub = new OutputStreamStub(defaultOutputStream);
engine.addOutput(stub);
return createInstanceOfClass(type,stub);
}
@Override
<BUG>public Object parse( ParsingEngine parsingEngine, ArgumentSource source, Class type, ArgumentMatches matches ) {
</BUG>
ArgumentDefinition definition = createDefaultArgumentDefinition(source);
String fileName = getArgumentValue( definition, matches );
if(fileName == null && !source.isRequired())
| public Object parse( ParsingEngine parsingEngine, ArgumentSource source, Type type, ArgumentMatches matches ) {
|
3,166 | String fileName = getArgumentValue( definition, matches );
if(fileName == null && !source.isRequired())
throw new MissingArgumentValueException(definition);
OutputStreamStub stub = new OutputStreamStub(new File(fileName));
engine.addOutput(stub);
<BUG>Object result = createInstanceOfClass(type,stub);
</BUG>
parsingEngine.addTags(result,getArgumentTags(matches));
return result;
}
| Object result = createInstanceOfClass(makeRawTypeIfNecessary(type),stub);
|
3,167 | @Argument(fullName="keepMultiAllelic", shortName="KMA", doc="If provided, we will not require the site to be biallelic", required=false)
public boolean keepMultiAllelic = false;
@Argument(fullName="allowMissingData", shortName="AMD", doc="If provided, we will not require every record to contain every field", required=false)
public boolean ALLOW_MISSING_DATA = false;
@Input(fullName="variants", shortName="V", doc="The variant file we will convert to a table", required=true)
<BUG>public RodBinding<VariantContext> variants;
public void initialize() {</BUG>
out.println(Utils.join("\t", fieldsToTake));
}
public static abstract class Getter { public abstract String get(VariantContext vc); }
| @Input(fullName="rodList", shortName="RL", doc="A list of ROD types that we will convert to a table", required=true)
public List<RodBinding<Feature>> variantsList;
public void initialize() {
|
3,168 | return String.format("%.2f", 10 * vc.getGenotype(0).getNegLog10PError());
}});
}
public Integer map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
if ( tracker == null ) // RodWalkers can make funky map calls
<BUG>return 0;
if ( ++nRecords < MAX_RECORDS || MAX_RECORDS == -1 ) {</BUG>
VariantContext vc = variants.getFirstValue(tracker, context.getLocation());
if ( (keepMultiAllelic || vc.isBiallelic()) && ( showFiltered || vc.isNotFiltered() ) ) {
List<String> vals = extractFields(vc, fieldsToTake, ALLOW_MISSING_DATA);
| for ( RodBinding binding : variantsList )
System.out.printf("VariantList binding %s tags=%s%n", binding, binding.getTags().getPositionalTags());
if ( ++nRecords < MAX_RECORDS || MAX_RECORDS == -1 ) {
|
3,169 | import org.broadinstitute.sting.commandline.ArgumentTypeDescriptor;
import org.broadinstitute.sting.commandline.ParsingEngine;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.utils.exceptions.UserException;
import org.broadinstitute.sting.utils.sam.SAMFileReaderBuilder;
<BUG>import java.io.File;
public class SAMFileReaderArgumentTypeDescriptor extends ArgumentTypeDescriptor {</BUG>
private GenomeAnalysisEngine engine;
public SAMFileReaderArgumentTypeDescriptor( GenomeAnalysisEngine engine ) {
this.engine = engine;
| import java.lang.reflect.Type;
public class SAMFileReaderArgumentTypeDescriptor extends ArgumentTypeDescriptor {
|
3,170 | @Override
public boolean supports( Class type ) {
return SAMFileReader.class.isAssignableFrom(type);
}
@Override
<BUG>public Object parse( ParsingEngine parsingEngine, ArgumentSource source, Class type, ArgumentMatches matches ) {
</BUG>
SAMFileReaderBuilder builder = new SAMFileReaderBuilder();
String readerFileName = getArgumentValue( createDefaultArgumentDefinition(source), matches );
if( readerFileName == null )
| public Object parse( ParsingEngine parsingEngine, ArgumentSource source, Type type, ArgumentMatches matches ) {
|
3,171 | import org.broadinstitute.sting.commandline.*;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.utils.codecs.vcf.VCFWriter;
import org.broadinstitute.sting.utils.exceptions.ReviewedStingException;
import java.io.File;
<BUG>import java.io.OutputStream;
import java.util.Arrays;</BUG>
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
| import java.lang.reflect.Type;
import java.util.Arrays;
|
3,172 | VCFWriterStub stub = new VCFWriterStub(engine, defaultOutputStream, false, argumentSources, false, false);
engine.addOutput(stub);
return stub;
}
@Override
<BUG>public Object parse( ParsingEngine parsingEngine, ArgumentSource source, Class type, ArgumentMatches matches ) {
</BUG>
ArgumentDefinition defaultArgumentDefinition = createDefaultArgumentDefinition(source);
String writerFileName = getArgumentValue(defaultArgumentDefinition,matches);
File writerFile = writerFileName != null ? new File(writerFileName) : null;
| public Object parse( ParsingEngine parsingEngine, ArgumentSource source, Type type, ArgumentMatches matches ) {
|
3,173 | import com.intellij.codeHighlighting.RainbowHighlighter;
import com.intellij.codeInsight.daemon.impl.HighlightInfo;
import com.intellij.codeInsight.daemon.impl.HighlightVisitor;
import com.intellij.codeInsight.daemon.impl.analysis.HighlightInfoHolder;
import com.intellij.openapi.editor.colors.TextAttributesKey;
<BUG>import com.intellij.openapi.util.NotNullLazyKey;
import com.intellij.openapi.util.text.StringHash;</BUG>
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
| import com.intellij.openapi.util.UserDataHolderEx;
|
3,174 | package org.voltdb.regressionsuites;
<BUG>import java.io.IOException;
import org.voltdb.BackendTarget;</BUG>
import org.voltdb.VoltTable;
import org.voltdb.VoltType;
import org.voltdb.client.Client;
| import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.voltdb.BackendTarget;
|
3,175 | new MultiConfigSuiteBuilder(TestGeographyValueQueries.class);
boolean success;
VoltProjectBuilder project = new VoltProjectBuilder();
String literalSchema =
"CREATE TABLE T (\n"
<BUG>+ " PK INTEGER NOT NULL PRIMARY KEY,\n"
+ " NAME VARCHAR(32),\n"
+ " POLY GEOGRAPHY\n"
+ ");\n"</BUG>
+ "CREATE TABLE PT (\n"
| [DELETED] |
3,176 | for (int i = 0; i < ql; i++) {
DbAttribute a = qualifierAttributes.get(i);
if (updateBatch.isNull(a)) {
continue;
}
<BUG>Object value = row.getValue(ul + i);
bindings[ul + i].include(j++, value);
</BUG>
}
return bindings;
| bindings[ul + i] = new DbAttributeBinding(qualifierAttributes.get(i));
|
3,177 | <BUG>package org.apache.cayenne.access.translator.procedure;
import org.apache.cayenne.access.translator.ProcedureParameterBinding;</BUG>
import org.apache.cayenne.access.types.ExtendedType;
import org.apache.cayenne.dba.DbAdapter;
import org.apache.cayenne.log.JdbcEventLogger;
| import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.cayenne.access.translator.ProcedureParameterBinding;
|
3,178 | import org.apache.cayenne.log.NoopJdbcEventLogger;
import org.apache.cayenne.map.EntityResolver;
import org.apache.cayenne.map.Procedure;
import org.apache.cayenne.map.ProcedureParameter;
import org.apache.cayenne.query.ProcedureQuery;
<BUG>import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;</BUG>
public class ProcedureTranslator {
| [DELETED] |
3,179 | for (int i = 0, j = 1; i < len; i++) {
DbAttributeBinding b = bindings[i];
if (deleteBatch.isNull(b.getAttribute())) {
b.exclude();
} else {
<BUG>b.include(j++, row.getValue(i));
}</BUG>
}
return bindings;
}
| Object value = row.getValue(i);
ExtendedType extendedType = value != null
? adapter.getExtendedTypes().getRegisteredType(value.getClass())
: adapter.getExtendedTypes().getDefaultType();
b.include(j++, value, extendedType);
|
3,180 | int slen = superBindings.length;
DbAttributeBinding[] bindings = new DbAttributeBinding[slen + 1];
DbAttribute deleteAttribute = query.getDbEntity().getAttribute(deletedFieldName);
String typeName = TypesMapping.getJavaBySqlType(deleteAttribute.getType());
ExtendedType extendedType = adapter.getExtendedTypes().getRegisteredType(typeName);
<BUG>bindings[0] = new DbAttributeBinding(deleteAttribute, extendedType);
bindings[0].include(1, true);
</BUG>
System.arraycopy(superBindings, 0, bindings, 1, slen);
return bindings;
| bindings[0] = new DbAttributeBinding(deleteAttribute);
bindings[0].include(1, true, extendedType);
|
3,181 | for (int i = 1, j = 2; i < len; i++) {
DbAttributeBinding b = bindings[i];
if (deleteBatch.isNull(b.getAttribute())) {
b.exclude();
} else {
<BUG>b.include(j++, row.getValue(i - 1));
}</BUG>
}
return bindings;
}
| Object value = row.getValue(i - 1);
ExtendedType extendedType = value != null
? adapter.getExtendedTypes().getRegisteredType(value.getClass())
: adapter.getExtendedTypes().getDefaultType();
b.include(j++, value, extendedType);
|
3,182 | private Object value;
private int statementPosition;
private ExtendedType extendedType;
private Integer type;
private int scale;
<BUG>public ParameterBinding(ExtendedType extendedType) {
this.statementPosition = EXCLUDED_POSITION;
this.extendedType = extendedType;</BUG>
}
public Object getValue() {
| public ParameterBinding() {
|
3,183 | ResultSet resultSet, OperationObserver callback, final long startTime) throws Exception {
boolean iteratedResult = callback.isIteratedResult();
ExtendedTypeMap types = dataNode.getAdapter().getExtendedTypes();
RowDescriptorBuilder builder = configureRowDescriptorBuilder(compiled, resultSet);
RowReader<?> rowReader = dataNode.rowReader(builder.getDescriptor(types), queryMetadata);
<BUG>JDBCResultIterator result = new JDBCResultIterator(statement, resultSet, rowReader);
ResultIterator it = result;</BUG>
if (iteratedResult) {
it = new ConnectionAwareResultIterator(it, connection) {
| ResultIterator it = new JDBCResultIterator(statement, resultSet, rowReader);
|
3,184 | List<DbAttribute> attributes = query.getDbAttributes();
int len = attributes.size();
DbAttributeBinding[] bindings = new DbAttributeBinding[len];
for (int i = 0; i < len; i++) {
DbAttribute a = attributes.get(i);
<BUG>String typeName = TypesMapping.getJavaBySqlType(a.getType());
ExtendedType extendedType = adapter.getExtendedTypes().getRegisteredType(typeName);
bindings[i] = new DbAttributeBinding(a, extendedType);
if (includeInBatch(a)) {
bindings[i].include(1, null);
</BUG>
} else {
| bindings[i] = new DbAttributeBinding(a);
bindings[i].include(1, null, null);
|
3,185 | protected DbAttributeBinding[] doUpdateBindings(BatchQueryRow row) {
int len = bindings.length;
for (int i = 0, j = 1; i < len; i++) {
DbAttributeBinding b = bindings[i];
if (!b.isExcluded()) {
<BUG>b.include(j++, row.getValue(i));
}</BUG>
}
return bindings;
}
| Object value = row.getValue(i);
ExtendedType extendedType = value != null
? adapter.getExtendedTypes().getRegisteredType(value.getClass())
: adapter.getExtendedTypes().getDefaultType();
b.include(j++, value, extendedType);
|
3,186 | } else {
updateMemo();
callback.updateMemo();
}
dismiss();
<BUG>}else{
</BUG>
Toast.makeText(getActivity(), getString(R.string.toast_memo_empty), Toast.LENGTH_SHORT).show();
}
}
| [DELETED] |
3,187 | }
@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);
|
3,188 | 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);
|
3,189 | 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(
|
3,190 | 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 {
|
3,191 | 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;
|
3,192 | 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) {
|
3,193 | 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;
|
3,194 | package org.openstreetmap.josm.command;
import org.junit.BeforeClass;
import org.junit.Test;
import org.openstreetmap.josm.JOSMFixture;
<BUG>import org.openstreetmap.josm.data.osm.DataSet;
import org.openstreetmap.josm.gui.layer.OsmDataLayer;</BUG>
import nl.jqno.equalsverifier.EqualsVerifier;
import nl.jqno.equalsverifier.Warning;
public class ChangePropertyCommandTest {
| import org.openstreetmap.josm.data.osm.User;
import org.openstreetmap.josm.gui.layer.OsmDataLayer;
|
3,195 | public static void setUpBeforeClass() {
JOSMFixture.createUnitTestFixture().init(false);
}
@Test
public void equalsContract() {
<BUG>EqualsVerifier.forClass(ChangePropertyCommand.class).usingGetClass()
.withPrefabValues(OsmDataLayer.class,</BUG>
new OsmDataLayer(new DataSet(), "1", null), new OsmDataLayer(new DataSet(), "2", null))
.suppress(Warning.NONFINAL_FIELDS)
.verify();
| .withPrefabValues(DataSet.class,
new DataSet(), new DataSet())
.withPrefabValues(User.class,
User.createOsmUser(1, "foo"), User.createOsmUser(2, "bar"))
.withPrefabValues(OsmDataLayer.class,
|
3,196 | import org.junit.Test;
import org.openstreetmap.josm.JOSMFixture;
import org.openstreetmap.josm.Main;
import org.openstreetmap.josm.data.conflict.Conflict;
import org.openstreetmap.josm.data.osm.DataSet;
<BUG>import org.openstreetmap.josm.data.osm.Node;
import org.openstreetmap.josm.data.osm.Way;</BUG>
import org.openstreetmap.josm.gui.layer.OsmDataLayer;
import nl.jqno.equalsverifier.EqualsVerifier;
import nl.jqno.equalsverifier.Warning;
| import org.openstreetmap.josm.data.osm.User;
import org.openstreetmap.josm.data.osm.Way;
|
3,197 | package org.openstreetmap.josm.command;
import org.junit.BeforeClass;
import org.junit.Test;
import org.openstreetmap.josm.JOSMFixture;
import org.openstreetmap.josm.data.osm.DataSet;
<BUG>import org.openstreetmap.josm.data.osm.Relation;
import org.openstreetmap.josm.gui.layer.OsmDataLayer;</BUG>
import nl.jqno.equalsverifier.EqualsVerifier;
import nl.jqno.equalsverifier.Warning;
public class ChangeRelationMemberRoleCommandTest {
| import org.openstreetmap.josm.data.osm.User;
import org.openstreetmap.josm.gui.layer.OsmDataLayer;
|
3,198 | }
@Test
public void equalsContract() {
EqualsVerifier.forClass(ChangeRelationMemberRoleCommand.class).usingGetClass()
.withPrefabValues(Relation.class,
<BUG>new Relation(1), new Relation(2))
.withPrefabValues(OsmDataLayer.class,</BUG>
new OsmDataLayer(new DataSet(), "1", null), new OsmDataLayer(new DataSet(), "2", null))
.suppress(Warning.NONFINAL_FIELDS)
.verify();
| .withPrefabValues(DataSet.class,
new DataSet(), new DataSet())
.withPrefabValues(User.class,
User.createOsmUser(1, "foo"), User.createOsmUser(2, "bar"))
.withPrefabValues(OsmDataLayer.class,
|
3,199 | package org.openstreetmap.josm.command;
import org.junit.BeforeClass;
import org.junit.Test;
<BUG>import org.openstreetmap.josm.JOSMFixture;
import org.openstreetmap.josm.data.osm.DataSet;
import org.openstreetmap.josm.gui.layer.OsmDataLayer;</BUG>
import nl.jqno.equalsverifier.EqualsVerifier;
import nl.jqno.equalsverifier.Warning;
| import org.openstreetmap.josm.data.coor.LatLon;
import org.openstreetmap.josm.data.osm.User;
import org.openstreetmap.josm.gui.layer.OsmDataLayer;
|
3,200 | package org.openstreetmap.josm.command;
import org.junit.BeforeClass;
import org.junit.Test;
<BUG>import org.openstreetmap.josm.JOSMFixture;
import org.openstreetmap.josm.data.osm.DataSet;
import org.openstreetmap.josm.gui.layer.OsmDataLayer;</BUG>
import nl.jqno.equalsverifier.EqualsVerifier;
import nl.jqno.equalsverifier.Warning;
| import org.openstreetmap.josm.data.coor.LatLon;
import org.openstreetmap.josm.data.osm.User;
import org.openstreetmap.josm.gui.layer.OsmDataLayer;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.