1 package net.sf.ehcache.config;
2
3 import org.junit.Test;
4
5 import static org.hamcrest.CoreMatchers.equalTo;
6 import static org.hamcrest.CoreMatchers.is;
7 import static org.junit.Assert.assertThat;
8 import static org.junit.Assert.fail;
9
10 /***
11 * @author Alex Snaps
12 */
13 public class MemoryUnitTest {
14
15 @Test
16 public void testOneUnitConversions() {
17 assertThat(MemoryUnit.BYTES.toBytes(1), equalTo(1L));
18 assertThat(MemoryUnit.BYTES.toKiloBytes(1024), equalTo(1L));
19 assertThat(MemoryUnit.BYTES.toMegaBytes(1024 * 1024), equalTo(1L));
20 assertThat(MemoryUnit.BYTES.toGigaBytes(1024 * 1024 * 1024), equalTo(1L));
21
22 assertThat(MemoryUnit.KILOBYTES.toBytes(1), equalTo(1024L));
23 assertThat(MemoryUnit.KILOBYTES.toKiloBytes(1), equalTo(1L));
24 assertThat(MemoryUnit.KILOBYTES.toMegaBytes(1024), equalTo(1L));
25 assertThat(MemoryUnit.KILOBYTES.toGigaBytes(1024 * 1024), equalTo(1L));
26
27 assertThat(MemoryUnit.MEGABYTES.toBytes(1), equalTo((long) 1024 * 1024));
28 assertThat(MemoryUnit.MEGABYTES.toKiloBytes(1), equalTo((long) 1024) );
29 assertThat(MemoryUnit.MEGABYTES.toMegaBytes(1), equalTo(1L) );
30 assertThat(MemoryUnit.MEGABYTES.toGigaBytes(1024), equalTo(1L) );
31
32 assertThat(MemoryUnit.GIGABYTES.toBytes(1), equalTo((long) 1024 * 1024 * 1024));
33 assertThat(MemoryUnit.GIGABYTES.toKiloBytes(1), equalTo((long) 1024 * 1024));
34 assertThat(MemoryUnit.GIGABYTES.toMegaBytes(1), equalTo((long) 1024));
35 assertThat(MemoryUnit.GIGABYTES.toGigaBytes(1), equalTo(1L));
36 }
37
38 @Test
39 public void testZeroUnitConversion() {
40 assertThat(MemoryUnit.BYTES.toBytes(0), equalTo(0L));
41 assertThat(MemoryUnit.BYTES.toKiloBytes(0), equalTo(0L));
42 assertThat(MemoryUnit.BYTES.toMegaBytes(0), equalTo(0L));
43 assertThat(MemoryUnit.BYTES.toGigaBytes(0), equalTo(0L));
44 assertThat(MemoryUnit.BYTES.toKiloBytes(1), equalTo(0L));
45 assertThat(MemoryUnit.BYTES.toKiloBytes(512), equalTo(0L));
46 assertThat(MemoryUnit.BYTES.toKiloBytes(1023), equalTo(0L));
47 assertThat(MemoryUnit.BYTES.toMegaBytes(1024*512), equalTo(0L));
48 assertThat(MemoryUnit.BYTES.toGigaBytes(1024*1024*512), equalTo(0L));
49
50 assertThat(MemoryUnit.KILOBYTES.toBytes(0), equalTo(0L));
51 assertThat(MemoryUnit.KILOBYTES.toKiloBytes(0), equalTo(0L));
52 assertThat(MemoryUnit.KILOBYTES.toMegaBytes(0), equalTo(0L));
53 assertThat(MemoryUnit.KILOBYTES.toGigaBytes(0), equalTo(0L));
54 assertThat(MemoryUnit.KILOBYTES.toKiloBytes(512), equalTo(512L));
55 assertThat(MemoryUnit.KILOBYTES.toMegaBytes(1), equalTo(0L));
56 assertThat(MemoryUnit.KILOBYTES.toMegaBytes(512), equalTo(0L));
57 assertThat(MemoryUnit.KILOBYTES.toMegaBytes(1023), equalTo(0L));
58 assertThat(MemoryUnit.KILOBYTES.toGigaBytes(1024*512), equalTo(0L));
59
60 assertThat(MemoryUnit.MEGABYTES.toBytes(0), equalTo(0L));
61 assertThat(MemoryUnit.MEGABYTES.toKiloBytes(0), equalTo(0L));
62 assertThat(MemoryUnit.MEGABYTES.toMegaBytes(0), equalTo(0L) );
63 assertThat(MemoryUnit.MEGABYTES.toGigaBytes(0), equalTo(0L) );
64 assertThat(MemoryUnit.MEGABYTES.toMegaBytes(512), equalTo(512L) );
65 assertThat(MemoryUnit.MEGABYTES.toGigaBytes(1), equalTo(0L) );
66 assertThat(MemoryUnit.MEGABYTES.toGigaBytes(512), equalTo(0L) );
67 assertThat(MemoryUnit.MEGABYTES.toGigaBytes(1023), equalTo(0L) );
68
69 assertThat(MemoryUnit.GIGABYTES.toBytes(0), equalTo(0L));
70 assertThat(MemoryUnit.GIGABYTES.toKiloBytes(0), equalTo(0L));
71 assertThat(MemoryUnit.GIGABYTES.toMegaBytes(0), equalTo(0L));
72 assertThat(MemoryUnit.GIGABYTES.toGigaBytes(0), equalTo(0L));
73 }
74
75 @Test
76 public void testLargeConversion() {
77 assertThat(MemoryUnit.BYTES.toBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE));
78 assertThat(MemoryUnit.BYTES.toKiloBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE / 1024));
79 assertThat(MemoryUnit.BYTES.toMegaBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE / 1024 / 1024));
80 assertThat(MemoryUnit.BYTES.toGigaBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE / 1024 / 1024 / 1024));
81
82 assertThat(MemoryUnit.KILOBYTES.toBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE));
83 assertThat(MemoryUnit.KILOBYTES.toKiloBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE));
84 assertThat(MemoryUnit.KILOBYTES.toMegaBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE / 1024));
85 assertThat(MemoryUnit.KILOBYTES.toGigaBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE / 1024 / 1024));
86
87 assertThat(MemoryUnit.MEGABYTES.toBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE));
88 assertThat(MemoryUnit.MEGABYTES.toKiloBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE));
89 assertThat(MemoryUnit.MEGABYTES.toMegaBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE) );
90 assertThat(MemoryUnit.MEGABYTES.toGigaBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE / 1024) );
91
92 assertThat(MemoryUnit.GIGABYTES.toBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE));
93 assertThat(MemoryUnit.GIGABYTES.toKiloBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE));
94 assertThat(MemoryUnit.GIGABYTES.toMegaBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE));
95 assertThat(MemoryUnit.GIGABYTES.toGigaBytes(Long.MAX_VALUE), equalTo(Long.MAX_VALUE));
96 }
97
98 @Test
99 public void testParsing() {
100 assertThat(MemoryUnit.parseUnit("100"), is(MemoryUnit.BYTES));
101 assertThat(MemoryUnit.parseUnit("100b"), is(MemoryUnit.BYTES));
102 assertThat(MemoryUnit.parseUnit("100 B"), is(MemoryUnit.BYTES));
103 assertThat(MemoryUnit.parseUnit("100 k"), is(MemoryUnit.KILOBYTES));
104 assertThat(MemoryUnit.parseUnit("100K"), is(MemoryUnit.KILOBYTES));
105 assertThat(MemoryUnit.parseUnit("100M"), is(MemoryUnit.MEGABYTES));
106 assertThat(MemoryUnit.parseUnit("0G"), is(MemoryUnit.GIGABYTES));
107
108 assertThat(MemoryUnit.parseAmount("100"), is(100L));
109 assertThat(MemoryUnit.parseAmount("100B"), is(100L));
110 assertThat(MemoryUnit.parseAmount("0M"), is(0L));
111 assertThat(MemoryUnit.parseAmount(Long.MAX_VALUE + "k"), is(Long.MAX_VALUE));
112
113 assertThat(MemoryUnit.parseSizeInBytes("2M"), is((long) 2 * 1024 * 1024));
114 assertThat(MemoryUnit.parseSizeInBytes("0M"), is((long) 0));
115 assertThat(MemoryUnit.parseSizeInBytes("0G"), is((long) 0));
116 assertThat(MemoryUnit.parseSizeInBytes("24G"), is((long) 24 * 1024 * 1024 * 1024));
117 assertThat(MemoryUnit.parseSizeInBytes("24 G"), is((long) 24 * 1024 * 1024 * 1024));
118 assertThat(MemoryUnit.parseSizeInBytes(Long.MAX_VALUE + "k"), is(Long.MAX_VALUE));
119 }
120
121 @Test
122 public void testIllegalValues() {
123 try {
124 MemoryUnit.parseSizeInBytes("1.5G");
125 fail("This should have thrown an NumberFormatException");
126 } catch (NumberFormatException e) {
127
128 }
129
130 try {
131 MemoryUnit.parseSizeInBytes("15L");
132 fail("This should have thrown an IllegalArgumentException");
133 } catch (IllegalArgumentException e) {
134
135 }
136
137 try {
138 MemoryUnit.parseSizeInBytes("");
139 fail("This should have thrown an IllegalArgumentException");
140 } catch (IllegalArgumentException e) {
141
142 }
143
144 try {
145 MemoryUnit.parseSizeInBytes("G");
146 fail("This should have thrown an NumberFormatException");
147 } catch (NumberFormatException e) {
148
149 }
150
151 }
152
153 }