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.jupiter.api.Test;
26  
27  import static org.junit.jupiter.api.Assertions.assertEquals;
28  import static org.junit.jupiter.api.Assertions.assertThrows;
29  
30  class FileSizeFormatTest {
31  
32      @Test
33      void testNegativeSize() {
34          FileSizeFormat format = new FileSizeFormat(Locale.ENGLISH);
35  
36          long negativeSize = -100L;
37          assertThrows(IllegalArgumentException.class, () -> format.format(negativeSize));
38      }
39  
40      @Test
41      void testSize() {
42          FileSizeFormat format = new FileSizeFormat(Locale.ENGLISH);
43  
44          long _0_bytes = 0L;
45          assertEquals("0 B", format.format(_0_bytes));
46  
47          long _5_bytes = 5L;
48          assertEquals("5 B", format.format(_5_bytes));
49  
50          long _10_bytes = 10L;
51          assertEquals("10 B", format.format(_10_bytes));
52  
53          long _15_bytes = 15L;
54          assertEquals("15 B", format.format(_15_bytes));
55  
56          long _999_bytes = 999L;
57          assertEquals("999 B", format.format(_999_bytes));
58  
59          long _1000_bytes = 1000L;
60          assertEquals("1.0 kB", format.format(_1000_bytes));
61  
62          long _5500_bytes = 5500L;
63          assertEquals("5.5 kB", format.format(_5500_bytes));
64  
65          long _10_kilobytes = 10L * 1000L;
66          assertEquals("10 kB", format.format(_10_kilobytes));
67  
68          long _15_kilobytes = 15L * 1000L;
69          assertEquals("15 kB", format.format(_15_kilobytes));
70  
71          long _999_kilobytes = 999L * 1000L;
72          assertEquals("999 kB", format.format(_999_kilobytes));
73  
74          long _1000_kilobytes = 1000L * 1000L;
75          assertEquals("1.0 MB", format.format(_1000_kilobytes));
76  
77          long _5500_kilobytes = 5500L * 1000L;
78          assertEquals("5.5 MB", format.format(_5500_kilobytes));
79  
80          long _10_megabytes = 10L * 1000L * 1000L;
81          assertEquals("10 MB", format.format(_10_megabytes));
82  
83          long _15_megabytes = 15L * 1000L * 1000L;
84          assertEquals("15 MB", format.format(_15_megabytes));
85  
86          long _999_megabytes = 999L * 1000L * 1000L;
87          assertEquals("999 MB", format.format(_999_megabytes));
88  
89          long _1000_megabytes = 1000L * 1000L * 1000L;
90          assertEquals("1.0 GB", format.format(_1000_megabytes));
91  
92          long _5500_megabytes = 5500L * 1000L * 1000L;
93          assertEquals("5.5 GB", format.format(_5500_megabytes));
94  
95          long _10_gigabytes = 10L * 1000L * 1000L * 1000L;
96          assertEquals("10 GB", format.format(_10_gigabytes));
97  
98          long _15_gigabytes = 15L * 1000L * 1000L * 1000L;
99          assertEquals("15 GB", format.format(_15_gigabytes));
100 
101         long _1000_gigabytes = 1000L * 1000L * 1000L * 1000L;
102         assertEquals("1000 GB", format.format(_1000_gigabytes));
103     }
104 
105     @Test
106     void testSizeWithSelectedScaleUnit() {
107         FileSizeFormat format = new FileSizeFormat(Locale.ENGLISH);
108 
109         long _0_bytes = 0L;
110         assertEquals("0 B", format.format(_0_bytes));
111         assertEquals("0 B", format.format(_0_bytes, ScaleUnit.BYTE));
112         assertEquals("0 kB", format.format(_0_bytes, ScaleUnit.KILOBYTE));
113         assertEquals("0 MB", format.format(_0_bytes, ScaleUnit.MEGABYTE));
114         assertEquals("0 GB", format.format(_0_bytes, ScaleUnit.GIGABYTE));
115 
116         long _5_bytes = 5L;
117         assertEquals("5 B", format.format(_5_bytes));
118         assertEquals("5 B", format.format(_5_bytes, ScaleUnit.BYTE));
119         assertEquals("0 kB", format.format(_5_bytes, ScaleUnit.KILOBYTE));
120         assertEquals("0 MB", format.format(_5_bytes, ScaleUnit.MEGABYTE));
121         assertEquals("0 GB", format.format(_5_bytes, ScaleUnit.GIGABYTE));
122 
123         long _49_bytes = 49L;
124         assertEquals("49 B", format.format(_49_bytes));
125         assertEquals("49 B", format.format(_49_bytes, ScaleUnit.BYTE));
126         assertEquals("0 kB", format.format(_49_bytes, ScaleUnit.KILOBYTE));
127         assertEquals("0 MB", format.format(_49_bytes, ScaleUnit.MEGABYTE));
128         assertEquals("0 GB", format.format(_49_bytes, ScaleUnit.GIGABYTE));
129 
130         long _50_bytes = 50L;
131         assertEquals("50 B", format.format(_50_bytes));
132         assertEquals("50 B", format.format(_50_bytes, ScaleUnit.BYTE));
133         assertEquals("0.1 kB", format.format(_50_bytes, ScaleUnit.KILOBYTE));
134         assertEquals("0 MB", format.format(_50_bytes, ScaleUnit.MEGABYTE));
135         assertEquals("0 GB", format.format(_50_bytes, ScaleUnit.GIGABYTE));
136 
137         long _999_bytes = 999L;
138         assertEquals("999 B", format.format(_999_bytes));
139         assertEquals("999 B", format.format(_999_bytes, ScaleUnit.BYTE));
140         assertEquals("1.0 kB", format.format(_999_bytes, ScaleUnit.KILOBYTE));
141         assertEquals("0 MB", format.format(_999_bytes, ScaleUnit.MEGABYTE));
142         assertEquals("0 GB", format.format(_999_bytes, ScaleUnit.GIGABYTE));
143 
144         long _1000_bytes = 1000L;
145         assertEquals("1.0 kB", format.format(_1000_bytes));
146         assertEquals("1000 B", format.format(_1000_bytes, ScaleUnit.BYTE));
147         assertEquals("1.0 kB", format.format(_1000_bytes, ScaleUnit.KILOBYTE));
148         assertEquals("0 MB", format.format(_1000_bytes, ScaleUnit.MEGABYTE));
149         assertEquals("0 GB", format.format(_1000_bytes, ScaleUnit.GIGABYTE));
150 
151         long _49_kilobytes = 49L * 1000L;
152         assertEquals("49 kB", format.format(_49_kilobytes));
153         assertEquals("49000 B", format.format(_49_kilobytes, ScaleUnit.BYTE));
154         assertEquals("49 kB", format.format(_49_kilobytes, ScaleUnit.KILOBYTE));
155         assertEquals("0 MB", format.format(_49_kilobytes, ScaleUnit.MEGABYTE));
156         assertEquals("0 GB", format.format(_49_kilobytes, ScaleUnit.GIGABYTE));
157 
158         long _50_kilobytes = 50L * 1000L;
159         assertEquals("50 kB", format.format(_50_kilobytes));
160         assertEquals("50000 B", format.format(_50_kilobytes, ScaleUnit.BYTE));
161         assertEquals("50 kB", format.format(_50_kilobytes, ScaleUnit.KILOBYTE));
162         assertEquals("0.1 MB", format.format(_50_kilobytes, ScaleUnit.MEGABYTE));
163         assertEquals("0 GB", format.format(_50_kilobytes, ScaleUnit.GIGABYTE));
164 
165         long _999_kilobytes = 999L * 1000L;
166         assertEquals("999 kB", format.format(_999_kilobytes));
167         assertEquals("999000 B", format.format(_999_kilobytes, ScaleUnit.BYTE));
168         assertEquals("999 kB", format.format(_999_kilobytes, ScaleUnit.KILOBYTE));
169         assertEquals("1.0 MB", format.format(_999_kilobytes, ScaleUnit.MEGABYTE));
170         assertEquals("0 GB", format.format(_999_kilobytes, ScaleUnit.GIGABYTE));
171 
172         long _1000_kilobytes = 1000L * 1000L;
173         assertEquals("1.0 MB", format.format(_1000_kilobytes));
174         assertEquals("1000000 B", format.format(_1000_kilobytes, ScaleUnit.BYTE));
175         assertEquals("1000 kB", format.format(_1000_kilobytes, ScaleUnit.KILOBYTE));
176         assertEquals("1.0 MB", format.format(_1000_kilobytes, ScaleUnit.MEGABYTE));
177         assertEquals("0 GB", format.format(_1000_kilobytes, ScaleUnit.GIGABYTE));
178 
179         long _49_megabytes = 49L * 1000L * 1000L;
180         assertEquals("49 MB", format.format(_49_megabytes));
181         assertEquals("49000000 B", format.format(_49_megabytes, ScaleUnit.BYTE));
182         assertEquals("49000 kB", format.format(_49_megabytes, ScaleUnit.KILOBYTE));
183         assertEquals("49 MB", format.format(_49_megabytes, ScaleUnit.MEGABYTE));
184         assertEquals("0 GB", format.format(_49_megabytes, ScaleUnit.GIGABYTE));
185 
186         long _50_megabytes = 50L * 1000L * 1000L;
187         assertEquals("50 MB", format.format(_50_megabytes));
188         assertEquals("50000000 B", format.format(_50_megabytes, ScaleUnit.BYTE));
189         assertEquals("50000 kB", format.format(_50_megabytes, ScaleUnit.KILOBYTE));
190         assertEquals("50 MB", format.format(_50_megabytes, ScaleUnit.MEGABYTE));
191         assertEquals("0.1 GB", format.format(_50_megabytes, ScaleUnit.GIGABYTE));
192 
193         long _999_megabytes = 999L * 1000L * 1000L;
194         assertEquals("999 MB", format.format(_999_megabytes));
195         assertEquals("999000000 B", format.format(_999_megabytes, ScaleUnit.BYTE));
196         assertEquals("999000 kB", format.format(_999_megabytes, ScaleUnit.KILOBYTE));
197         assertEquals("999 MB", format.format(_999_megabytes, ScaleUnit.MEGABYTE));
198         assertEquals("1.0 GB", format.format(_999_megabytes, ScaleUnit.GIGABYTE));
199 
200         long _1000_megabytes = 1000L * 1000L * 1000L;
201         assertEquals("1.0 GB", format.format(_1000_megabytes));
202         assertEquals("1000000000 B", format.format(_1000_megabytes, ScaleUnit.BYTE));
203         assertEquals("1000000 kB", format.format(_1000_megabytes, ScaleUnit.KILOBYTE));
204         assertEquals("1000 MB", format.format(_1000_megabytes, ScaleUnit.MEGABYTE));
205         assertEquals("1.0 GB", format.format(_1000_megabytes, ScaleUnit.GIGABYTE));
206     }
207 
208     @Test
209     void testNegativeProgressedSize() {
210         FileSizeFormat format = new FileSizeFormat(Locale.ENGLISH);
211 
212         long negativeProgressedSize = -100L;
213         assertThrows(IllegalArgumentException.class, () -> format.formatProgress(negativeProgressedSize, 10L));
214     }
215 
216     @Test
217     void testNegativeProgressedSizeBiggerThanSize() {
218         FileSizeFormat format = new FileSizeFormat(Locale.ENGLISH);
219 
220         assertThrows(IllegalArgumentException.class, () -> format.formatProgress(100L, 10L));
221     }
222 
223     @Test
224     void testProgressedSizeWithoutSize() {
225         FileSizeFormat format = new FileSizeFormat(Locale.ENGLISH);
226 
227         long _0_bytes = 0L;
228         assertEquals("0 B", format.formatProgress(_0_bytes, -1L));
229 
230         long _1000_bytes = 1000L;
231         assertEquals("1.0 kB", format.formatProgress(_1000_bytes, -1L));
232 
233         long _1000_kilobytes = 1000L * 1000L;
234         assertEquals("1.0 MB", format.formatProgress(_1000_kilobytes, -1L));
235 
236         long _1000_megabytes = 1000L * 1000L * 1000L;
237         assertEquals("1.0 GB", format.formatProgress(_1000_megabytes, -1L));
238     }
239 
240     @Test
241     void testProgressedBothZero() {
242         FileSizeFormat format = new FileSizeFormat(Locale.ENGLISH);
243 
244         long _0_bytes = 0L;
245         assertEquals("0 B", format.formatProgress(_0_bytes, _0_bytes));
246     }
247 
248     @Test
249     void testProgressedSizeWithSize() {
250         FileSizeFormat format = new FileSizeFormat(Locale.ENGLISH);
251 
252         long _0_bytes = 0L;
253         long _400_bytes = 400L;
254         long _800_bytes = 2L * _400_bytes;
255         assertEquals("0/800 B", format.formatProgress(_0_bytes, _800_bytes));
256         assertEquals("400/800 B", format.formatProgress(_400_bytes, _800_bytes));
257         assertEquals("800 B", format.formatProgress(_800_bytes, _800_bytes));
258 
259         long _4000_bytes = 4000L;
260         long _8000_bytes = 2L * _4000_bytes;
261         long _50_kilobytes = 50000L;
262         assertEquals("0/8.0 kB", format.formatProgress(_0_bytes, _8000_bytes));
263         assertEquals("0.4/8.0 kB", format.formatProgress(_400_bytes, _8000_bytes));
264         assertEquals("4.0/8.0 kB", format.formatProgress(_4000_bytes, _8000_bytes));
265         assertEquals("8.0 kB", format.formatProgress(_8000_bytes, _8000_bytes));
266         assertEquals("8.0/50 kB", format.formatProgress(_8000_bytes, _50_kilobytes));
267         assertEquals("16/50 kB", format.formatProgress(2L * _8000_bytes, _50_kilobytes));
268         assertEquals("50 kB", format.formatProgress(_50_kilobytes, _50_kilobytes));
269 
270         long _500_kilobytes = 500000L;
271         long _1000_kilobytes = 2L * _500_kilobytes;
272         ;
273         long _5000_kilobytes = 5L * _1000_kilobytes;
274         long _15_megabytes = 3L * _5000_kilobytes;
275         assertEquals("0/5.0 MB", format.formatProgress(_0_bytes, _5000_kilobytes));
276         assertEquals("0.5/5.0 MB", format.formatProgress(_500_kilobytes, _5000_kilobytes));
277         assertEquals("1.0/5.0 MB", format.formatProgress(_1000_kilobytes, _5000_kilobytes));
278         assertEquals("5.0 MB", format.formatProgress(_5000_kilobytes, _5000_kilobytes));
279         assertEquals("5.0/15 MB", format.formatProgress(_5000_kilobytes, _15_megabytes));
280         assertEquals("15 MB", format.formatProgress(_15_megabytes, _15_megabytes));
281 
282         long _500_megabytes = 500000000L;
283         long _1000_megabytes = 2L * _500_megabytes;
284         long _5000_megabytes = 5L * _1000_megabytes;
285         long _15_gigabytes = 3L * _5000_megabytes;
286         assertEquals("0/500 MB", format.formatProgress(_0_bytes, _500_megabytes));
287         assertEquals("1.0/5.0 GB", format.formatProgress(_1000_megabytes, _5000_megabytes));
288         assertEquals("5.0 GB", format.formatProgress(_5000_megabytes, _5000_megabytes));
289         assertEquals("5.0/15 GB", format.formatProgress(_5000_megabytes, _15_gigabytes));
290         assertEquals("15 GB", format.formatProgress(_15_gigabytes, _15_gigabytes));
291     }
292 }