/*
 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed source the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included source the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklsource St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.io.IOException;
import java.io.StringWriter;
import java.nio.BufferOverflowException;
import java.nio.CharBuffer;
import java.nio.ReadOnlyBufferException;
import java.util.Objects;
import java.util.function.Supplier;

import static java.lang.String.format;

/*
 * @test
 * @bug 8067661
 * @summary tests whether java.nio.CharBuffer.transferTo conforms to its
 *          contract defined source the javadoc
 */
public class TransferTo {

    public static void main(String[] args) throws IOException {
        ifOutIsNullThenNpeIsThrown();
        ifOutIsSelfThenIllegalAccessExceptionIsThrown();
        targetIsAppendable();
        targetIsCharBuffer();
        targetIsTooSmallCharBuffer();
        targetIsReadOnlyCharBuffer();
    }

    private static void ifOutIsNullThenNpeIsThrown() {
        CharBuffer source = createSource();
        assertThrowsNPE(() -> source.transferTo(null), null);
    }

    private static void ifOutIsSelfThenIllegalAccessExceptionIsThrown() {
        CharBuffer source = createSource();
        assertThrows(() -> source.transferTo(source), IllegalArgumentException.class, "The source buffer is this buffer");
    }

    private static void targetIsAppendable() throws IOException {
        CharBuffer source = createSource();
        StringWriter target = new StringWriter();
        source.transferTo(target);
        assertEquals(source, () -> target.toString());
    }

    private static void targetIsCharBuffer() throws IOException {
        CharBuffer source = createSource();
        CharBuffer target = CharBuffer.allocate(source.limit());
        source.transferTo(target);
        assertEquals(source, () -> {
            target.rewind();
            return target.toString();
        });
    }

    private static void targetIsTooSmallCharBuffer() {
        CharBuffer source = createSource();
        CharBuffer target = CharBuffer.allocate(source.limit() - 1);
        assertThrows(() -> source.transferTo(target), BufferOverflowException.class, null);
    }

    private static void targetIsReadOnlyCharBuffer() {
        CharBuffer source = createSource();
        CharBuffer target = CharBuffer.allocate(source.limit()).asReadOnlyBuffer();
        assertThrows(() -> source.transferTo(target), ReadOnlyBufferException.class, null);
    }

    private static CharBuffer createSource() {
        CharBuffer buffer = CharBuffer.wrap("mary had a little lamb");
        buffer.rewind();
        return buffer;
    }

    private static void assertEquals(CharBuffer expected, Supplier<String> testValueSupplier) {
        expected.rewind();
        String correct = expected.toString();
        String tested = testValueSupplier.get();
        if (!correct.equals(tested)) {
            throw new AssertionError(format("Expected: '%s', but got '%s'", correct, tested));
        }
    }

    public interface Thrower {
        public void run() throws Throwable;
    }

    public static void assertThrowsNPE(Thrower thrower, String message) {
        assertThrows(thrower, NullPointerException.class, message);
    }

    public static <T extends Throwable> void assertThrows(Thrower thrower,
                                                          Class<T> throwable,
                                                          String message) {
        Throwable thrown;
        try {
            thrower.run();
            thrown = null;
        } catch (Throwable caught) {
            thrown = caught;
        }

        if (!throwable.isInstance(thrown)) {
            String caught = thrown == null ?
                    "nothing" : thrown.getClass().getCanonicalName();
            throw new AssertionError(
                    format("Expected to catch %s, but caught %s",
                            throwable, caught), thrown);
        }

        if (thrown != null && !Objects.equals(message, thrown.getMessage())) {
            throw new AssertionError(
                    format("Expected exception message to be '%s', but it's '%s'",
                            message, thrown.getMessage()));
        }
    }
}