1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements.  See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License.  You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16package org.apache.harmony.tests.java.io;
17
18import java.io.IOException;
19import java.io.Writer;
20
21import junit.framework.TestCase;
22
23public class WriterTest extends TestCase {
24
25    /**
26     * java.io.Writer#append(char)
27     */
28    public void test_appendChar() throws IOException {
29        char testChar = ' ';
30        MockWriter writer = new MockWriter(20);
31        writer.append(testChar);
32        assertEquals(String.valueOf(testChar), String.valueOf(writer
33                .getContents()));
34        writer.close();
35    }
36
37    /**
38     * java.io.Writer#append(CharSequence)
39     */
40    public void test_appendCharSequence() throws IOException {
41        String testString = "My Test String";
42        MockWriter writer = new MockWriter(20);
43        writer.append(testString);
44        assertEquals(testString, String.valueOf(writer.getContents()));
45        writer.close();
46
47    }
48
49    /**
50     * java.io.Writer#append(CharSequence, int, int)
51     */
52    public void test_appendCharSequenceIntInt() throws IOException {
53        String testString = "My Test String";
54        MockWriter writer = new MockWriter(20);
55        writer.append(testString, 1, 3);
56        assertEquals(testString.substring(1, 3), String.valueOf(writer
57                .getContents()));
58        writer.close();
59
60    }
61
62
63    /**
64     * java.io.Writer#write(String)
65     */
66    public void test_writeLjava_lang_String() throws IOException {
67        // Regression for HARMONY-51
68        Object lock = new Object();
69        Writer wr = new MockLockWriter(lock);
70        wr.write("Some string");
71        wr.close();
72    }
73
74    class MockLockWriter extends Writer {
75        final Object myLock;
76
77        MockLockWriter(Object lock) {
78            super(lock);
79            myLock = lock;
80        }
81
82        @Override
83        public synchronized void close() throws IOException {
84            // do nothing
85        }
86
87        @Override
88        public synchronized void flush() throws IOException {
89            // do nothing
90        }
91
92        @Override
93        public void write(char[] arg0, int arg1, int arg2) throws IOException {
94            assertTrue(Thread.holdsLock(myLock));
95        }
96    }
97
98
99    class MockWriter extends Writer {
100        private char[] contents;
101
102        private int length;
103
104        private int offset;
105
106        MockWriter(int capacity) {
107            contents = new char[capacity];
108            length = capacity;
109            offset = 0;
110        }
111
112        public synchronized void close() throws IOException {
113            flush();
114            contents = null;
115        }
116
117        public synchronized void flush() throws IOException {
118            // do nothing
119        }
120
121        public void write(char[] buffer, int offset, int count)
122                throws IOException {
123            if (null == contents) {
124                throw new IOException();
125            }
126            if (offset < 0 || count < 0 || offset >= buffer.length) {
127                throw new IndexOutOfBoundsException();
128            }
129            count = Math.min(count, buffer.length - offset);
130            count = Math.min(count, this.length - this.offset);
131            for (int i = 0; i < count; i++) {
132                contents[this.offset + i] = buffer[offset + i];
133            }
134            this.offset += count;
135
136        }
137
138        public char[] getContents() {
139            char[] result = new char[offset];
140            for (int i = 0; i < offset; i++) {
141                result[i] = contents[i];
142            }
143            return result;
144        }
145    }
146
147}
148