View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *   http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.net.util;
19  
20  import java.io.ByteArrayInputStream;
21  import java.io.ByteArrayOutputStream;
22  import java.io.CharArrayReader;
23  import java.io.CharArrayWriter;
24  import java.io.Closeable;
25  import java.io.InputStream;
26  import java.io.OutputStream;
27  import java.io.Reader;
28  import java.io.Writer;
29  import java.net.Socket;
30  
31  import org.apache.commons.net.io.CopyStreamEvent;
32  import org.apache.commons.net.io.CopyStreamListener;
33  import org.apache.commons.net.io.Util;
34  import org.junit.Assert;
35  import org.junit.Test;
36  
37  public class UtilTest {
38  
39      static class CSL implements CopyStreamListener {
40  
41          final long expectedTotal;
42          final int expectedBytes;
43          final long expectedSize;
44  
45          CSL(final long totalBytesTransferred, final int bytesTransferred, final long streamSize) {
46              this.expectedTotal = totalBytesTransferred;
47              this.expectedBytes = bytesTransferred;
48              this.expectedSize = streamSize;
49          }
50  
51          @Override
52          public void bytesTransferred(final CopyStreamEvent event) {
53          }
54  
55          @Override
56          public void bytesTransferred(final long totalBytesTransferred, final int bytesTransferred, final long streamSize) {
57              Assert.assertEquals("Wrong total", expectedTotal, totalBytesTransferred);
58              Assert.assertEquals("Wrong streamSize", expectedSize, streamSize);
59              Assert.assertEquals("Wrong bytes", expectedBytes, bytesTransferred);
60          }
61  
62      }
63  
64      // Class to check overall counts as well as batch size
65      static class CSLtotal implements CopyStreamListener {
66  
67          final long expectedTotal;
68          final long expectedBytes;
69          volatile long totalBytesTransferredTotal;
70          volatile long bytesTransferredTotal;
71  
72          CSLtotal(final long totalBytesTransferred, final long bytesTransferred) {
73              this.expectedTotal = totalBytesTransferred;
74              this.expectedBytes = bytesTransferred;
75          }
76  
77          @Override
78          public void bytesTransferred(final CopyStreamEvent event) {
79          }
80  
81          @Override
82          public void bytesTransferred(final long totalBytesTransferred, final int bytesTransferred, final long streamSize) {
83              Assert.assertEquals("Wrong bytes", expectedBytes, bytesTransferred);
84              this.totalBytesTransferredTotal = totalBytesTransferred;
85              this.bytesTransferredTotal += bytesTransferred;
86          }
87  
88          void checkExpected() {
89              Assert.assertEquals("Wrong totalBytesTransferred total", expectedTotal, totalBytesTransferredTotal);
90              Assert.assertEquals("Total should equal sum of parts", totalBytesTransferredTotal, bytesTransferredTotal);
91          }
92  
93      }
94  
95      private final Writer dest = new CharArrayWriter();
96      private final Reader source = new CharArrayReader(new char[] { 'a' });
97  
98      private final InputStream src = new ByteArrayInputStream(new byte[] { 'z' });
99  
100     private final OutputStream dst = new ByteArrayOutputStream();
101 
102     @Test
103     public void testcloseQuietly() {
104         Util.closeQuietly((Closeable) null);
105         Util.closeQuietly((Socket) null);
106     }
107 
108     @Test
109     public void testNET550_Reader() throws Exception {
110         final char[] buff = { 'a', 'b', 'c', 'd' }; // must be multiple of 2
111         final int bufflen = buff.length;
112         { // Check buffer size 1 processes in chunks of 1
113             final Reader rdr = new CharArrayReader(buff);
114             final CSLtotal listener = new CSLtotal(bufflen, 1);
115             Util.copyReader(rdr, dest, 1, 0, listener); // buffer size 1
116             listener.checkExpected();
117         }
118         { // Check bufsize 2 uses chunks of 2
119             final Reader rdr = new CharArrayReader(buff);
120             final CSLtotal listener = new CSLtotal(bufflen, 2);
121             Util.copyReader(rdr, dest, 2, 0, listener); // buffer size 2
122             listener.checkExpected();
123         }
124         { // Check bigger size reads the lot
125             final Reader rdr = new CharArrayReader(buff);
126             final CSLtotal listener = new CSLtotal(bufflen, bufflen);
127             Util.copyReader(rdr, dest, 20, 0, listener); // buffer size 20
128             listener.checkExpected();
129         }
130         { // Check negative size reads reads full amount
131             final Reader rdr = new CharArrayReader(buff);
132             final CSLtotal listener = new CSLtotal(bufflen, bufflen);
133             Util.copyReader(rdr, dest, -1, 0, listener); // buffer size -1
134             listener.checkExpected();
135         }
136         { // Check zero size reads reads full amount
137             final Reader rdr = new CharArrayReader(buff);
138             final CSLtotal listener = new CSLtotal(bufflen, bufflen);
139             Util.copyReader(rdr, dest, 0, 0, listener); // buffer size -1
140             listener.checkExpected();
141         }
142     }
143 
144     @Test
145     public void testNET550_Stream() throws Exception {
146         final byte[] buff = { 'a', 'b', 'c', 'd' }; // must be multiple of 2
147         final int bufflen = buff.length;
148         { // Check buffer size 1 processes in chunks of 1
149             final InputStream is = new ByteArrayInputStream(buff);
150             final CSLtotal listener = new CSLtotal(bufflen, 1);
151             Util.copyStream(is, dst, 1, 0, listener); // buffer size 1
152             listener.checkExpected();
153         }
154         { // Check bufsize 2 uses chunks of 2
155             final InputStream is = new ByteArrayInputStream(buff);
156             final CSLtotal listener = new CSLtotal(bufflen, 2);
157             Util.copyStream(is, dst, 2, 0, listener); // buffer size 2
158             listener.checkExpected();
159         }
160         { // Check bigger size reads the lot
161             final InputStream is = new ByteArrayInputStream(buff);
162             final CSLtotal listener = new CSLtotal(bufflen, bufflen);
163             Util.copyStream(is, dst, 20, 0, listener); // buffer size 20
164             listener.checkExpected();
165         }
166         { // Check negative size reads reads full amount
167             final InputStream is = new ByteArrayInputStream(buff);
168             final CSLtotal listener = new CSLtotal(bufflen, bufflen);
169             Util.copyStream(is, dst, -1, 0, listener); // buffer size -1
170             listener.checkExpected();
171         }
172         { // Check zero size reads reads full amount
173             final InputStream is = new ByteArrayInputStream(buff);
174             final CSLtotal listener = new CSLtotal(bufflen, bufflen);
175             Util.copyStream(is, dst, 0, 0, listener); // buffer size -1
176             listener.checkExpected();
177         }
178     }
179 
180     @Test
181     public void testReader_1() throws Exception {
182         final long streamSize = 0;
183         final int bufferSize = -1;
184         Util.copyReader(source, dest, bufferSize, streamSize, new CSL(1, 1, streamSize));
185     }
186 
187     @Test
188     public void testReader0() throws Exception {
189         final long streamSize = 0;
190         final int bufferSize = 0;
191         Util.copyReader(source, dest, bufferSize, streamSize, new CSL(1, 1, streamSize));
192     }
193 
194     @Test
195     public void testReader1() throws Exception {
196         final long streamSize = 0;
197         final int bufferSize = 1;
198         Util.copyReader(source, dest, bufferSize, streamSize, new CSL(1, 1, streamSize));
199     }
200 
201     @Test
202     public void testStream_1() throws Exception {
203         final long streamSize = 0;
204         final int bufferSize = -1;
205         Util.copyStream(src, dst, bufferSize, streamSize, new CSL(1, 1, streamSize));
206     }
207 
208     @Test
209     public void testStream0() throws Exception {
210         final long streamSize = 0;
211         final int bufferSize = 0;
212         Util.copyStream(src, dst, bufferSize, streamSize, new CSL(1, 1, streamSize));
213     }
214 
215     @Test
216     public void testStream1() throws Exception {
217         final long streamSize = 0;
218         final int bufferSize = 1;
219         Util.copyStream(src, dst, bufferSize, streamSize, new CSL(1, 1, streamSize));
220     }
221 }