[Demonstration 1]

[Buggy Method]
public static String getData(String message) {
    return message.substring(message.indexOf('.'), message.length());
}

[Buggy Hunk]
return message.substring(message.indexOf('.'), message.length());

[Patch]
return message.substring(message.indexOf('.')+1, message.length());

[Demonstration 2]

[Buggy Method]
@Override
protected void onStart() {
    super.onStart();
    compositeSubscription = new CompositeSubscription();
    compositeSubscription.add(bindActivity(this, reactiveLocationProvider.getCurrentPlace(null)).flatMap(new Func1<PlaceLikelihoodBuffer, Observable<PlaceLikelihood>>() {

        @Override
        public Observable<PlaceLikelihood> call(PlaceLikelihoodBuffer placeLikelihoods) {
            return DataBufferObservable.from(placeLikelihoods);
        }
    }).firstOrDefault(null).subscribe(new Action1<PlaceLikelihood>() {

        @Override
        public void call(PlaceLikelihood place) {
            if (place != null) {
                currentPlaceView.setText(place.getPlace().getName());
            }
        }
    }));
    Observable<String> queryObservable = TextObservable.create(queryView).debounce(1, TimeUnit.SECONDS).filter(new Func1<String, Boolean>() {

        @Override
        public Boolean call(String s) {
            return !TextUtils.isEmpty(s);
        }
    });
    Observable<Location> lastKnownLocationObservable = reactiveLocationProvider.getLastKnownLocation();
    Observable<List<String>> suggestionsObservable = Observable.combineLatest(queryObservable, lastKnownLocationObservable, new Func2<String, Location, QueryWithCurrentLocation>() {

        @Override
        public QueryWithCurrentLocation call(String query, Location currentLocation) {
            return new QueryWithCurrentLocation(query, currentLocation);
        }
    }).flatMap(new Func1<QueryWithCurrentLocation, Observable<AutocompletePredictionBuffer>>() {

        @Override
        public Observable<AutocompletePredictionBuffer> call(QueryWithCurrentLocation q) {
            if (q.location == null)
                return Observable.empty();
            double latitude = q.location.getLatitude();
            double longitude = q.location.getLatitude();
            LatLngBounds bounds = new LatLngBounds(new LatLng(latitude - 0.05, longitude - 0.05), new LatLng(latitude + 0.05, longitude + 0.05));
            return reactiveLocationProvider.getPlaceAutocompletePredictions(q.query, bounds, null);
        }
    }).flatMap(new Func1<AutocompletePredictionBuffer, Observable<List<String>>>() {

        @Override
        public Observable<List<String>> call(AutocompletePredictionBuffer autocompletePredictions) {
            return DataBufferObservable.from(autocompletePredictions).map(new Func1<AutocompletePrediction, String>() {

                @Override
                public String call(AutocompletePrediction autocompletePrediction) {
                    return autocompletePrediction.getDescription();
                }
            }).toList();
        }
    });
    compositeSubscription.add(bindActivity(this, suggestionsObservable).subscribe(new Action1<List<String>>() {

        @Override
        public void call(List<String> autocompletePredictions) {
            placeSuggestionsList.setAdapter(new ArrayAdapter<>(PlacesActivity.this, android.R.layout.simple_list_item_1, autocompletePredictions));
        }
    }));
}

[Buggy Hunk]
double longitude = q.location.getLatitude();

[Patch]
double longitude = q.location.getLongitude();

[Demonstration 3]

