*
     * @param reader a reader object.
     * @throws IOException IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     * any.
     * @return CoreExtensions
     */
    public CoreExtensions read(Reader reader) throws IOException, XmlPullParserException {
        return read(reader, true);
    } // -- CoreExtensions read( Reader )

    /**
     * Method read.
     *

            try (final DocumentReader documentReader = reader.get()) {
                Map<String, Object> doc = documentReader.read();
                while (doc != null) {
                    if (Thread.currentThread().isInterrupted()) {
                        break;
                    }
                    docs.add(doc);
                    doc = documentReader.read();

	return key, err
}

// EncryptSinglePart encrypts an io.Reader which must be the
// body of a single-part PUT request.
func EncryptSinglePart(r io.Reader, key ObjectKey) io.Reader {
	r, err := sio.EncryptReader(r, sio.Config{MinVersion: sio.Version20, Key: key[:]})
	if err != nil {
		logger.CriticalIf(context.Background(), errors.New("Unable to encrypt io.Reader using object key"))
	}
	return r
}

 */
public class LineIteratorTest {

    /**
     * @throws Exception
     */
    @Test
    public void test() throws Exception {
        final StringReader reader = new StringReader("aaa\nbbb\nccc\n");
        final LineIterator it = new LineIterator(reader);
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("aaa"));
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("bbb"));

    sed -i "" \
      "s/\"com.squareup.okhttp3:\([^\:]*\):[^\"]*\"/\"com.squareup.okhttp3:\1:$RELEASE_VERSION\"/g" \
      `find . -name "README.md"`
    sed -i "" \
      "s/\/com.squareup.okhttp3\/\([^\:]*\)\/[^\/]*\//\/com.squareup.okhttp3\/\1\/$RELEASE_VERSION\//g" \
      `find . -name "README.md"`

    git commit -am "Prepare for release $RELEASE_VERSION."
    git tag -a parent-$RELEASE_VERSION -m "Version $RELEASE_VERSION"

	return &Checker{c: rc, r: ioutil.HardLimitReader(rc, length), h: h, want: wantSum}
}

// Read satisfies io.Reader
func (c Checker) Read(p []byte) (n int, err error) {
	n, err = c.r.Read(p)
	if n > 0 {
		c.h.Write(p[:n])
	}
	if errors.Is(err, io.EOF) {
		got := c.h.Sum(nil)
		if !bytes.Equal(got, c.want) {
			return n, ErrInvalidChecksum
		}
		return n, err
	}
	return n, err
}

// Close satisfies io.Closer

func (v Versioning) PrefixesExcluded() bool {
	return len(v.ExcludedPrefixes) > 0 || v.ExcludeFolders
}

// ParseConfig - parses data in given reader to VersioningConfiguration.
func ParseConfig(reader io.Reader) (*Versioning, error) {
	var v Versioning
	if err := xml.NewDecoder(reader).Decode(&v); err != nil {
		return nil, err
	}
	if err := v.Validate(); err != nil {
		return nil, err
	}
	return &v, nil

			}

			if totalGet < throughputHighestGet {
				// Following check is for situations
				// when Writes() scale higher than Reads()
				// - practically speaking this never happens
				// and should never happen - however it has
				// been seen recently due to hardware issues
				// causes Reads() to go slower than Writes().
				//
				// Send such results anyways as this shall
				// expose a problem underneath.

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;

public class TransformLog4jConfigFilter extends FilterReader {
    public TransformLog4jConfigFilter(Reader in) throws IOException {
        super(new StringReader(transform(in)));
    }

    private static String transform(Reader reader) throws IOException {

    assertThat(inputStream!!.read()).isEqualTo('A'.code)
    assertThat(inputStream.read()).isEqualTo('B'.code)
    assertThat(inputStream.read()).isEqualTo('C'.code)
    assertThat(inputStream.read()).isEqualTo('D'.code)
    assertThat(inputStream.read()).isEqualTo('E'.code)
    assertThat(inputStream.read()).isEqualTo('F'.code)
    assertThat(inputStream.read()).isEqualTo(-1)