[Demonstration 1]

[Buggy Method]
@Test
public void should_get_existing_entry_from_cache() {
    given(mockCache.get(SOME_KEY)).willReturn(new ICache.Entry(SOME_BYTES));
    given(mockDataMapper.fromBytes(any(byte[].class), eq(SomeEntry.class))).willReturn(mockEntry);
    ObservableCacheDispatcher cacheDispatcher = new ObservableCacheDispatcher(mockCache, mockDataMapper);
    Observable<SomeEntry> observable = cacheDispatcher.get(SOME_KEY, SomeEntry.class, mockLoader, mockExpiration);
    SomeEntry result = (SomeEntry) observable.toBlocking().first();
    verify(mockLoader, never()).invoke();
    verify(mockCache).get(SOME_KEY);
    verify(mockCache, never()).put(anyString(), any(ICache.Entry.class));
    verify(mockDataMapper).fromBytes(any(byte[].class), eq(SomeEntry.class));
    verify(mockDataMapper, never()).toBytes(anyObject());
    assertThat(result, is(equalTo(mockEntry)));
}

[Buggy Hunk]
SomeEntry result = (SomeEntry) observable.toBlocking().first();

[Patch]
SomeEntry result = observable.toBlocking().first();

[Demonstration 2]

[Buggy Method]
protected CipherSolution runGibbsSampler(BigDecimal temperature, CipherSolution solution) {
    BigDecimal acceptanceProbability;
    RouletteSampler<LetterProbability> rouletteSampler = new RouletteSampler<>();
    // For each cipher symbol type, run the gibbs sampling
    for (Map.Entry<String, Plaintext> entry : solution.getMappings().entrySet()) {
        List<LetterProbability> plaintextDistribution = computeDistribution(entry.getKey(), solution);
        rouletteSampler.reIndex(plaintextDistribution);
        Character proposedLetter = plaintextDistribution.get(rouletteSampler.getNextIndex(plaintextDistribution)).getValue();
        CipherSolution proposedSolution = solution.clone();
        proposedSolution.getMappings().put(entry.getKey(), new Plaintext(proposedLetter.toString()));
        proposedSolution.setScore(plaintextEvaluator.evaluate(proposedSolution));
        // For now, we're not doing anything if the same mapping is chosen
        if (proposedSolution.getScore().compareTo(solution.getScore()) > 1) {
            solution = proposedSolution;
        } else {
            // Need to convert to log probabilities in order for the acceptance probability calculation to be useful
            // TODO: use a better implementation of exponent that does not lose precision
            acceptanceProbability = BigDecimal.valueOf(Math.exp(convertToLogProbability(solution.getScore()).subtract(convertToLogProbability(proposedSolution.getScore())).divide(temperature, MathContext.DECIMAL128).negate().doubleValue()));
            if (ThreadLocalRandom.current().nextDouble() < acceptanceProbability.doubleValue()) {
                solution = proposedSolution;
            }
        }
    }
    return solution;
}

[Buggy Hunk]
proposedSolution.getMappings().put(entry.getKey(), new Plaintext(proposedLetter.toString()));

[Patch]
proposedSolution.replaceMapping(entry.getKey(), new Plaintext(proposedLetter.toString()));

[Demonstration 3]

[Buggy Method]
@Override
public JsonDeserializer<?> findMapDeserializer(final MapType type, DeserializationConfig config, BeanDescription beanDesc, final KeyDeserializer keyDeserializer, final TypeDeserializer elementTypeDeserializer, final JsonDeserializer<?> elementDeserializer) throws JsonMappingException {
    if (ImmutableMap.class.isAssignableFrom(type.getRawClass())) {
        return new StdDeserializer<Object>(type) {

            @Override
            public Object deserialize(JsonParser jp, DeserializationContext context) throws IOException {
                JsonToken t = jp.getCurrentToken();
                if (t == JsonToken.START_OBJECT) {
                    t = jp.nextToken();
                }
                if (t != JsonToken.FIELD_NAME && t != JsonToken.END_OBJECT) {
                    throw context.mappingException(type.getRawClass());
                }
                MutableMap m = Maps.mutable.of();
                for (; jp.getCurrentToken() == JsonToken.FIELD_NAME; jp.nextToken()) {
                    // Pointing to field name
                    String fieldName = jp.getCurrentName();
                    Object key = (keyDeserializer == null) ? fieldName : keyDeserializer.deserializeKey(fieldName, context);
                    t = jp.nextToken();
                    Object value;
                    if (t == JsonToken.VALUE_NULL) {
                        value = null;
                    } else if (elementDeserializer == null) {
                        value = jp.readValuesAs(type.getContentType().getRawClass());
                    } else if (elementTypeDeserializer == null) {
                        value = elementDeserializer.deserialize(jp, context);
                    } else {
                        value = elementDeserializer.deserializeWithType(jp, context, elementTypeDeserializer);
                    }
                    m.put(key, value);
                }
                return m.toImmutable();
            }
        };
    }
    return super.findMapDeserializer(type, config, beanDesc, keyDeserializer, elementTypeDeserializer, elementDeserializer);
}

[Buggy Hunk]
value = jp.readValuesAs(type.getContentType().getRawClass());

[Patch]
value = jp.readValueAs(type.getContentType().getRawClass());