[Buggy Method]
private Exertion dispatchExertion(ServiceExertion exertion, String providerName) throws ExertionException, ExecutionException {
    Signature signature = exertion.getProcessSignature();
    Object provider = null;
    try {
        // If the exertion is a job rearrange the inner exertions to make sure the
        // dependencies are not broken
        if (exertion.isJob()) {
            ExertionSorter es = new ExertionSorter(exertion);
            exertion = (ServiceExertion) es.getSortedJob();
        }
        //			 exert modeling tasks
        if (exertion instanceof ModelingTask && exertion.getFidelity().getSelects().size() == 1) {
            return ((Task) exertion).doTask(transaction);
        }
        // handle delegated tasks with fidelities
        if (exertion.getClass() == Task.class) {
            if (exertion.getFidelity().getSelects().size() == 1) {
                return ((Task) exertion).doTask(transaction);
            } else {
                try {
                    return new ControlFlowManager().doTask((Task) exertion);
                } catch (ContextException e) {
                    e.printStackTrace();
                    throw new ExertionException(e);
                }
            }
        }
        // exert object tasks and jobs
        if (!(signature instanceof NetSignature)) {
            if (exertion instanceof Task) {
                if (exertion.getFidelity().getSelects().size() == 1) {
                    return ((Task) exertion).doTask(transaction);
                } else {
                    try {
                        return new ControlFlowManager().doTask((Task) exertion);
                    } catch (ContextException e) {
                        e.printStackTrace();
                        throw new ExertionException(e);
                    }
                }
            } else if (exertion instanceof Job) {
                return ((Job) exertion).doJob(transaction);
            } else if (exertion instanceof Block) {
                return ((Block) exertion).doBlock(transaction);
            }
        }
        // check for missing signature of inconsistent PULL/PUSH cases
        logger.info("signature (before) = {}", signature);
        signature = correctProcessSignature();
        logger.info("signature (after)  = {}", signature);
        if (!((ServiceSignature) signature).isSelectable()) {
            exertion.reportException(new ExertionException("No such operation in the requested signature: " + signature));
            logger.warn("Not selectable exertion operation: " + signature);
            return exertion;
        }
        if (providerName != null && providerName.length() > 0) {
            signature.setProviderName(providerName);
        }
        if (logger.isDebugEnabled())
            logger.debug("ServiceShell's service accessor: {}", Accessor.get().getClass().getName());
        // if space exertion should go to Spacer
        if (!exertion.isJob() && exertion.getControlContext().getAccessType() == Access.PULL) {
            signature = new NetSignature("exert", Spacer.class, Sorcer.getActualSpacerName());
            exertion.correctProcessSignature(signature);
        }
        provider = ((NetSignature) signature).getProvider();
        if (provider == null) {
            // check proxy cache amd ping with a provider name
            try {
                provider = proxies.get(signature);
                ((Provider) provider).getProviderName();
            } catch (RuntimeException e) {
                proxies.refresh(signature);
                provider = proxies.get(signature);
            }
            if (provider == null) {
                String message = String.format("Provider name: [%s], type: %s not found, make sure it is running and there is " + "an available lookup service with correct discovery settings", signature.getProviderName(), signature.getServiceType().getName());
                logger.error(message);
                throw new ExertionException(message);
            }
            // lookup proxy
            /*if (provider == null) {
					long t0 = System.currentTimeMillis();
					provider = Accessor.get().getService(signature);
					if (logger.isDebugEnabled())
					 logger.info("Return from Accessor.getService(), round trip: {} millis",
							 (System.currentTimeMillis() - t0));
				}*/
        }
    } catch (Exception e) {
        throw new ExertionException(e);
    }
    if (provider != null) {
        if (provider instanceof Provider) {
            // cache the provider for the signature
            ((NetSignature) signature).setProvider((Provider) provider);
            //				if (proxies != null)
            //					proxies.put(signature, provider);
        } else if (exertion instanceof Task) {
            // exert smart proxy as an object task delegate
            try {
                ObjectSignature sig = new ObjectSignature();
                sig.setSelector(signature.getSelector());
                sig.setTarget(provider);
                Context cxt = exertion.getContext();
                ((Task) exertion).setDelegate(new ObjectTask(sig, cxt));
                return ((Task) exertion).doTask(transaction);
            } catch (Exception e) {
                throw new ExertionException(e);
            }
        }
    }
    this.provider = (Provider) provider;
    // continue exerting
    return null;
}

[Buggy Hunk]
} catch(RuntimeException e) {

[Patch]
} catch(Exception e) {