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