/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "WriterTest.h"

#include <decaf/io/Writer.h>
#include <decaf/nio/CharBuffer.h>
#include <decaf/lang/exceptions/IndexOutOfBoundsException.h>

using namespace std;
using namespace decaf;
using namespace decaf::io;
using namespace decaf::nio;
using namespace decaf::lang::exceptions;

////////////////////////////////////////////////////////////////////////////////
namespace {

    class MockWriter : public Writer {
    private:

        char* contents;
        int length;
        int offset;

    private:

        MockWriter(const MockWriter&);
        MockWriter& operator= (const MockWriter&);

    public:

        MockWriter( int capacity ) : contents(), length(capacity), offset(0) {
            contents = new char[capacity];
        }

        virtual ~MockWriter() {
            close();
        }

        virtual void close() {
            flush();
            delete [] contents;
            contents = NULL;
        }

        virtual void flush() {
        }

        virtual void doWriteArrayBounded(
            const char* buffer, int size, int offset, int length ) {

            if( NULL == contents ) {
                throw IOException( __FILE__, __LINE__, "Writer was already closed." );
            }

            if( offset + length > size ) {
                throw IndexOutOfBoundsException(
                    __FILE__, __LINE__, "offset + length must be less than size." );
            }

            for( int i = 0; i < length; i++ ) {
                contents[this->offset + i] = buffer[offset + i];
            }

            this->offset += length;

        }

        std::vector<char> getContents() {

            std::vector<char> result( offset );

            for( int i = 0; i < offset; i++ ) {
                result[i] = contents[i];
            }

            return result;
        }
    };

}

////////////////////////////////////////////////////////////////////////////////
WriterTest::WriterTest() {
}

////////////////////////////////////////////////////////////////////////////////
WriterTest::~WriterTest() {
}

////////////////////////////////////////////////////////////////////////////////
void WriterTest::testWriteChar() {

    std::string testString = "My Test String";
    MockWriter writer( 20 );

    std::string::const_iterator iter = testString.begin();
    for( ; iter != testString.end(); ++iter ) {
        writer.write( *iter );
    }

    std::vector<char> result = writer.getContents();
    CPPUNIT_ASSERT_EQUAL( testString, std::string( result.begin(), result.end() ) );
}

////////////////////////////////////////////////////////////////////////////////
void WriterTest::testWriteVector() {

    std::string testString = "My Test String";
    MockWriter writer( 20 );

    std::vector<char> buffer( testString.begin(), testString.end() );
    writer.write( buffer );

    std::vector<char> result = writer.getContents();
    CPPUNIT_ASSERT_EQUAL( testString, std::string( result.begin(), result.end() ) );
}

////////////////////////////////////////////////////////////////////////////////
void WriterTest::testWriteString() {

    std::string testString = "My Test String";
    MockWriter writer( 20 );

    writer.write( testString );

    std::vector<char> result = writer.getContents();
    CPPUNIT_ASSERT_EQUAL( testString, std::string( result.begin(), result.end() ) );
}

////////////////////////////////////////////////////////////////////////////////
void WriterTest::testWriteStringOffsetCount() {

    std::string testString = "My Test String";
    MockWriter writer( 20 );

    writer.write( testString, 0, (int)testString.length() );

    std::vector<char> result = writer.getContents();
    CPPUNIT_ASSERT_EQUAL( testString, std::string( result.begin(), result.end() ) );
}

////////////////////////////////////////////////////////////////////////////////
void WriterTest::testAppendChar() {

    char testChar = ' ';
    MockWriter writer(20);

    writer.append( testChar );

    CPPUNIT_ASSERT_EQUAL( testChar, writer.getContents()[0] );

    writer.close();
}

////////////////////////////////////////////////////////////////////////////////
void WriterTest::testAppendCharSequence() {

    std::string testString = "My Test String";
    MockWriter writer( 20 );

    CharBuffer* buffer = CharBuffer::allocate( (int)testString.size() );
    buffer->put( testString );
    buffer->rewind();

    writer.append( buffer );

    std::vector<char> result = writer.getContents();
    CPPUNIT_ASSERT_EQUAL( testString, std::string( result.begin(), result.end() ) );

    writer.close();

    delete buffer;
}

////////////////////////////////////////////////////////////////////////////////
void WriterTest::testAppendCharSequenceIntInt() {

    std::string testString = "My Test String";
    MockWriter writer(20);

    CharBuffer* buffer = CharBuffer::allocate( (int)testString.size() );
    buffer->put( testString );
    buffer->rewind();

    writer.append( buffer, 1, 3 );

    std::vector<char> result = writer.getContents();
    CPPUNIT_ASSERT_EQUAL( testString.substr( 1, 2 ), std::string( result.begin(), result.end() ) );

    writer.close();

    delete buffer;
}