*/
    public boolean isDeleted() {
        return isUpdated() && newInput.length() == 0;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        final int result = 1;
        return prime * result + input.hashCode();
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {

    while (lines.peek() == null) {
      Java8Compatibility.clear(cbuf);
      // The default implementation of Reader#read(CharBuffer) allocates a
      // temporary char[], so we call Reader#read(char[], int, int) instead.
      int read = (reader != null) ? reader.read(buf, 0, buf.length) : readable.read(cbuf);
      if (read == -1) {
        lineBuf.finish();
        break;
      }
      lineBuf.add(buf, 0, read);
    }

        this.second = second;
    }

    @Override
    public String toString() {
        return "{" + first + ", " + second + "}";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((first == null) ? 0 : first.hashCode());
        result = prime * result + ((second == null) ? 0 : second.hashCode());
        return result;
    }

    @Test
    public void testPerformance() throws Exception {
        final int num = 100;
        long start = System.currentTimeMillis();
        for (int i = 0; i < num; i++) {
            System.out.println("test" + i);
        }
        final long sysout = System.currentTimeMillis() - start;
        start = System.currentTimeMillis();
        for (int i = 0; i < num; i++) {
            logger.fatal("test" + i);
        }

            throw new RuntimeException(uee.getMessage());
        }
    }

    static byte[] computeResponse(final byte[] responseKey, final byte[] serverChallenge, final byte[] clientData, final int offset,
            final int length) {
        final HMACT64 hmac = new HMACT64(responseKey);
        hmac.update(serverChallenge);
        hmac.update(clientData, offset, length);
        final byte[] mac = hmac.digest();

    final List<E> elements;
    int modCount = 0;

    PickyIterable(E... elements) {
      this.elements = new ArrayList<E>(asList(elements));
    }

    @Override
    public Iterator<E> iterator() {
      return new PickyIterator();
    }

    final class PickyIterator implements Iterator<E> {
      int expectedModCount = modCount;
      int index = 0;
      boolean canRemove;

				"name": "my name",
			},
			expect: clause.Values{
				Columns: []clause.Column{{Name: "name"}},
				Values:  [][]interface{}{{"my name"}},
			},
		},
		{
			name: "Test convert int value",
			input: map[string]interface{}{
				"age": 18,
			},
			expect: clause.Values{
				Columns: []clause.Column{{Name: "age"}},
				Values:  [][]interface{}{{18}},
			},
		},
		{

    protected final long tookMs;

    /**
     * The list of popular words.
     */
    protected final List<String> words;

    /**
     * The number of popular words.
     */
    protected final int num;

    /**
     * The total number of words.
     */
    protected final long total;

    /**
     * The list of suggested items.
     */
    protected final List<SuggestItem> items;

    /**

    for (CharSource in : BROKEN_SOURCES) {
      int suppressed = runSuppressionFailureTest(in, newNormalCharSink());
      assertEquals(0, suppressed);

      suppressed = runSuppressionFailureTest(in, BROKEN_CLOSE_SINK);
      assertEquals((in == BROKEN_OPEN_SOURCE) ? 0 : 1, suppressed);
    }

    for (CharSink out : BROKEN_SINKS) {
      int suppressed = runSuppressionFailureTest(newNormalCharSource(), out);

		}
	}
}

// time n scanner actions.
// Use for s < scannerMetricLastRealtime
func (p *scannerMetrics) timeN(s scannerMetric) func(n int) func() {
	startTime := time.Now()
	return func(n int) func() {
		return func() {
			duration := time.Since(startTime)

			atomic.AddUint64(&p.operations[s], uint64(n))
			if s < scannerMetricLastRealtime {
				p.latency[s].add(duration)