1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 package net.sf.bluecove;
26
27 import java.io.IOException;
28
29 import org.bluecove.tester.log.Logger;
30 import org.bluecove.tester.util.IOUtils;
31
32 import junit.framework.Assert;
33 import net.sf.bluecove.tests.L2TrafficGenerator;
34
35
36
37
38 public class CommunicationTesterL2CAP extends CommunicationData {
39
40 public static final int INITIAL_DATA_PREFIX_LEN = 2;
41
42 public static byte[] startPrefix(int testType, byte[] data) {
43 byte[] dataToSend = new byte[data.length + INITIAL_DATA_PREFIX_LEN];
44 dataToSend[0] = Consts.SEND_TEST_START;
45 dataToSend[1] = (byte) testType;
46 System.arraycopy(data, 0, dataToSend, INITIAL_DATA_PREFIX_LEN, data.length);
47 Logger.debug("send L2CAP packet", dataToSend);
48 return dataToSend;
49 }
50
51 public static void runTest(int testType, boolean server, ConnectionHolderL2CAP c, byte[] initialData,
52 TestStatus testStatus) throws IOException {
53 switch (testType) {
54 case 1:
55 testStatus.setName("l2byteAray");
56 if (!server) {
57 c.channel.send(startPrefix(testType, byteAray));
58 } else {
59 Assert.assertEquals("byteAray.len", byteAray.length, initialData.length);
60 for (int i = 0; i < byteAray.length; i++) {
61 Assert.assertEquals("byte[" + i + "]", byteAray[i], initialData[i]);
62 }
63 }
64 break;
65 case 2:
66 testStatus.setName("l2sequence");
67 if (server) {
68 sequenceRecive(c, initialData);
69 } else {
70 sequenceSend(testType, c);
71 }
72 break;
73 case 3:
74 testStatus.setName("l2maxMTU");
75 if (server) {
76 maxMTURecive(c, initialData);
77 } else {
78 maxMTUSend(testType, c);
79 }
80 break;
81 case TRAFFIC_GENERATOR_WRITE:
82 testStatus.setName("l2genW");
83 if (server) {
84 L2TrafficGenerator.trafficGeneratorStatusReadStart(c, testStatus);
85 L2TrafficGenerator.trafficGeneratorWrite(c, initialData, server, testStatus);
86 } else {
87 L2TrafficGenerator.trafficGeneratorClientInit(c, testType);
88 L2TrafficGenerator.trafficGeneratorRead(c, initialData, testStatus);
89 }
90 break;
91 case TRAFFIC_GENERATOR_READ:
92 testStatus.setName("l2genR");
93 if (server) {
94 L2TrafficGenerator.trafficGeneratorRead(c, initialData, testStatus);
95 } else {
96 L2TrafficGenerator.trafficGeneratorClientInit(c, testType);
97 L2TrafficGenerator.trafficGeneratorStatusReadStart(c, testStatus);
98 L2TrafficGenerator.trafficGeneratorWrite(c, initialData, server, testStatus);
99 }
100 break;
101 case TRAFFIC_GENERATOR_READ_WRITE:
102 testStatus.setName("l2genRW");
103 if (!server) {
104 L2TrafficGenerator.trafficGeneratorClientInit(c, testType);
105 }
106 L2TrafficGenerator.trafficGeneratorReadStart(c, initialData, testStatus);
107 L2TrafficGenerator.trafficGeneratorWrite(c, initialData, server, testStatus);
108 break;
109 default:
110 Assert.fail("Invalid test#" + testType);
111 }
112
113 }
114
115 private static void sequenceSend(int testType, ConnectionHolderL2CAP c) throws IOException {
116 final int sequenceSize = 77;
117 int sequenceRecivedCount = 0;
118 int sequenceSentCount = 0;
119 c.channel.send(startPrefix(testType, new byte[] { sequenceSize }));
120 int receiveMTU = c.channel.getReceiveMTU();
121 int transmitMTU = c.channel.getTransmitMTU();
122 Assert.assertTrue("ReceiveMTU " + receiveMTU, sequenceSize <= receiveMTU);
123 Assert.assertTrue("TransmitMTU " + transmitMTU, sequenceSize <= transmitMTU);
124 try {
125 mainLoop: for (int i = 1; i <= sequenceSize; i++) {
126 byte[] data = new byte[i];
127 data[0] = (byte) i;
128 for (int j = 1; j < data.length; j++) {
129 data[j] = (byte) (j + aKnowndNegativeByte);
130 }
131 c.channel.send(data);
132 sequenceSentCount++;
133 while (!c.channel.ready()) {
134 try {
135 Thread.sleep(100);
136 } catch (InterruptedException e) {
137 break mainLoop;
138 }
139 }
140 byte[] dataRecived = new byte[receiveMTU];
141 int lengthdataRecived = c.channel.receive(dataRecived);
142 Assert.assertTrue("seq " + i + " lengthdataRecived " + lengthdataRecived, lengthdataRecived >= 1);
143 Assert.assertEquals("sequence", (byte) i, dataRecived[0]);
144 Assert.assertEquals("lengthdataRecived", i, lengthdataRecived);
145 for (int j = 1; j < lengthdataRecived; j++) {
146 Assert.assertEquals("recived, byte [" + j + "]", (byte) (j + aKnowndPositiveByte), dataRecived[j]);
147 }
148 sequenceRecivedCount++;
149 }
150 } finally {
151 if (sequenceSentCount != sequenceSize) {
152 Logger.debug("Sent only " + sequenceSentCount + " packet(s) from " + sequenceSize);
153 }
154 if (sequenceRecivedCount != sequenceSize) {
155 Logger.debug("Recived only " + sequenceRecivedCount + " packet(s) from " + sequenceSize);
156 }
157 }
158 }
159
160 private static void sequenceRecive(ConnectionHolderL2CAP c, byte[] initialData) throws IOException {
161 Assert.assertEquals("initialData.len", 1, initialData.length);
162 final int sequenceSize = initialData[0];
163 int receiveMTU = c.channel.getReceiveMTU();
164 int transmitMTU = c.channel.getTransmitMTU();
165 Assert.assertTrue("ReceiveMTU " + receiveMTU, sequenceSize <= receiveMTU);
166 Assert.assertTrue("TransmitMTU " + transmitMTU, sequenceSize <= transmitMTU);
167
168 int sequenceRecivedCount = 0;
169 int sequenceSentCount = 0;
170 try {
171 mainLoop: for (int i = 1; i <= sequenceSize; i++) {
172 while (!c.channel.ready()) {
173 try {
174 Thread.sleep(100);
175 } catch (InterruptedException e) {
176 break mainLoop;
177 }
178 }
179 byte[] dataRecived = new byte[receiveMTU];
180 int lengthdataRecived = c.channel.receive(dataRecived);
181 Assert.assertTrue("seq " + i + " lengthdataRecived " + lengthdataRecived, lengthdataRecived >= 1);
182 Assert.assertEquals("sequence", (byte) i, dataRecived[0]);
183 Assert.assertEquals("lengthdataRecived", i, lengthdataRecived);
184 for (int j = 1; j < lengthdataRecived; j++) {
185 Assert.assertEquals("recived, byte [" + j + "]", (byte) (j + aKnowndNegativeByte), dataRecived[j]);
186 }
187 sequenceRecivedCount++;
188
189 byte[] data = new byte[i];
190 data[0] = (byte) i;
191 for (int j = 1; j < data.length; j++) {
192 data[j] = (byte) (j + aKnowndPositiveByte);
193 }
194 c.channel.send(data);
195 sequenceSentCount++;
196 }
197 } finally {
198 if (sequenceRecivedCount != sequenceSize) {
199 Logger.debug("Recived only " + sequenceRecivedCount + " packet(s) from " + sequenceSize);
200 }
201 if (sequenceSentCount != sequenceSize) {
202 Logger.debug("Sent only " + sequenceSentCount + " packet(s) from " + sequenceSize);
203 }
204 }
205 }
206
207 private static void maxMTUSend(int testType, ConnectionHolderL2CAP c) throws IOException {
208 int receiveMTU = c.channel.getReceiveMTU();
209 int transmitMTU = c.channel.getTransmitMTU();
210 if (transmitMTU < receiveMTU) {
211 receiveMTU = transmitMTU;
212 }
213 final int sequenceSize = 10;
214 c.channel.send(startPrefix(testType, new byte[] { sequenceSize, IOUtils.hiByte(receiveMTU),
215 IOUtils.loByte(receiveMTU) }));
216
217 int sequenceRecivedCount = 0;
218 int sequenceSentCount = 0;
219 try {
220 mainLoop: for (int i = 1; i <= sequenceSize; i++) {
221 byte[] data = new byte[receiveMTU];
222 data[0] = (byte) i;
223 for (int j = 1; j < data.length; j++) {
224 data[j] = (byte) (j + aKnowndNegativeByte);
225 }
226 c.channel.send(data);
227 sequenceSentCount++;
228 while (!c.channel.ready()) {
229 try {
230 Thread.sleep(100);
231 } catch (InterruptedException e) {
232 break mainLoop;
233 }
234 }
235 byte[] dataRecived = new byte[receiveMTU];
236 int lengthdataRecived = c.channel.receive(dataRecived);
237 Assert.assertTrue("lengthdataRecived", lengthdataRecived >= 1);
238 Assert.assertEquals("sequence", (byte) i, dataRecived[0]);
239 Assert.assertEquals("lengthdataRecived", receiveMTU, lengthdataRecived);
240 for (int j = 1; j < lengthdataRecived; j++) {
241 Assert.assertEquals("recived, byte [" + j + "]", (byte) (j + aKnowndPositiveByte), dataRecived[j]);
242 }
243 sequenceRecivedCount++;
244 }
245 } finally {
246 if (sequenceSentCount != sequenceSize) {
247 Logger.debug("Sent only " + sequenceSentCount + " packet(s) from " + sequenceSize);
248 }
249 if (sequenceRecivedCount != sequenceSize) {
250 Logger.debug("Recived only " + sequenceRecivedCount + " packet(s) from " + sequenceSize);
251 }
252 }
253 }
254
255 private static void maxMTURecive(ConnectionHolderL2CAP c, byte[] initialData) throws IOException {
256 Assert.assertEquals("initialData.len", 3, initialData.length);
257 final int sequenceSize = initialData[0];
258 int clientMTU = IOUtils.bytesToShort(initialData[1], initialData[2]);
259 int receiveMTU = c.channel.getReceiveMTU();
260 int transmitMTU = c.channel.getTransmitMTU();
261 Assert.assertTrue("ReceiveMTU " + receiveMTU, clientMTU <= receiveMTU);
262 Assert.assertTrue("TransmitMTU " + transmitMTU, clientMTU <= transmitMTU);
263
264 int sequenceRecivedCount = 0;
265 int sequenceSentCount = 0;
266 try {
267 mainLoop: for (int i = 1; i <= sequenceSize; i++) {
268 while (!c.channel.ready()) {
269 try {
270 Thread.sleep(100);
271 } catch (InterruptedException e) {
272 break mainLoop;
273 }
274 }
275 byte[] dataReceived = new byte[receiveMTU];
276 int lengthdataReceived = c.channel.receive(dataReceived);
277 Assert.assertTrue("lengthdataReceived", lengthdataReceived >= 1);
278 Assert.assertEquals("sequence", (byte) i, dataReceived[0]);
279 Assert.assertEquals("lengthdataReceived", clientMTU, lengthdataReceived);
280 for (int j = 1; j < lengthdataReceived; j++) {
281 Assert
282 .assertEquals("received, byte [" + j + "]", (byte) (j + aKnowndNegativeByte),
283 dataReceived[j]);
284 }
285 sequenceRecivedCount++;
286
287 byte[] data = new byte[clientMTU];
288 data[0] = (byte) i;
289 for (int j = 1; j < data.length; j++) {
290 data[j] = (byte) (j + aKnowndPositiveByte);
291 }
292 c.channel.send(data);
293 sequenceSentCount++;
294 }
295 } finally {
296 if (sequenceRecivedCount != sequenceSize) {
297 Logger.debug("Received only " + sequenceRecivedCount + " packet(s) from " + sequenceSize);
298 }
299 if (sequenceSentCount != sequenceSize) {
300 Logger.debug("Sent only " + sequenceSentCount + " packet(s) from " + sequenceSize);
301 }
302 }
303 }
304
305 }