View Javadoc
1   package org.apache.maven.cli.transfer;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.util.Locale;
23  
24  import org.apache.commons.lang3.JavaVersion;
25  import org.apache.commons.lang3.SystemUtils;
26  import org.apache.maven.cli.transfer.AbstractMavenTransferListener.FileSizeFormat;
27  import org.apache.maven.cli.transfer.AbstractMavenTransferListener.FileSizeFormat.ScaleUnit;
28  
29  import static org.junit.Assert.assertEquals;
30  import org.junit.Test;
31  
32  public class FileSizeFormatTest {
33  
34      @Test( expected = IllegalArgumentException.class )
35      public void testNegativeSize()
36      {
37          FileSizeFormat format = new FileSizeFormat( Locale.ENGLISH );
38  
39          long negativeSize = -100L;
40          format.format( negativeSize );
41      }
42  
43      @Test
44      public void testSize()
45      {
46          FileSizeFormat format = new FileSizeFormat( Locale.ENGLISH );
47  
48          long _0_bytes = 0L;
49          assertEquals( "0 B", format.format( _0_bytes ) );
50  
51          long _5_bytes = 5L;
52          assertEquals( "5 B", format.format( _5_bytes ) );
53  
54          long _10_bytes = 10L;
55          assertEquals( "10 B", format.format( _10_bytes ) );
56  
57          long _15_bytes = 15L;
58          assertEquals( "15 B", format.format( _15_bytes ) );
59  
60          long _999_bytes = 999L;
61          assertEquals( "999 B", format.format( _999_bytes ) );
62  
63          long _1000_bytes = 1000L;
64          assertEquals( "1.0 kB", format.format( _1000_bytes ) );
65  
66          long _5500_bytes = 5500L;
67          assertEquals( "5.5 kB", format.format( _5500_bytes ) );
68  
69          long _10_kilobytes = 10L * 1000L;
70          assertEquals( "10 kB", format.format( _10_kilobytes ) );
71  
72          long _15_kilobytes = 15L * 1000L;
73          assertEquals( "15 kB", format.format( _15_kilobytes ) );
74  
75          long _999_kilobytes = 999L * 1000L;
76          assertEquals( "999 kB", format.format( _999_kilobytes ) );
77  
78          long _1000_kilobytes = 1000L * 1000L;
79          assertEquals( "1.0 MB", format.format( _1000_kilobytes ) );
80  
81          long _5500_kilobytes = 5500L * 1000L;
82          assertEquals( "5.5 MB", format.format( _5500_kilobytes ) );
83  
84          long _10_megabytes = 10L * 1000L * 1000L;
85          assertEquals( "10 MB", format.format( _10_megabytes ) );
86  
87          long _15_megabytes = 15L * 1000L * 1000L;
88          assertEquals( "15 MB", format.format( _15_megabytes ) );
89  
90          long _999_megabytes = 999L * 1000L * 1000L;
91          assertEquals( "999 MB", format.format( _999_megabytes ) );
92  
93          long _1000_megabytes = 1000L * 1000L * 1000L;
94          assertEquals( "1.0 GB", format.format( _1000_megabytes ) );
95  
96          long _5500_megabytes = 5500L * 1000L * 1000L;
97          assertEquals( "5.5 GB", format.format( _5500_megabytes ) );
98  
99          long _10_gigabytes = 10L * 1000L * 1000L * 1000L;
100         assertEquals( "10 GB", format.format( _10_gigabytes ) );
101 
102         long _15_gigabytes = 15L * 1000L * 1000L * 1000L;
103         assertEquals( "15 GB", format.format( _15_gigabytes ) );
104 
105         long _1000_gigabytes = 1000L * 1000L * 1000L * 1000L;
106         assertEquals( "1000 GB", format.format( _1000_gigabytes ) );
107     }
108 
109     @Test
110     public void testSizeWithSelectedScaleUnit()
111     {
112         FileSizeFormat format = new FileSizeFormat( Locale.ENGLISH );
113 
114         long _0_bytes = 0L;
115         assertEquals( "0 B", format.format( _0_bytes ) );
116         assertEquals( "0 B", format.format( _0_bytes, ScaleUnit.BYTE ) );
117         assertEquals( "0 kB", format.format( _0_bytes, ScaleUnit.KILOBYTE ) );
118         assertEquals( "0 MB", format.format( _0_bytes, ScaleUnit.MEGABYTE ) );
119         assertEquals( "0 GB", format.format( _0_bytes, ScaleUnit.GIGABYTE ) );
120 
121         long _5_bytes = 5L;
122         assertEquals( "5 B", format.format( _5_bytes ) );
123         assertEquals( "5 B", format.format( _5_bytes, ScaleUnit.BYTE ) );
124         assertEquals( "0 kB", format.format( _5_bytes, ScaleUnit.KILOBYTE ) );
125         assertEquals( "0 MB", format.format( _5_bytes, ScaleUnit.MEGABYTE ) );
126         assertEquals( "0 GB", format.format( _5_bytes, ScaleUnit.GIGABYTE ) );
127 
128 
129         long _49_bytes = 49L;
130         assertEquals( "49 B", format.format( _49_bytes ) );
131         assertEquals( "49 B", format.format( _49_bytes, ScaleUnit.BYTE ) );
132         assertEquals( "0 kB", format.format( _49_bytes, ScaleUnit.KILOBYTE ) );
133         assertEquals( "0 MB", format.format( _49_bytes, ScaleUnit.MEGABYTE ) );
134         assertEquals( "0 GB", format.format( _49_bytes, ScaleUnit.GIGABYTE ) );
135 
136         long _50_bytes = 50L;
137         assertEquals( "50 B", format.format( _50_bytes ) );
138         assertEquals( "50 B", format.format( _50_bytes, ScaleUnit.BYTE ) );
139         if ( SystemUtils.isJavaVersionAtLeast( JavaVersion.JAVA_1_8 ) )
140         {
141             assertEquals( "0.1 kB", format.format( _50_bytes, ScaleUnit.KILOBYTE ) );
142         }
143         assertEquals( "0 MB", format.format( _50_bytes, ScaleUnit.MEGABYTE ) );
144         assertEquals( "0 GB", format.format( _50_bytes, ScaleUnit.GIGABYTE ) );
145 
146         long _999_bytes = 999L;
147         assertEquals( "999 B", format.format( _999_bytes ) );
148         assertEquals( "999 B", format.format( _999_bytes, ScaleUnit.BYTE ) );
149         assertEquals( "1.0 kB", format.format( _999_bytes, ScaleUnit.KILOBYTE ) );
150         assertEquals( "0 MB", format.format( _999_bytes, ScaleUnit.MEGABYTE ) );
151         assertEquals( "0 GB", format.format( _999_bytes, ScaleUnit.GIGABYTE ) );
152 
153         long _1000_bytes = 1000L;
154         assertEquals( "1.0 kB", format.format( _1000_bytes ) );
155         assertEquals( "1000 B", format.format( _1000_bytes, ScaleUnit.BYTE ) );
156         assertEquals( "1.0 kB", format.format( _1000_bytes, ScaleUnit.KILOBYTE ) );
157         assertEquals( "0 MB", format.format( _1000_bytes, ScaleUnit.MEGABYTE ) );
158         assertEquals( "0 GB", format.format( _1000_bytes, ScaleUnit.GIGABYTE ) );
159 
160         long _49_kilobytes = 49L * 1000L;
161         assertEquals( "49 kB", format.format( _49_kilobytes ) );
162         assertEquals( "49000 B", format.format( _49_kilobytes, ScaleUnit.BYTE ) );
163         assertEquals( "49 kB", format.format( _49_kilobytes, ScaleUnit.KILOBYTE ) );
164         assertEquals( "0 MB", format.format( _49_kilobytes, ScaleUnit.MEGABYTE ) );
165         assertEquals( "0 GB", format.format( _49_kilobytes, ScaleUnit.GIGABYTE ) );
166 
167         long _50_kilobytes = 50L * 1000L;
168         assertEquals( "50 kB", format.format( _50_kilobytes ) );
169         assertEquals( "50000 B", format.format( _50_kilobytes, ScaleUnit.BYTE ) );
170         assertEquals( "50 kB", format.format( _50_kilobytes, ScaleUnit.KILOBYTE ) );
171         if ( SystemUtils.isJavaVersionAtLeast( JavaVersion.JAVA_1_8 ) )
172         {
173             assertEquals( "0.1 MB", format.format( _50_kilobytes, ScaleUnit.MEGABYTE ) );
174         }
175         assertEquals( "0 GB", format.format( _50_kilobytes, ScaleUnit.GIGABYTE ) );
176 
177         long _999_kilobytes = 999L * 1000L;
178         assertEquals( "999 kB", format.format( _999_kilobytes ) );
179         assertEquals( "999000 B", format.format( _999_kilobytes, ScaleUnit.BYTE ) );
180         assertEquals( "999 kB", format.format( _999_kilobytes, ScaleUnit.KILOBYTE ) );
181         assertEquals( "1.0 MB", format.format( _999_kilobytes, ScaleUnit.MEGABYTE ) );
182         assertEquals( "0 GB", format.format( _999_kilobytes, ScaleUnit.GIGABYTE ) );
183 
184         long _1000_kilobytes = 1000L * 1000L;
185         assertEquals( "1.0 MB", format.format( _1000_kilobytes ) );
186         assertEquals( "1000000 B", format.format( _1000_kilobytes, ScaleUnit.BYTE ) );
187         assertEquals( "1000 kB", format.format( _1000_kilobytes, ScaleUnit.KILOBYTE ) );
188         assertEquals( "1.0 MB", format.format( _1000_kilobytes, ScaleUnit.MEGABYTE ) );
189         assertEquals( "0 GB", format.format( _1000_kilobytes, ScaleUnit.GIGABYTE ) );
190 
191         long _49_megabytes = 49L * 1000L * 1000L;
192         assertEquals( "49 MB", format.format( _49_megabytes ) );
193         assertEquals( "49000000 B", format.format( _49_megabytes, ScaleUnit.BYTE ) );
194         assertEquals( "49000 kB", format.format( _49_megabytes, ScaleUnit.KILOBYTE ) );
195         assertEquals( "49 MB", format.format( _49_megabytes, ScaleUnit.MEGABYTE ) );
196         assertEquals( "0 GB", format.format( _49_megabytes, ScaleUnit.GIGABYTE ) );
197 
198         long _50_megabytes = 50L * 1000L * 1000L;
199         assertEquals( "50 MB", format.format( _50_megabytes ) );
200         assertEquals( "50000000 B", format.format( _50_megabytes, ScaleUnit.BYTE ) );
201         assertEquals( "50000 kB", format.format( _50_megabytes, ScaleUnit.KILOBYTE ) );
202         assertEquals( "50 MB", format.format( _50_megabytes, ScaleUnit.MEGABYTE ) );
203         if ( SystemUtils.isJavaVersionAtLeast( JavaVersion.JAVA_1_8 ) )
204         {
205             assertEquals( "0.1 GB", format.format( _50_megabytes, ScaleUnit.GIGABYTE ) );
206         }
207 
208         long _999_megabytes = 999L * 1000L * 1000L;
209         assertEquals( "999 MB", format.format( _999_megabytes ) );
210         assertEquals( "999000000 B", format.format( _999_megabytes, ScaleUnit.BYTE ) );
211         assertEquals( "999000 kB", format.format( _999_megabytes, ScaleUnit.KILOBYTE ) );
212         assertEquals( "999 MB", format.format( _999_megabytes, ScaleUnit.MEGABYTE ) );
213         assertEquals( "1.0 GB", format.format( _999_megabytes, ScaleUnit.GIGABYTE ) );
214 
215         long _1000_megabytes = 1000L * 1000L * 1000L;
216         assertEquals( "1.0 GB", format.format( _1000_megabytes ) );
217         assertEquals( "1000000000 B", format.format( _1000_megabytes, ScaleUnit.BYTE ) );
218         assertEquals( "1000000 kB", format.format( _1000_megabytes, ScaleUnit.KILOBYTE ) );
219         assertEquals( "1000 MB", format.format( _1000_megabytes, ScaleUnit.MEGABYTE ) );
220         assertEquals( "1.0 GB", format.format( _1000_megabytes, ScaleUnit.GIGABYTE ) );
221     }
222 
223     @Test( expected = IllegalArgumentException.class )
224     public void testNegativeProgressedSize()
225     {
226         FileSizeFormat format = new FileSizeFormat( Locale.ENGLISH );
227 
228         long negativeProgressedSize = -100L;
229         format.formatProgress( negativeProgressedSize, 10L );
230     }
231 
232     @Test( expected = IllegalArgumentException.class )
233     public void testNegativeProgressedSizeBiggerThanSize()
234     {
235         FileSizeFormat format = new FileSizeFormat( Locale.ENGLISH );
236 
237         format.formatProgress( 100L, 10L );
238     }
239 
240     @Test
241     public void testProgressedSizeWithoutSize()
242     {
243          FileSizeFormat format = new FileSizeFormat( Locale.ENGLISH );
244 
245          long _0_bytes = 0L;
246          assertEquals( "0 B", format.formatProgress( _0_bytes, -1L ) );
247 
248          long _1000_bytes = 1000L;
249          assertEquals( "1.0 kB", format.formatProgress( _1000_bytes, -1L ) );
250 
251          long _1000_kilobytes = 1000L * 1000L;
252          assertEquals( "1.0 MB", format.formatProgress( _1000_kilobytes, -1L ) );
253 
254          long _1000_megabytes = 1000L * 1000L * 1000L;
255          assertEquals( "1.0 GB", format.formatProgress( _1000_megabytes, -1L ) );
256 
257     }
258 
259     @Test
260     public void testProgressedBothZero()
261     {
262          FileSizeFormat format = new FileSizeFormat( Locale.ENGLISH );
263 
264          long _0_bytes = 0L;
265          assertEquals( "0 B", format.formatProgress( _0_bytes, _0_bytes ) );
266     }
267 
268     @Test
269     public void testProgressedSizeWithSize()
270     {
271          FileSizeFormat format = new FileSizeFormat( Locale.ENGLISH );
272 
273          long _0_bytes = 0L;
274          long _400_bytes = 400L;
275          long _800_bytes = 2L * _400_bytes;
276          assertEquals( "0/800 B", format.formatProgress( _0_bytes, _800_bytes ) );
277          assertEquals( "400/800 B", format.formatProgress( _400_bytes, _800_bytes ) );
278          assertEquals( "800 B", format.formatProgress( _800_bytes, _800_bytes ) );
279 
280          long _4000_bytes = 4000L;
281          long _8000_bytes = 2L * _4000_bytes;
282          long _50_kilobytes = 50000L;
283          assertEquals( "0/8.0 kB", format.formatProgress( _0_bytes, _8000_bytes ) );
284          assertEquals( "0.4/8.0 kB", format.formatProgress( _400_bytes, _8000_bytes ) );
285          assertEquals( "4.0/8.0 kB", format.formatProgress( _4000_bytes, _8000_bytes ) );
286          assertEquals( "8.0 kB", format.formatProgress( _8000_bytes, _8000_bytes ) );
287          assertEquals( "8.0/50 kB", format.formatProgress( _8000_bytes, _50_kilobytes ) );
288          assertEquals( "16/50 kB", format.formatProgress( 2L * _8000_bytes, _50_kilobytes ) );
289          assertEquals( "50 kB", format.formatProgress( _50_kilobytes, _50_kilobytes ) );
290 
291          long _500_kilobytes = 500000L;
292          long _1000_kilobytes = 2L * _500_kilobytes;;
293          long _5000_kilobytes = 5L * _1000_kilobytes;
294          long _15_megabytes = 3L * _5000_kilobytes;
295          assertEquals( "0/5.0 MB", format.formatProgress( _0_bytes, _5000_kilobytes ) );
296          assertEquals( "0.5/5.0 MB", format.formatProgress( _500_kilobytes, _5000_kilobytes ) );
297          assertEquals( "1.0/5.0 MB", format.formatProgress( _1000_kilobytes, _5000_kilobytes ) );
298          assertEquals( "5.0 MB", format.formatProgress( _5000_kilobytes, _5000_kilobytes ) );
299          assertEquals( "5.0/15 MB", format.formatProgress( _5000_kilobytes, _15_megabytes ) );
300          assertEquals( "15 MB", format.formatProgress( _15_megabytes, _15_megabytes ) );
301 
302          long _500_megabytes = 500000000L;
303          long _1000_megabytes = 2L * _500_megabytes;
304          long _5000_megabytes = 5L * _1000_megabytes;
305          long _15_gigabytes = 3L * _5000_megabytes;
306          assertEquals( "0/500 MB", format.formatProgress( _0_bytes, _500_megabytes ) );
307          assertEquals( "1.0/5.0 GB", format.formatProgress( _1000_megabytes, _5000_megabytes ) );
308          assertEquals( "5.0 GB", format.formatProgress( _5000_megabytes, _5000_megabytes ) );
309          assertEquals( "5.0/15 GB", format.formatProgress( _5000_megabytes, _15_gigabytes ) );
310          assertEquals( "15 GB", format.formatProgress( _15_gigabytes, _15_gigabytes ) );
311     }
312 
313 }