id
int64 1
49k
| buggy
stringlengths 34
37.5k
| fixed
stringlengths 2
37k
|
|---|---|---|
701 | this.upnpService = upnpService;
}
public UpnpService getUpnpService() {
return upnpService;
}
<BUG>public ReceivingAsync createReceivingAsync(IncomingDatagramMessage message) throws ProtocolCreationException {
log.fine("Creating protocol for incoming asynchronous: " + message);
if (message.getOperation() instanceof UpnpRequest) {</BUG>
IncomingDatagramMessage<UpnpRequest> incomingRequest = message;
switch (incomingRequest.getOperation().getMethod()) {
| if (log.isLoggable(Level.FINE)) {
if (message.getOperation() instanceof UpnpRequest) {
|
702 | }
public UpnpHeaders(Map<String, List<String>> headers) {
super(headers);
}
public UpnpHeaders(ByteArrayInputStream inputStream) {
<BUG>super(inputStream);
}</BUG>
protected void parseHeaders() {
parsedHeaders = new LinkedHashMap();
if (log.isLoggable(Level.FINE))
| public UpnpHeaders(boolean normalizeHeaders) {
super(normalizeHeaders);
|
703 | List<URL> callbackURLs = new ArrayList();
for (NetworkAddress activeStreamServer : activeStreamServers) {
callbackURLs.add(
new Location(
activeStreamServer,
<BUG>namespace.getEventCallbackPath(getService())
</BUG>
).getURL());
}
return callbackURLs;
| namespace.getEventCallbackPathString(getService())
|
704 | package com.cronutils.model.time.generator;
import java.util.Collections;
<BUG>import java.util.List;
import org.apache.commons.lang3.Validate;</BUG>
import com.cronutils.model.field.CronField;
import com.cronutils.model.field.expression.FieldExpression;
public abstract class FieldValueGenerator {
| import org.apache.commons.lang3.Validate;
import org.apache.commons.lang3.Validate;
|
705 | import java.util.ResourceBundle;
import java.util.function.Function;</BUG>
class DescriptionStrategyFactory {
private DescriptionStrategyFactory() {}
public static DescriptionStrategy daysOfWeekInstance(final ResourceBundle bundle, final FieldExpression expression) {
<BUG>final Function<Integer, String> nominal = integer -> new DateTime().withDayOfWeek(integer).dayOfWeek().getAsText(bundle.getLocale());
</BUG>
NominalDescriptionStrategy dow = new NominalDescriptionStrategy(bundle, nominal, expression);
dow.addDescription(fieldExpression -> {
if (fieldExpression instanceof On) {
| import java.util.function.Function;
import com.cronutils.model.field.expression.FieldExpression;
import com.cronutils.model.field.expression.On;
final Function<Integer, String> nominal = integer -> DayOfWeek.of(integer).getDisplayName(TextStyle.FULL, bundle.getLocale());
|
706 | return dom;
}
public static DescriptionStrategy monthsInstance(final ResourceBundle bundle, final FieldExpression expression) {
return new NominalDescriptionStrategy(
bundle,
<BUG>integer -> new DateTime().withMonthOfYear(integer).monthOfYear().getAsText(bundle.getLocale()),
expression</BUG>
);
}
public static DescriptionStrategy plainInstance(ResourceBundle bundle, final FieldExpression expression) {
| integer -> Month.of(integer).getDisplayName(TextStyle.FULL, bundle.getLocale()),
expression
|
707 | <BUG>package com.cronutils.model.time.generator;
import com.cronutils.mapper.WeekDay;</BUG>
import com.cronutils.model.field.CronField;
import com.cronutils.model.field.CronFieldName;
import com.cronutils.model.field.constraint.FieldConstraintsBuilder;
| import java.time.LocalDate;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.apache.commons.lang3.Validate;
import com.cronutils.mapper.WeekDay;
|
708 | import com.cronutils.model.field.expression.Between;
import com.cronutils.model.field.expression.FieldExpression;
import com.cronutils.parser.CronParserField;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
<BUG>import org.apache.commons.lang3.Validate;
import org.joda.time.DateTime;
import java.util.Collections;
import java.util.List;
import java.util.Set;</BUG>
class BetweenDayOfWeekValueGenerator extends FieldValueGenerator {
| [DELETED] |
709 | <BUG>package com.cronutils.model.time.generator;
import com.cronutils.model.field.CronField;</BUG>
import com.cronutils.model.field.CronFieldName;
import com.cronutils.model.field.expression.FieldExpression;
import com.cronutils.model.field.expression.On;
| import java.time.DayOfWeek;
import java.time.LocalDate;
import java.util.List;
import org.apache.commons.lang3.Validate;
import com.cronutils.model.field.CronField;
|
710 | import com.cronutils.model.field.CronField;</BUG>
import com.cronutils.model.field.CronFieldName;
import com.cronutils.model.field.expression.FieldExpression;
import com.cronutils.model.field.expression.On;
import com.google.common.collect.Lists;
<BUG>import org.apache.commons.lang3.Validate;
import org.joda.time.DateTime;
import java.util.List;</BUG>
class OnDayOfMonthValueGenerator extends FieldValueGenerator {
private int year;
| package com.cronutils.model.time.generator;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.util.List;
import com.cronutils.model.field.CronField;
|
711 | class OnDayOfMonthValueGenerator extends FieldValueGenerator {
private int year;
private int month;
public OnDayOfMonthValueGenerator(CronField cronField, int year, int month) {
super(cronField);
<BUG>Validate.isTrue(CronFieldName.DAY_OF_MONTH.equals(cronField.getField()), "CronField does not belong to day of month");
this.year = year;</BUG>
this.month = month;
}
| Validate.isTrue(CronFieldName.DAY_OF_MONTH.equals(cronField.getField()), "CronField does not belong to day of" +
" month");
this.year = year;
|
712 | package com.cronutils.mapper;
public class ConstantsMapper {
private ConstantsMapper() {}
public static final WeekDay QUARTZ_WEEK_DAY = new WeekDay(2, false);
<BUG>public static final WeekDay JODATIME_WEEK_DAY = new WeekDay(1, false);
</BUG>
public static final WeekDay CRONTAB_WEEK_DAY = new WeekDay(1, true);
public static int weekDayMapping(WeekDay source, WeekDay target, int weekday){
return source.mapTo(weekday, target);
| public static final WeekDay JAVA8 = new WeekDay(1, false);
|
713 | return nextMatch;
} catch (NoSuchValueException e) {
throw new IllegalArgumentException(e);
}
}
<BUG>DateTime nextClosestMatch(DateTime date) throws NoSuchValueException {
</BUG>
List<Integer> year = yearsValueGenerator.generateCandidates(date.getYear(), date.getYear());
TimeNode days = null;
int lowestMonth = months.getValues().get(0);
| ZonedDateTime nextClosestMatch(ZonedDateTime date) throws NoSuchValueException {
|
714 | boolean questionMarkSupported =
cronDefinition.getFieldDefinition(DAY_OF_WEEK).getConstraints().getSpecialChars().contains(QUESTION_MARK);
if(questionMarkSupported){
return new TimeNode(
generateDayCandidatesQuestionMarkSupported(
<BUG>date.getYear(), date.getMonthOfYear(),
</BUG>
((DayOfWeekFieldDefinition)
cronDefinition.getFieldDefinition(DAY_OF_WEEK)
).getMondayDoWValue()
| date.getYear(), date.getMonthValue(),
|
715 | )
);
}else{
return new TimeNode(
generateDayCandidatesQuestionMarkNotSupported(
<BUG>date.getYear(), date.getMonthOfYear(),
</BUG>
((DayOfWeekFieldDefinition)
cronDefinition.getFieldDefinition(DAY_OF_WEEK)
).getMondayDoWValue()
| date.getYear(), date.getMonthValue(),
|
716 | }
public DateTime lastExecution(DateTime date){
</BUG>
Validate.notNull(date);
try {
<BUG>DateTime previousMatch = previousClosestMatch(date);
</BUG>
if(previousMatch.equals(date)){
previousMatch = previousClosestMatch(date.minusSeconds(1));
}
| public java.time.Duration timeToNextExecution(ZonedDateTime date){
return java.time.Duration.between(date, nextExecution(date));
public ZonedDateTime lastExecution(ZonedDateTime date){
ZonedDateTime previousMatch = previousClosestMatch(date);
|
717 | return previousMatch;
} catch (NoSuchValueException e) {
throw new IllegalArgumentException(e);
}
}
<BUG>public Duration timeFromLastExecution(DateTime date){
return new Interval(lastExecution(date), date).toDuration();
}
public boolean isMatch(DateTime date){
</BUG>
return nextExecution(lastExecution(date)).equals(date);
| [DELETED] |
718 | <BUG>package com.cronutils.model.time.generator;
import com.cronutils.model.field.CronField;</BUG>
import com.cronutils.model.field.expression.Every;
import com.cronutils.model.field.expression.FieldExpression;
import com.google.common.annotations.VisibleForTesting;
| import java.time.ZonedDateTime;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.cronutils.model.field.CronField;
|
719 | import com.cronutils.model.field.CronField;</BUG>
import com.cronutils.model.field.expression.Every;
import com.cronutils.model.field.expression.FieldExpression;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Lists;
<BUG>import org.joda.time.DateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;</BUG>
class EveryFieldValueGenerator extends FieldValueGenerator {
| package com.cronutils.model.time.generator;
import java.time.ZonedDateTime;
import java.util.List;
import com.cronutils.model.field.CronField;
|
720 | private static final Logger log = LoggerFactory.getLogger(EveryFieldValueGenerator.class);
public EveryFieldValueGenerator(CronField cronField) {
super(cronField);
log.trace(String.format(
"processing \"%s\" at %s",
<BUG>cronField.getExpression().asString(), DateTime.now()
</BUG>
));
}
@Override
| cronField.getExpression().asString(), ZonedDateTime.now()
|
721 | import java.util.ResourceBundle;
import java.util.function.Function;</BUG>
class DescriptionStrategyFactory {
private DescriptionStrategyFactory() {}
public static DescriptionStrategy daysOfWeekInstance(final ResourceBundle bundle, final FieldExpression expression) {
<BUG>final Function<Integer, String> nominal = integer -> new DateTime().withDayOfWeek(integer).dayOfWeek().getAsText(bundle.getLocale());
</BUG>
NominalDescriptionStrategy dow = new NominalDescriptionStrategy(bundle, nominal, expression);
dow.addDescription(fieldExpression -> {
if (fieldExpression instanceof On) {
| import java.util.function.Function;
import com.cronutils.model.field.expression.FieldExpression;
import com.cronutils.model.field.expression.On;
final Function<Integer, String> nominal = integer -> DayOfWeek.of(integer).getDisplayName(TextStyle.FULL, bundle.getLocale());
|
722 | return dom;
}
public static DescriptionStrategy monthsInstance(final ResourceBundle bundle, final FieldExpression expression) {
return new NominalDescriptionStrategy(
bundle,
<BUG>integer -> new DateTime().withMonthOfYear(integer).monthOfYear().getAsText(bundle.getLocale()),
expression</BUG>
);
}
public static DescriptionStrategy plainInstance(ResourceBundle bundle, final FieldExpression expression) {
| integer -> Month.of(integer).getDisplayName(TextStyle.FULL, bundle.getLocale()),
expression
|
723 | <BUG>package com.cronutils.model.time.generator;
import com.cronutils.mapper.WeekDay;</BUG>
import com.cronutils.model.field.CronField;
import com.cronutils.model.field.CronFieldName;
import com.cronutils.model.field.constraint.FieldConstraintsBuilder;
| import java.time.LocalDate;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.apache.commons.lang3.Validate;
import com.cronutils.mapper.WeekDay;
|
724 | import com.cronutils.model.field.expression.Between;
import com.cronutils.model.field.expression.FieldExpression;
import com.cronutils.parser.CronParserField;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
<BUG>import org.apache.commons.lang3.Validate;
import org.joda.time.DateTime;
import java.util.Collections;
import java.util.List;
import java.util.Set;</BUG>
class BetweenDayOfWeekValueGenerator extends FieldValueGenerator {
| [DELETED] |
725 | package com.cronutils.mapper;
public class ConstantsMapper {
private ConstantsMapper() {}
public static final WeekDay QUARTZ_WEEK_DAY = new WeekDay(2, false);
<BUG>public static final WeekDay JODATIME_WEEK_DAY = new WeekDay(1, false);
</BUG>
public static final WeekDay CRONTAB_WEEK_DAY = new WeekDay(1, true);
public static int weekDayMapping(WeekDay source, WeekDay target, int weekday){
return source.mapTo(weekday, target);
| public static final WeekDay JAVA8 = new WeekDay(1, false);
|
726 | return nextMatch;
} catch (NoSuchValueException e) {
throw new IllegalArgumentException(e);
}
}
<BUG>DateTime nextClosestMatch(DateTime date) throws NoSuchValueException {
</BUG>
List<Integer> year = yearsValueGenerator.generateCandidates(date.getYear(), date.getYear());
TimeNode days = null;
int lowestMonth = months.getValues().get(0);
| ZonedDateTime nextClosestMatch(ZonedDateTime date) throws NoSuchValueException {
|
727 | boolean questionMarkSupported =
cronDefinition.getFieldDefinition(DAY_OF_WEEK).getConstraints().getSpecialChars().contains(QUESTION_MARK);
if(questionMarkSupported){
return new TimeNode(
generateDayCandidatesQuestionMarkSupported(
<BUG>date.getYear(), date.getMonthOfYear(),
</BUG>
((DayOfWeekFieldDefinition)
cronDefinition.getFieldDefinition(DAY_OF_WEEK)
).getMondayDoWValue()
| date.getYear(), date.getMonthValue(),
|
728 | )
);
}else{
return new TimeNode(
generateDayCandidatesQuestionMarkNotSupported(
<BUG>date.getYear(), date.getMonthOfYear(),
</BUG>
((DayOfWeekFieldDefinition)
cronDefinition.getFieldDefinition(DAY_OF_WEEK)
).getMondayDoWValue()
| date.getYear(), date.getMonthValue(),
|
729 | }
public DateTime lastExecution(DateTime date){
</BUG>
Validate.notNull(date);
try {
<BUG>DateTime previousMatch = previousClosestMatch(date);
</BUG>
if(previousMatch.equals(date)){
previousMatch = previousClosestMatch(date.minusSeconds(1));
}
| public java.time.Duration timeToNextExecution(ZonedDateTime date){
return java.time.Duration.between(date, nextExecution(date));
public ZonedDateTime lastExecution(ZonedDateTime date){
ZonedDateTime previousMatch = previousClosestMatch(date);
|
730 | return previousMatch;
} catch (NoSuchValueException e) {
throw new IllegalArgumentException(e);
}
}
<BUG>public Duration timeFromLastExecution(DateTime date){
return new Interval(lastExecution(date), date).toDuration();
}
public boolean isMatch(DateTime date){
</BUG>
return nextExecution(lastExecution(date)).equals(date);
| [DELETED] |
731 | <BUG>package com.cronutils.model.time.generator;
import com.cronutils.model.field.CronField;</BUG>
import com.cronutils.model.field.expression.Every;
import com.cronutils.model.field.expression.FieldExpression;
import com.google.common.annotations.VisibleForTesting;
| import java.time.ZonedDateTime;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.cronutils.model.field.CronField;
|
732 | import com.cronutils.model.field.CronField;</BUG>
import com.cronutils.model.field.expression.Every;
import com.cronutils.model.field.expression.FieldExpression;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.Lists;
<BUG>import org.joda.time.DateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;</BUG>
class EveryFieldValueGenerator extends FieldValueGenerator {
| package com.cronutils.model.time.generator;
import java.time.ZonedDateTime;
import java.util.List;
import com.cronutils.model.field.CronField;
|
733 | private static final Logger log = LoggerFactory.getLogger(EveryFieldValueGenerator.class);
public EveryFieldValueGenerator(CronField cronField) {
super(cronField);
log.trace(String.format(
"processing \"%s\" at %s",
<BUG>cronField.getExpression().asString(), DateTime.now()
</BUG>
));
}
@Override
| cronField.getExpression().asString(), ZonedDateTime.now()
|
734 | 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);
|
735 | .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) {
|
736 | setCurrentBean(new XWikiDocument(new DocumentReference(wiki, "XWiki", "Page")));
getDocument().setSyntax(Syntax.XWIKI_1_0);
this.skippedElements.add("version");
this.skippedElements.add("minorEdit");
this.skippedElements.add("comment");
<BUG>this.skippedElements.add("creator");
this.skippedElements.add("author");
this.skippedElements.add("contentAuthor");</BUG>
this.skippedElements.add("creationDate");
this.skippedElements.add("date");
| [DELETED] |
737 | import org.drools.verifier.report.components.Cause;
public abstract class Restriction extends PatternComponent
implements
Cause {
public static class RestrictionType {
<BUG>public static final RestrictionType LITERAL = new RestrictionType( "LITERAL" );
public static final RestrictionType VARIABLE = new RestrictionType( "VARIABLE" );
public static final RestrictionType QUALIFIED_IDENTIFIER = new RestrictionType( "QUALIFIED_IDENTIFIER" );
public static final RestrictionType RETURN_VALUE_RESTRICTION = new RestrictionType( "RETURN_VALUE_RESTRICTION" );
public static final RestrictionType ENUM = new RestrictionType( "ENUM" );
protected final String type;
private RestrictionType(String t) {</BUG>
type = t;
| public static final RestrictionType LITERAL = new RestrictionType("LITERAL");
public static final RestrictionType VARIABLE = new RestrictionType("VARIABLE");
public static final RestrictionType QUALIFIED_IDENTIFIER = new RestrictionType("QUALIFIED_IDENTIFIER");
public static final RestrictionType RETURN_VALUE_RESTRICTION = new RestrictionType("RETURN_VALUE_RESTRICTION");
public static final RestrictionType ENUM = new RestrictionType("ENUM");
protected final String type;
private RestrictionType(String t) {
|
738 | public Operator getOperator() {
return operator;
}
public void setOperator(Operator operator) {
this.operator = operator;
<BUG>}
public String getConstraintPath() {
return constraintPath;
}
public void setConstraintPath(String constraintPath) {
this.constraintPath = constraintPath;</BUG>
}
| [DELETED] |
739 | if ( webServerPort == 443 )
{
sb.append( "s" );
}
sb.append( "://" );
<BUG>sb.append( addressResolver.getHostname() );
if ( webServerPort != 80 )</BUG>
{
sb.append( ":" );
sb.append( webServerPort );
| sb.append( getWebServerAddress() );
if ( webServerPort != 80 )
|
740 | import org.neo4j.server.NeoServer;
public interface WebServer
{
void init();
void setNeoServer( NeoServer server );
<BUG>void setPort( int portNo );
void start();</BUG>
void stop();
void setMaxThreads( int maxThreads );
void addJAXRSPackages( List<String> packageNames, String serverMountPoint );
| void setAddress( String addr );
void start();
|
741 | String DEFAULT_CONFIG_DIR = File.separator + "etc" + File.separator + "neo";
String DATABASE_LOCATION_PROPERTY_KEY = "org.neo4j.server.database.location";
String NEO_SERVER_CONFIG_FILE_KEY = "org.neo4j.server.properties";
String DB_MODE_KEY = "org.neo4j.server.database.mode";
int DEFAULT_WEBSERVER_PORT = 7474;
<BUG>String WEBSERVER_PORT_PROPERTY_KEY = "org.neo4j.server.webserver.port";
String WEBSERVER_MAX_THREADS_PROPERTY_KEY = "org.neo4j.server.webserver.maxthreads";</BUG>
String REST_API_PATH_PROPERTY_KEY = "org.neo4j.server.webadmin.data.uri";
String REST_API_PACKAGE = "org.neo4j.server.rest.web";
String DEFAULT_DATA_API_PATH = "/db/data";
| String DEFAULT_WEBSERVER_ADDRESS = "0.0.0.0";
String WEBSERVER_ADDRESS_PROPERTY_KEY = "org.neo4j.server.webserver.address";
String WEBSERVER_MAX_THREADS_PROPERTY_KEY = "org.neo4j.server.webserver.maxthreads";
|
742 | import java.util.TreeSet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.mortbay.jetty.Handler;
<BUG>import org.mortbay.jetty.Server;
import org.mortbay.jetty.SessionManager;</BUG>
import org.mortbay.jetty.handler.MovedContextHandler;
import org.mortbay.jetty.servlet.Context;
import org.mortbay.jetty.servlet.HashSessionManager;
| import org.mortbay.jetty.Connector;
import org.mortbay.jetty.nio.SelectChannelConnector;
import org.mortbay.jetty.SessionManager;
|
743 | import com.sun.jersey.api.core.ResourceConfig;
import com.sun.jersey.spi.container.servlet.ServletContainer;
public class Jetty6WebServer implements WebServer
{
public static final Logger log = Logger.getLogger( Jetty6WebServer.class );
<BUG>public static final int DEFAULT_PORT = 80;
private Server jetty;
private int jettyPort = DEFAULT_PORT;
private final HashMap<String, String> staticContent = new HashMap<String, String>();</BUG>
private final HashMap<String, ServletHolder> jaxRSPackages = new HashMap<String, ServletHolder>();
| public static final String DEFAULT_ADDRESS = "0.0.0.0";
private String jettyAddr = DEFAULT_ADDRESS;
private final HashMap<String, String> staticContent = new HashMap<String, String>();
|
744 | ClassLoader.getSystemClassLoader();
systemClassLoader.loadClass(className);
return true;
}
catch (ClassNotFoundException cnfe) {
<BUG>Class<?> classObj = getClass();
if (classObj.getResource(className) != null) {
</BUG>
return true;
| [DELETED] |
745 | else if (type.equals(String.class.getName())) {
map.put(kvp[0], kvp[1]);
}
else {
try {
<BUG>Class<?> classObj = Class.forName(type);
Constructor<?> constructor = classObj.getConstructor(
</BUG>
new Class<?>[] {String.class});
| Class<?> clazz = Class.forName(type);
Constructor<?> constructor = clazz.getConstructor(
|
746 | return _instance._get(null, null, methodKey);
}
public static Method put(MethodKey methodKey, Method method) {
return _instance._put(methodKey, method);
}
<BUG>public static void remove(Class<?> classObj) {
_instance._remove(classObj);
</BUG>
}
| public static void remove(Class<?> clazz) {
_instance._remove(clazz);
|
747 | Method method = methodsMap.get(methodKey);
if (method == null) {
String className = methodKey.getClassName();
String methodName = methodKey.getMethodName();
Class<?>[] parameterTypes = methodKey.getParameterTypes();
<BUG>Class<?> classObj = classesMap.get(className);
if (classObj == null) {
</BUG>
Thread currentThread = Thread.currentThread();
| Class<?> clazz = classesMap.get(className);
if (clazz == null) {
|
748 | package com.liferay.portal.kernel.search;
import java.util.List;
public class IndexerRegistryUtil {
<BUG>public static Indexer getIndexer(Class<?> classObj) {
return getIndexerRegistry().getIndexer(classObj.getName());
</BUG>
}
| public static Indexer getIndexer(Class<?> clazz) {
return getIndexerRegistry().getIndexer(clazz.getName());
|
749 | package org.eclipse.emf.index.util;
import java.util.Collection;
<BUG>public class CollectionUtils {
public static <T> Collection<T> addIfNotNull(Collection<T> c, T element) {</BUG>
if (element != null)
c.add(element);
return c;
| import java.util.ArrayList;
public static <T> Collection<T> copyOrNull(Collection<T> source) {
if(source == null) return null;
return new ArrayList<T>(source);
}
public static <T> Collection<T> addIfNotNull(Collection<T> c, T element) {
|
750 | import org.eclipse.emf.index.EClassDescriptor;
import org.eclipse.emf.index.EPackageDescriptor;
import org.eclipse.emf.index.IGenericQuery;
import org.eclipse.emf.index.IIndexStore;
import org.eclipse.emf.index.impl.DefaultQueryTool;
<BUG>public class EClassDAOImpl extends BasicCachingMemoryDAO<EClassDescriptor> implements EClassDescriptor.DAO {
</BUG>
protected InverseReferenceCache<EPackageDescriptor, EClassDescriptor> ePackageScope;
public EClassDAOImpl(IIndexStore indexStore) {
super(indexStore);
| public class EClassDAOImpl extends BasicMemoryDAOImpl<EClassDescriptor> implements EClassDescriptor.DAO {
|
751 | return DefaultQueryTool.createQueryEClass(this, eClass);
}
public IGenericQuery<EClassDescriptor> createQueryEClassesInPackage(EPackageDescriptor ePackageDescriptor) {
return ePackageScope.createQuery(ePackageDescriptor);
}
<BUG>protected class EClassQuery extends BasicCachingMemoryDAO<EClassDescriptor>.Query implements EClassDescriptor.Query {
</BUG>
private String namePattern;
private EPackageDescriptor ePackageDescriptor;
private EPackageDescriptor.Query ePackageQuery;
| protected class EClassQuery extends BasicMemoryDAOImpl<EClassDescriptor>.Query implements EClassDescriptor.Query {
|
752 | ePackageQuery = indexStore.ePackageDAO().createQuery();
return ePackageQuery;
}
@Override
protected boolean matches(EClassDescriptor typeDescriptor) {
<BUG>return (namePattern == null || namePattern.equals(typeDescriptor.getName()));
}</BUG>
@Override
protected Collection<EClassDescriptor> scope() {
Collection<EClassDescriptor> eClassesByEPackage = ePackageScope.lookup(ePackageDescriptor, ePackageQuery);
| return matchesGlobbing(typeDescriptor.getName(), namePattern);
|
753 | private TargetDesc target;
protected Query(TargetDesc target) {
this.target = target;
}
public Collection<SourceDesc> executeListResult() {
<BUG>return lookup(target);
}</BUG>
public SourceDesc executeSingleResult() {
Collection<SourceDesc> result = lookup(target);
if(result != null && !result.isEmpty()) {
| return CollectionUtils.copyOrNull(lookup(target));
|
754 | import org.eclipse.emf.index.ECrossReferenceDescriptor;
import org.eclipse.emf.index.EObjectDescriptor;
import org.eclipse.emf.index.IGenericQuery;
import org.eclipse.emf.index.IIndexStore;
import org.eclipse.emf.index.impl.DefaultQueryTool;
<BUG>public class ECrossReferenceDAOImpl extends BasicCachingMemoryDAO<ECrossReferenceDescriptor> implements
</BUG>
ECrossReferenceDescriptor.DAO {
protected InverseReferenceCache<EObjectDescriptor, ECrossReferenceDescriptor> sourceScope;
protected InverseReferenceCache<EObjectDescriptor, ECrossReferenceDescriptor> targetScope;
| public class ECrossReferenceDAOImpl extends BasicMemoryDAOImpl<ECrossReferenceDescriptor> implements
|
755 | return sourceScope.createQuery(sourceDescriptor);
}
public IGenericQuery<ECrossReferenceDescriptor> createQueryCrossReferencesTo(EObjectDescriptor targetDescriptor) {
return targetScope.createQuery(targetDescriptor);
}
<BUG>protected class CrossRefQuery extends BasicCachingMemoryDAO<ECrossReferenceDescriptor>.Query implements
</BUG>
ECrossReferenceDescriptor.Query {
private EObjectDescriptor.Query sourceQuery;
private EObjectDescriptor.Query targetQuery;
| protected class CrossRefQuery extends BasicMemoryDAOImpl<ECrossReferenceDescriptor>.Query implements
|
756 | public ECrossReferenceDescriptor.Query referenceName(String pattern) {
referenceNamePattern = pattern;
return this;
}
protected boolean matches(ECrossReferenceDescriptor crossRefDescriptor) {
<BUG>return referenceNamePattern == null || referenceNamePattern.equals(crossRefDescriptor.getReferenceName());
}</BUG>
@Override
protected Collection<ECrossReferenceDescriptor> scope() {
Collection<ECrossReferenceDescriptor> eCrossReferencesBySource = sourceScope.lookup(sourceDescriptor, sourceQuery);
| return matchesGlobbing(crossRefDescriptor.getReferenceName(), referenceNamePattern);
|
757 | <BUG>package org.eclipse.emf.index.ecore;
import org.eclipse.emf.ecore.EPackage;</BUG>
import org.eclipse.emf.index.EPackageDescriptor;
import org.eclipse.emf.index.IIndexStore;
public class EPackageRegistryIndexFeeder {
| import java.util.ArrayList;
import java.util.List;
import org.eclipse.emf.ecore.EPackage;
|
758 | import org.eclipse.emf.index.EPackageDescriptor;
import org.eclipse.emf.index.IIndexStore;
public class EPackageRegistryIndexFeeder {
public static void feedEPackagesFromRegistry(IIndexStore indexStore) {
for (boolean hasChanged = true; hasChanged;) {
<BUG>for (String nsURI : EPackage.Registry.INSTANCE.keySet()) {
hasChanged = false;</BUG>
EPackageDescriptor storedEPackages = indexStore.ePackageDAO().createQuery().nsURI(nsURI)
.executeSingleResult();
if (storedEPackages == null) {
| List<String> nsURIs = new ArrayList<String>(EPackage.Registry.INSTANCE.keySet());
for (String nsURI : nsURIs) {
hasChanged = false;
|
759 | import org.eclipse.emf.index.EObjectDescriptor;
import org.eclipse.emf.index.IGenericQuery;
import org.eclipse.emf.index.IIndexStore;
import org.eclipse.emf.index.ResourceDescriptor;
import org.eclipse.emf.index.impl.DefaultQueryTool;
<BUG>public class EObjectDAOImpl extends BasicCachingMemoryDAO<EObjectDescriptor> implements EObjectDescriptor.DAO {
</BUG>
protected InverseReferenceCache<ResourceDescriptor, EObjectDescriptor> resourceScope;
protected InverseReferenceCache<EClassDescriptor, EObjectDescriptor> eClassScope;
public EObjectDAOImpl(IIndexStore indexStore) {
| public class EObjectDAOImpl extends BasicMemoryDAOImpl<EObjectDescriptor> implements EObjectDescriptor.DAO {
|
760 | return DefaultQueryTool.createQueryEObjectsInResource(this, eObject, resourceDescriptor);
}
public IGenericQuery<EObjectDescriptor> createQueryEObjectsInResource(ResourceDescriptor resourceDescriptor) {
return resourceScope.createQuery(resourceDescriptor);
}
<BUG>private class ElementQuery extends BasicCachingMemoryDAO<EObjectDescriptor>.Query implements EObjectDescriptor.Query {
</BUG>
private ResourceDescriptor resourceDescriptor;
private ResourceDescriptor.Query resourceQuery;
private String fragmentPattern;
| private class ElementQuery extends BasicMemoryDAOImpl<EObjectDescriptor>.Query implements EObjectDescriptor.Query {
|
761 | }
userDataPatterns.put(key, pattern);
return this;
}
public boolean matches(EObjectDescriptor elementDescriptor) {
<BUG>if ((fragmentPattern == null || fragmentPattern.equals(elementDescriptor.getFragment()))
&& (namePattern == null || namePattern.equals(elementDescriptor.getName()))
&& (typeDescriptor == null || typeDescriptor.equals(elementDescriptor.getEClassDescriptor()))) {</BUG>
if (userDataPatterns != null) {
for (Entry<String, String> userDataEntry : userDataPatterns.entrySet()) {
| public IGenericQuery<EObjectDescriptor> createQueryEObjectsByType(EClassDescriptor eClassDescriptor) {
return eClassScope.createQuery(eClassDescriptor);
|
762 | import lu.nowina.nexu.flow.operation.SelectPrivateKeyOperation;
import lu.nowina.nexu.flow.operation.SignOperation;
import lu.nowina.nexu.flow.operation.TokenOperationResultKey;
import lu.nowina.nexu.view.core.UIDisplay;
import lu.nowina.nexu.view.core.UIOperation;
<BUG>import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import eu.europa.esig.dss.SignatureValue;
import eu.europa.esig.dss.token.DSSPrivateKeyEntry;
import eu.europa.esig.dss.token.SignatureTokenConnection;</BUG>
class SignatureFlow extends AbstractCoreFlow<SignatureRequest, SignatureResponse> {
| [DELETED] |
763 | getOperationFactory().getOperation(AdvancedCreationFeedbackOperation.class,
api, map).perform();
}
if(api.getAppConfig().isEnablePopUps()) {
getOperationFactory().getOperation(UIOperation.class, "/fxml/message.fxml",
<BUG>new Object[]{ResourceBundle.getBundle("bundles/nexu").getString("signature.flow.finished")}).perform();
}</BUG>
return new Execution<SignatureResponse>(new SignatureResponse(value, key.getCertificate(), key.getCertificateChain()));
} else {
return handleErrorOperationResult(signOperationResult);
| new Object[]{"signature.flow.finished"}).perform();
|
764 | } else {
return handleErrorOperationResult(signOperationResult);
}
} else {
if(api.getAppConfig().isEnablePopUps()) {
<BUG>getOperationFactory().getOperation(UIOperation.class, "/fxml/message.fxml",
new Object[]{MessageFormat.format(
ResourceBundle.getBundle("bundles/nexu").getString("signature.flow.no.key.selected"),
api.getAppConfig().getApplicationName())
}).perform();</BUG>
}
| new Object[]{"signature.flow.no.key.selected", api.getAppConfig().getApplicationName()}).perform();
|
765 | package lu.nowina.nexu.view.ui;
<BUG>import java.net.URL;
import java.util.ResourceBundle;</BUG>
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.Button;
| import java.text.MessageFormat;
import java.util.Arrays;
import java.util.ResourceBundle;
|
766 | public class MessageController extends AbstractUIOperationController<Void> implements Initializable {
@FXML
private Label message;
@FXML
private Button ok;
<BUG>private String defaultErrorText;
@Override</BUG>
public void initialize(URL location, ResourceBundle resources) {
ok.setOnAction((e) -> {
signalEnd(null);
| private ResourceBundle resources;
@Override
|
767 | try {
server.stop();
} catch(Exception e1) {}
throw e;
}
<BUG>new Thread(() -> {
try {
server.join();
} catch(Exception e) {
logger.error("Exception on join", e);
}
});</BUG>
return server;
| server.start();
|
768 | package lu.nowina.nexu.flow;
<BUG>import java.text.MessageFormat;
import java.util.ResourceBundle;</BUG>
import lu.nowina.nexu.api.Execution;
import lu.nowina.nexu.api.Feedback;
import lu.nowina.nexu.api.NexuAPI;
| [DELETED] |
769 | final Feedback feedback = new Feedback(e);
getOperationFactory().getOperation(
UIOperation.class, "/fxml/provide-feedback.fxml",
new Object[]{feedback, api.getAppConfig().getServerUrl(), api.getAppConfig().getApplicationVersion(),
api.getAppConfig().getApplicationName()}).perform();
<BUG>getOperationFactory().getOperation(UIOperation.class, "/fxml/message.fxml",
new Object[]{MessageFormat.format(
ResourceBundle.getBundle("bundles/nexu").getString("exception.failure.message"),
api.getAppConfig().getApplicationName())
}).perform();</BUG>
}
| new Object[]{"exception.failure.message", api.getAppConfig().getApplicationName()}).perform();
|
770 | package lu.nowina.nexu.flow;
import java.util.List;
import java.util.Map;
<BUG>import java.util.ResourceBundle;
import lu.nowina.nexu.api.CardAdapter;</BUG>
import lu.nowina.nexu.api.DetectedCard;
import lu.nowina.nexu.api.Execution;
import lu.nowina.nexu.api.GetCertificateRequest;
| import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import eu.europa.esig.dss.token.DSSPrivateKeyEntry;
import eu.europa.esig.dss.token.SignatureTokenConnection;
import eu.europa.esig.dss.x509.CertificateToken;
import lu.nowina.nexu.api.CardAdapter;
|
771 | import lu.nowina.nexu.flow.operation.GetTokenConnectionOperation;
import lu.nowina.nexu.flow.operation.SelectPrivateKeyOperation;
import lu.nowina.nexu.flow.operation.TokenOperationResultKey;
import lu.nowina.nexu.view.core.UIDisplay;
import lu.nowina.nexu.view.core.UIOperation;
<BUG>import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import eu.europa.esig.dss.token.DSSPrivateKeyEntry;
import eu.europa.esig.dss.token.SignatureTokenConnection;
import eu.europa.esig.dss.x509.CertificateToken;</BUG>
class GetCertificateFlow extends AbstractCoreFlow<GetCertificateRequest, GetCertificateResponse> {
| [DELETED] |
772 | resp.setSupportedDigests(cardAdapter.getSupportedDigestAlgorithms(card));
resp.setPreferredDigest(cardAdapter.getPreferredDigestAlgorithm(card));
}
if(api.getAppConfig().isEnablePopUps()) {
getOperationFactory().getOperation(UIOperation.class, "/fxml/message.fxml",
<BUG>new Object[]{ ResourceBundle.getBundle("bundles/nexu").getString("certificates.flow.finished") }).perform();
}</BUG>
return new Execution<GetCertificateResponse>(resp);
} else {
return handleErrorOperationResult(selectPrivateKeyOperationResult);
| new Object[]{ "certificates.flow.finished" }).perform();
|
773 | when(operationFactory.getOperation(GetMatchingCardAdaptersOperation.class, api)).thenReturn(operation);
final Operation<Object> successOperation = mock(Operation.class);
when(successOperation.perform()).thenReturn(new OperationResult<Object>(BasicOperationStatus.SUCCESS));
when(operationFactory.getOperation(
eq(UIOperation.class), eq("/fxml/provide-feedback.fxml"), any(Object[].class))).thenReturn(successOperation);
<BUG>when(operationFactory.getOperation(
UIOperation.class, "/fxml/message.fxml", new Object[]{"Finished"})).thenReturn(successOperation);</BUG>
final GetCertificateFlow flow = new GetCertificateFlow(display, api);
flow.setOperationFactory(operationFactory);
final GetCertificateRequest req = new GetCertificateRequest();
| [DELETED] |
774 | import java.io.IOException;
import static org.gradle.internal.nativeplatform.jna.Kernel32.*;
public class WindowsHandlesManipulator {
public void uninheritStandardStreams() throws ProcessInitializationException {
Kernel32 kernel32 = INSTANCE;
<BUG>try {
HANDLE stdin = kernel32.GetStdHandle(Kernel32.STD_INPUT_HANDLE);
makeUninheritable(kernel32, stdin);
HANDLE stdout = kernel32.GetStdHandle(Kernel32.STD_OUTPUT_HANDLE);
makeUninheritable(kernel32, stdout);
HANDLE stderr = kernel32.GetStdHandle(Kernel32.STD_ERROR_HANDLE);
makeUninheritable(kernel32, stderr);</BUG>
} catch (Exception e) {
| uninheritStream(kernel32, Kernel32.STD_INPUT_HANDLE);
uninheritStream(kernel32, Kernel32.STD_OUTPUT_HANDLE);
uninheritStream(kernel32, Kernel32.STD_ERROR_HANDLE);
|
775 | }
@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)
|
776 | 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))
|
777 | }
@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);
|
778 | 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);
|
779 | 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);
|
780 | 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);
|
781 | } else {
updateMemo();
callback.updateMemo();
}
dismiss();
<BUG>}else{
</BUG>
Toast.makeText(getActivity(), getString(R.string.toast_memo_empty), Toast.LENGTH_SHORT).show();
}
}
| [DELETED] |
782 | }
@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);
|
783 | 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);
|
784 | 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(
|
785 | 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 {
|
786 | 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;
|
787 | 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) {
|
788 | 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;
|
789 | }
@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)
|
790 | 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))
|
791 | 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)
|
792 | 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");
|
793 | 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");
|
794 | }
@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);
|
795 | 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);
|
796 | 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);
|
797 | 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);
|
798 | public ReportElement getBase() {
return base;
}
@Override
public float print(PDDocument document, PDPageContentStream stream, int pageNumber, float startX, float startY, float allowedWidth) throws IOException {
<BUG>PDPage currPage = (PDPage) document.getDocumentCatalog().getPages().get(pageNo);
PDPageContentStream pageStream = new PDPageContentStream(document, currPage, true, false);
</BUG>
base.print(document, pageStream, pageNo, x, y, width);
pageStream.close();
| PDPage currPage = document.getDocumentCatalog().getPages().get(pageNo);
PDPageContentStream pageStream = new PDPageContentStream(document, currPage, PDPageContentStream.AppendMode.APPEND, false);
|
799 | public PdfTextStyle(String config) {
Assert.hasText(config);
String[] split = config.split(",");
Assert.isTrue(split.length == 3, "config must look like: 10,Times-Roman,#000000");
fontSize = Integer.parseInt(split[0]);
<BUG>font = resolveStandard14Name(split[1]);
color = new Color(Integer.valueOf(split[2].substring(1), 16));</BUG>
}
public int getFontSize() {
return fontSize;
| font = getFont(split[1]);
color = new Color(Integer.valueOf(split[2].substring(1), 16));
|
800 | package cc.catalysts.boot.report.pdf.elements;
import cc.catalysts.boot.report.pdf.config.PdfTextStyle;
import cc.catalysts.boot.report.pdf.utils.ReportAlignType;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
<BUG>import org.apache.pdfbox.pdmodel.font.PDFont;
import org.slf4j.Logger;</BUG>
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;
import java.io.IOException;
| import org.apache.pdfbox.pdmodel.font.PDType1Font;
import org.apache.pdfbox.util.Matrix;
import org.slf4j.Logger;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.