|
1
4 package com.tc.util;
5
6 import java.util.Arrays  ;
7
8 import junit.framework.TestCase;
9
10
18 public class ConversionTest extends TestCase {
19
20
25 public ConversionTest(String arg0) {
26 super(arg0);
27 }
28
29 static final byte[] MAX_UINT_BYTES = new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF };
30 static final byte[] ONE_UINT_BYTES = new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x01 };
31 static final byte[] ZERO_UINT_BYTES = new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00 };
32
33 public void testBits() {
34 byte flags = 0;
35
36 flags = Conversion.setFlag(flags, 1, true);
37 flags = Conversion.setFlag(flags, 2, false);
38 flags = Conversion.setFlag(flags, 4, true);
39 flags = Conversion.setFlag(flags, 8, false);
40 flags = Conversion.setFlag(flags, 16, true);
41
42 assertTrue(Conversion.getFlag(flags, 1));
43 assertFalse(Conversion.getFlag(flags, 2));
44 assertTrue(Conversion.getFlag(flags, 4));
45 assertFalse(Conversion.getFlag(flags, 8));
46 assertTrue(Conversion.getFlag(flags, 16));
47
48 flags = Conversion.setFlag(flags, 1, false);
49 flags = Conversion.setFlag(flags, 2, true);
50 flags = Conversion.setFlag(flags, 4, false);
51 flags = Conversion.setFlag(flags, 8, true);
52 flags = Conversion.setFlag(flags, 16, false);
53
54 assertFalse(Conversion.getFlag(flags, 1));
55 assertTrue(Conversion.getFlag(flags, 2));
56 assertFalse(Conversion.getFlag(flags, 4));
57 assertTrue(Conversion.getFlag(flags, 8));
58 assertFalse(Conversion.getFlag(flags, 16));
59
60 }
61
62 public void testuint2Bytes() {
63 byte[] bytes = Conversion.uint2bytes(Conversion.MAX_UINT);
64 long l = Conversion.bytes2uint(bytes, 0, 4);
65 assertTrue(l == Conversion.MAX_UINT);
66 assertTrue(Arrays.equals(MAX_UINT_BYTES, bytes));
67
68 bytes = Conversion.uint2bytes(1L);
69 l = Conversion.bytes2uint(bytes, 0, 4);
70 assertTrue(l == 1L);
71 assertTrue(Arrays.equals(ONE_UINT_BYTES, bytes));
72
73 bytes = Conversion.uint2bytes(0L);
74 l = Conversion.bytes2uint(bytes, 0, 4);
75 assertTrue(l == 0L);
76 assertTrue(Arrays.equals(ZERO_UINT_BYTES, bytes));
77
78 bytes = Conversion.uint2bytes(3427655L);
79 l = Conversion.bytes2uint(bytes, 0, 4);
80 assertTrue(l == 3427655L);
81 assertTrue(Arrays.equals(new byte[] { (byte) 0x00, (byte) 0x34, (byte) 0x4D, (byte) 0x47 }, bytes));
82
83 try {
84 Conversion.uint2bytes(Conversion.MAX_UINT + 1L);
85 assertTrue(false);
86 } catch (IllegalArgumentException e) {
87 }
89
90 try {
91 Conversion.uint2bytes(-1L);
92 assertTrue(false);
93 } catch (IllegalArgumentException e) {
94 }
96
97 }
98
99 public void testBytes2uint() {
100 long result = Conversion.bytes2uint(MAX_UINT_BYTES, 0, 4);
101 assertTrue(Conversion.MAX_UINT == result);
102
103 result = Conversion.bytes2uint(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFE }, 0, 4);
104 assertTrue((Conversion.MAX_UINT - 1L) == result);
105
106 result = Conversion.bytes2uint(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFE, (byte) 0xFF }, 0, 4);
107 assertTrue((Conversion.MAX_UINT - 256L) == result);
108
109 result = Conversion.bytes2uint(new byte[] { (byte) 0xFF, (byte) 0xFE, (byte) 0xFF, (byte) 0xFF }, 0, 4);
110 assertTrue((Conversion.MAX_UINT - 65536L) == result);
111
112 result = Conversion.bytes2uint(new byte[] { (byte) 0xFE, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }, 0, 4);
113 assertTrue((Conversion.MAX_UINT - 16777216L) == result);
114
115 result = Conversion.bytes2uint(ZERO_UINT_BYTES, 0, 4);
116 assertTrue(0L == result);
117
118 result = Conversion.bytes2uint(ONE_UINT_BYTES, 0, 4);
119 assertTrue(1L == result);
120
121 result = Conversion.bytes2uint(new byte[] { 1, 1, 1, 1 }, 0, 4);
122 assertTrue(16843009L == result);
123
124 result = Conversion.bytes2uint(new byte[] { (byte) 0xFF, (byte) 0xFF, 1, (byte) 0xFF, (byte) 0xFF }, 2, 1);
125 assertTrue(1L == result);
126 }
127
128 public void testByte2uint() {
129 int i = 128;
130
131 for (byte b = Byte.MIN_VALUE; b < 0; b++) {
132 int result = Conversion.byte2uint(b);
133 assertTrue(result == i);
134 i++;
135 }
136
137 i = 0;
138 for (byte b = 0; b < Byte.MAX_VALUE; b++) {
139 int result = Conversion.byte2uint(b);
140 assertTrue(result == i);
141 i++;
142 }
143
144 }
145
146 public void testBytes2String() {
147 String testString = "test string";
149 String convertedString;
150 byte[] bytes = Conversion.string2Bytes(testString);
151 convertedString = Conversion.bytes2String(bytes);
152 assertTrue(testString.equals(convertedString));
153 }
154
155 public void testString2Bytes() {
156 }
158
159 public void testBytes2Boolean() {
160 boolean testBoolean = true;
161 boolean convertedBoolean = false;
162
163 byte[] bytes = Conversion.boolean2Bytes(testBoolean);
164 convertedBoolean = Conversion.bytes2Boolean(bytes);
165 assertTrue(testBoolean == convertedBoolean);
166 }
167
168 public void testBoolean2Bytes() {
169 }
171
172 public void testByte2Bytes() {
173 byte testByte = 18;
174 byte[] convertedBytes = Conversion.byte2Bytes(testByte);
175 assertTrue(convertedBytes != null && convertedBytes.length == 1 && convertedBytes[0] == testByte);
176 }
177
178 public void testBytes2Char() {
179 char testChar = 'c';
180 byte[] convertedBytes = Conversion.char2Bytes(testChar);
181 assertTrue(testChar == Conversion.bytes2Char(convertedBytes));
182 }
183
184 public void testChar2Bytes() {
185 }
187
188 public void testBytes2Double() {
189 double[] testVals = new double[] { Double.MIN_VALUE, -1.1, 0, 1.1, Double.MAX_VALUE };
190
191 for (int i = 0; i < testVals.length; i++) {
192 byte[] convertedBytes = Conversion.double2Bytes(testVals[i]);
193 double convertedDouble = Conversion.bytes2Double(convertedBytes);
194 assertTrue(testVals[i] == convertedDouble);
195 }
196 }
197
198 public void testDouble2Bytes() {
199 }
201
202 public void testBytes2Float() {
203 float[] testVals = new float[] { Float.MIN_VALUE, -1.1f, 0, 1.1f, Float.MAX_VALUE };
204 for (int i = 0; i < testVals.length; i++) {
205 byte[] convertedBytes = Conversion.float2Bytes(testVals[i]);
206 assertTrue(testVals[i] == Conversion.bytes2Float(convertedBytes));
207 }
208 }
209
210 public void testFloat2Bytes() {
211 }
213
214 public void testBytes2Int() {
215 int[] testVals = new int[] { Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE };
216 for (int i = 0; i < testVals.length; i++) {
217 try {
218 byte[] convertedBytes = Conversion.int2Bytes(testVals[i]);
219 int convertedInt = Conversion.bytes2Int(convertedBytes);
220 assertEquals(testVals[i], convertedInt);
221 } catch (RuntimeException e) {
222 e.printStackTrace();
223 System.out.println("Failed to convert: " + testVals[i]);
224 fail("Failed to convert: " + testVals[i]);
225 }
226 }
227 }
228
229 public void testInt2Bytes() {
230 }
232
233 public void testBytes2Long() {
234 long[] testVals = new long[] { Long.MIN_VALUE, -1, 0, 1, Long.MAX_VALUE };
235 for (int i = 0; i < testVals.length; i++) {
236 byte[] convertedBytes = Conversion.long2Bytes(testVals[i]);
237 assertTrue(testVals[i] == Conversion.bytes2Long(convertedBytes));
238 }
239 }
240
241 public void testLong2Bytes() {
242 }
244
245 public void testBytes2Short() {
246 short[] testVals = new short[] { Short.MIN_VALUE, -1, 0, 1, Short.MIN_VALUE };
247 for (int i = 0; i < testVals.length; i++) {
248 byte[] convertedBytes = Conversion.short2Bytes(testVals[i]);
249 assertTrue(testVals[i] == Conversion.bytes2Short(convertedBytes));
250 }
251 }
252
253 public void testShort2Bytes() {
254 }
256
257 }
258 |
Popular Tags |
Java API By Example, From Geeks To Geeks.