Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.ntp.NtpV3Impl |
0% |
0% |

1 |  |
     package org.apache.commons.net.ntp;
2 |  |
     /*
3 |  |
      * Copyright 2001-2005 The Apache Software Foundation
4 |  |
      *
5 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
6 |  |
      * you may not use this file except in compliance with the License.
7 |  |
      * You may obtain a copy of the License at
8 |  |
      *
9 |  |
      *     http://www.apache.org/licenses/LICENSE-2.0
10 |  |
      *
11 |  |
      * Unless required by applicable law or agreed to in writing, software
12 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
13 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 |  |
      * See the License for the specific language governing permissions and
15 |  |
      * limitations under the License.
16 |  |
      */
17 |  |
     import java.net.DatagramPacket;
18 |  |
19 |  |
     /***
20 |  |
      * Implementation of NtpV3Packet with methods converting Java objects to/from
21 |  |
      * the Network Time Protocol (NTP) data message header format described in RFC-1305.
22 |  |
      *
23 |  |
      * @author Naz Irizarry, MITRE Corp
24 |  |
      * @author Jason Mathews, MITRE Corp
25 |  |
      *
26 |  |
      * @version $Revision: 165675 $ $Date: 2005-05-02 21:09:55 +0100 (Mon, 02 May 2005) $
27 |  |
      */
28 |  |
     public class NtpV3Impl implements NtpV3Packet
29 |  |
     {
30 |  |
31 |  |
         private static final int MODE_INDEX = 0;
32 |  |
         private static final int MODE_SHIFT = 0;
33 |  |
34 |  |
         private static final int VERSION_INDEX = 0;
35 |  |
         private static final int VERSION_SHIFT = 3;
36 |  |
37 |  |
         private static final int LI_INDEX = 0;
38 |  |
         private static final int LI_SHIFT = 6;
39 |  |
40 |  |
         private static final int STRATUM_INDEX = 1;
41 |  |
         private static final int POLL_INDEX = 2;
42 |  |
         private static final int PRECISION_INDEX = 3;
43 |  |
44 |  |
         private static final int ROOT_DELAY_INDEX = 4;
45 |  |
         private static final int ROOT_DISPERSION_INDEX = 8;
46 |  |
         private static final int REFERENCE_ID_INDEX = 12;
47 |  |
48 |  |
         private static final int REFERENCE_TIMESTAMP_INDEX = 16;
49 |  |
         private static final int ORIGINATE_TIMESTAMP_INDEX = 24;
50 |  |
         private static final int RECEIVE_TIMESTAMP_INDEX = 32;
51 |  |
         private static final int TRANSMIT_TIMESTAMP_INDEX = 40;
52 |  |
53 |  |
         private static final int KEY_IDENTIFIER_INDEX = 48;
54 |  |
         private static final int MESSAGE_DIGEST = 54; /* len 16 bytes */
55 |  |
56 | 0 |
         private byte[] buf = new byte[48];
57 |  |
58 |  |
         private DatagramPacket dp;
59 |  |
60 |  |
         /** Creates a new instance of NtpV3Impl */
61 |  |
         public NtpV3Impl()
62 | 0 |
         {
63 | 0 |
         }
64 |  |
65 |  |
         /***
66 |  |
          * Returns mode as defined in RFC-1305 which is a 3-bit integer
67 |  |
          * whose value is indicated by the MODE_xxx parameters.
68 |  |
          *
69 |  |
          * @return mode as defined in RFC-1305.
70 |  |
          */
71 |  |
         public int getMode()
72 |  |
         {
73 | 0 |
             return (ui(buf[MODE_INDEX]) >> MODE_SHIFT) & 0x7;
74 |  |
         }
75 |  |
76 |  |
         /***
77 |  |
          * Return human-readable name of message mode type as described in
78 |  |
          * RFC 1305.
79 |  |
          * @return mode name as string.
80 |  |
          */
81 |  |
         public String getModeName()
82 |  |
         {
83 | 0 |
             return NtpUtils.getModeName(getMode());
84 |  |
         }
85 |  |
86 |  |
         /***
87 |  |
          * Set mode as defined in RFC-1305.
88 |  |
          * @param mode
89 |  |
          */
90 |  |
         public void setMode(int mode)
91 |  |
         {
92 | 0 |
             buf[MODE_INDEX] = (byte) (buf[MODE_INDEX] & 0xF8 | mode & 0x7);
93 | 0 |
         }
94 |  |
95 |  |
         /***
96 |  |
          * Returns leap indicator as defined in RFC-1305 which is a two-bit code:
97 |  |
          *	0=no warning
98 |  |
          *	1=last minute has 61 seconds
99 |  |
          *	2=last minute has 59 seconds
100 |  |
          *	3=alarm condition (clock not synchronized)
101 |  |
          *
102 |  |
          * @return leap indicator as defined in RFC-1305.
103 |  |
          */
104 |  |
         public int getLeapIndicator()
105 |  |
         {
106 | 0 |
             return (ui(buf[LI_INDEX]) >> LI_SHIFT) & 0x3;
107 |  |
         }
108 |  |
109 |  |
         /***
110 |  |
          * Set leap indicator as defined in RFC-1305.
111 |  |
          * @param li leap indicator.
112 |  |
          */
113 |  |
         public void setLeapIndicator(int li)
114 |  |
         {
115 | 0 |
             buf[LI_INDEX] = (byte) (buf[LI_INDEX] & 0x3F | ((li & 0x3) << LI_SHIFT));
116 | 0 |
         }
117 |  |
118 |  |
         /***
119 |  |
          * Returns poll interval as defined in RFC-1305, which is an eight-bit
120 |  |
          * signed integer indicating the maximum interval between successive
121 |  |
          * messages, in seconds to the nearest power of two (e.g. value of six
122 |  |
          * indicates an interval of 64 seconds. The values that can appear in
123 |  |
          * this field range from NTP_MINPOLL to NTP_MAXPOLL inclusive.
124 |  |
          *
125 |  |
          * @return poll interval as defined in RFC-1305.
126 |  |
          */
127 |  |
         public int getPoll()
128 |  |
         {
129 | 0 |
             return (int) (buf[POLL_INDEX]);
130 |  |
         }
131 |  |
132 |  |
         /***
133 |  |
          * Set poll interval as defined in RFC-1305.
134 |  |
          *
135 |  |
          * @param poll poll interval.
136 |  |
          */
137 |  |
         public void setPoll(int poll)
138 |  |
         {
139 | 0 |
             buf[POLL_INDEX] = (byte) (poll & 0xFF);
140 | 0 |
         }
141 |  |
142 |  |
         /***
143 |  |
          * Returns precision as defined in RFC-1305 encoded as an 8-bit signed
144 |  |
          * integer (seconds to nearest power of two).
145 |  |
          * Values normally range from -6 to -20.
146 |  |
          *
147 |  |
          * @return precision as defined in RFC-1305.
148 |  |
          */
149 |  |
         public int getPrecision()
150 |  |
         {
151 | 0 |
             return (int) buf[PRECISION_INDEX];
152 |  |
         }
153 |  |
154 |  |
         /***
155 |  |
          * Set precision as defined in RFC-1305.
156 |  |
          * @param precision
157 |  |
          */
158 |  |
         public void setPrecision(int precision)
159 |  |
         {
160 | 0 |
             buf[PRECISION_INDEX] = (byte) (precision & 0xFF);
161 | 0 |
         }
162 |  |
163 |  |
         /***
164 |  |
          * Returns NTP version number as defined in RFC-1305.
165 |  |
          *
166 |  |
          * @return NTP version number.
167 |  |
          */
168 |  |
         public int getVersion()
169 |  |
         {
170 | 0 |
             return (ui(buf[VERSION_INDEX]) >> VERSION_SHIFT) & 0x7;
171 |  |
         }
172 |  |
173 |  |
         /***
174 |  |
          * Set NTP version as defined in RFC-1305.
175 |  |
          *
176 |  |
          * @param version NTP version.
177 |  |
          */
178 |  |
         public void setVersion(int version)
179 |  |
         {
180 | 0 |
             buf[VERSION_INDEX] = (byte) (buf[VERSION_INDEX] & 0xC7 | ((version & 0x7) << VERSION_SHIFT));
181 | 0 |
         }
182 |  |
183 |  |
         /***
184 |  |
          * Returns Stratum as defined in RFC-1305, which indicates the stratum level
185 |  |
          * of the local clock, with values defined as follows: 0=unspecified,
186 |  |
          * 1=primary ref clock, and all others a secondary reference (via NTP).
187 |  |
          *
188 |  |
          * @return Stratum level as defined in RFC-1305.
189 |  |
          */
190 |  |
         public int getStratum()
191 |  |
         {
192 | 0 |
             return ui(buf[STRATUM_INDEX]);
193 |  |
         }
194 |  |
195 |  |
         /***
196 |  |
          * Set stratum level as defined in RFC-1305.
197 |  |
          *
198 |  |
          * @param stratum stratum level.
199 |  |
          */
200 |  |
         public void setStratum(int stratum)
201 |  |
         {
202 | 0 |
             buf[STRATUM_INDEX] = (byte) (stratum & 0xFF);
203 | 0 |
         }
204 |  |
205 |  |
         /***
206 |  |
          * Return root delay as defined in RFC-1305, which is the total roundtrip delay
207 |  |
          * to the primary reference source, in seconds. Values can take positive and
208 |  |
          * negative values, depending on clock precision and skew.
209 |  |
          *
210 |  |
          * @return root delay as defined in RFC-1305.
211 |  |
          */
212 |  |
         public int getRootDelay()
213 |  |
         {
214 | 0 |
             return getInt(ROOT_DELAY_INDEX);
215 |  |
         }
216 |  |
217 |  |
         /***
218 |  |
          * Return root delay as defined in RFC-1305 in milliseconds, which is
219 |  |
          * the total roundtrip delay to the primary reference source, in
220 |  |
          * seconds. Values can take positive and negative values, depending
221 |  |
          * on clock precision and skew.
222 |  |
          *
223 |  |
          * @return root delay in milliseconds
224 |  |
          */
225 |  |
         public double getRootDelayInMillisDouble()
226 |  |
         {
227 | 0 |
             double l = getRootDelay();
228 | 0 |
             return l / 65.536;
229 |  |
         }
230 |  |
231 |  |
         /***
232 |  |
          * Returns root dispersion as defined in RFC-1305.
233 |  |
          * @return root dispersion.
234 |  |
          */
235 |  |
         public int getRootDispersion()
236 |  |
         {
237 | 0 |
             return getInt(ROOT_DISPERSION_INDEX);
238 |  |
         }
239 |  |
240 |  |
         /***
241 |  |
          * Returns root dispersion (as defined in RFC-1305) in milliseconds.
242 |  |
          *
243 |  |
          * @return root dispersion in milliseconds
244 |  |
          */
245 |  |
         public long getRootDispersionInMillis()
246 |  |
         {
247 | 0 |
             long l = getRootDispersion();
248 | 0 |
             return (l * 1000) / 65536L;
249 |  |
         }
250 |  |
251 |  |
         /***
252 |  |
          * Returns root dispersion (as defined in RFC-1305) in milliseconds
253 |  |
          * as double precision value.
254 |  |
          *
255 |  |
          * @return root dispersion in milliseconds
256 |  |
          */
257 |  |
         public double getRootDispersionInMillisDouble()
258 |  |
         {
259 | 0 |
             double l = getRootDispersion();
260 | 0 |
             return l / 65.536;
261 |  |
         }
262 |  |
263 |  |
         /***
264 |  |
          * Set reference clock identifier field with 32-bit unsigned integer value.
265 |  |
          * See RFC-1305 for description.
266 |  |
          *
267 |  |
          * @param refId reference clock identifier.
268 |  |
          */
269 |  |
         public void setReferenceId(int refId)
270 |  |
         {
271 | 0 |
             for (int i = 3; i >= 0; i--) {
272 | 0 |
                 buf[REFERENCE_ID_INDEX + i] = (byte) (refId & 0xff);
273 | 0 |
                 refId >>>= 8; // shift right one-byte
274 |  |
             }
275 | 0 |
         }
276 |  |
277 |  |
         /***
278 |  |
          * Returns the reference id as defined in RFC-1305, which is
279 |  |
          * a 32-bit integer whose value is dependent on several criteria.
280 |  |
          *
281 |  |
          * @return the reference id as defined in RFC-1305.
282 |  |
          */
283 |  |
         public int getReferenceId()
284 |  |
         {
285 | 0 |
             return getInt(REFERENCE_ID_INDEX);
286 |  |
         }
287 |  |
288 |  |
         /***
289 |  |
          * Returns the reference id string. String cannot be null but
290 |  |
          * value is dependent on the version of the NTP spec supported
291 |  |
          * and stratum level. Value can be an empty string, clock type string,
292 |  |
          * IP address, or a hex string.
293 |  |
          *
294 |  |
          * @return the reference id string.
295 |  |
          */
296 |  |
         public String getReferenceIdString()
297 |  |
         {
298 | 0 |
             int version = getVersion();
299 | 0 |
             int stratum = getStratum();
300 | 0 |
             if (version == VERSION_3 || version == VERSION_4) {
301 | 0 |
                 if (stratum == 0 || stratum == 1) {
302 | 0 |
                     return idAsString(); // 4-character ASCII string (e.g. GPS, USNO)
303 |  |
                 }
304 |  |
                 // in NTPv4 servers this is latest transmit timestamp of ref source
305 | 0 |
                 if (version == VERSION_4)
306 | 0 |
                     return idAsHex();
307 |  |
             }
308 |  |
309 |  |
             // Stratum 2 and higher this is a four-octet IPv4 address
310 |  |
             // of the primary reference host.
311 | 0 |
             if (stratum >= 2) {
312 | 0 |
                 return idAsIPAddress();
313 |  |
             }
314 | 0 |
             return idAsHex();
315 |  |
         }
316 |  |
317 |  |
         /***
318 |  |
          * Returns Reference id as dotted IP address.
319 |  |
          * @return refId as IP address string.
320 |  |
          */
321 |  |
         private String idAsIPAddress()
322 |  |
         {
323 | 0 |
             return ui(buf[REFERENCE_ID_INDEX]) + "." +
324 |  |
                     ui(buf[REFERENCE_ID_INDEX + 1]) + "." +
325 |  |
                     ui(buf[REFERENCE_ID_INDEX + 2]) + "." +
326 |  |
                     ui(buf[REFERENCE_ID_INDEX + 3]);
327 |  |
         }
328 |  |
329 |  |
         private String idAsString()
330 |  |
         {
331 | 0 |
             String id = "";
332 | 0 |
             for (int i = 0; i <= 3; i++) {
333 | 0 |
                 char c = (class="keyword">char) buf[REFERENCE_ID_INDEX + i];
334 | 0 |
                 if (c == 0) break; // 0-terminated string
335 | 0 |
                 id = id + c;
336 |  |
             }
337 | 0 |
             return id;
338 |  |
         }
339 |  |
340 |  |
         private String idAsHex()
341 |  |
         {
342 | 0 |
             return Integer.toHexString(getReferenceId());
343 |  |
         }
344 |  |
345 |  |
         /***
346 |  |
          * Returns the transmit timestamp as defined in RFC-1305.
347 |  |
          *
348 |  |
          * @return the transmit timestamp as defined in RFC-1305.
349 |  |
          * Never returns a null object.
350 |  |
          */
351 |  |
         public TimeStamp getTransmitTimeStamp()
352 |  |
         {
353 | 0 |
             return getTimestamp(TRANSMIT_TIMESTAMP_INDEX);
354 |  |
         }
355 |  |
356 |  |
         /***
357 |  |
          * Set transmit time with NTP timestamp.
358 |  |
          * If <code>ts</code> is null then zero time is used.
359 |  |
          *
360 |  |
          * @param ts NTP timestamp
361 |  |
          */
362 |  |
         public void setTransmitTime(TimeStamp ts)
363 |  |
         {
364 | 0 |
             setTimestamp(TRANSMIT_TIMESTAMP_INDEX, ts);
365 | 0 |
         }
366 |  |
367 |  |
         /***
368 |  |
          * Set originate timestamp given NTP TimeStamp object.
369 |  |
          * If <code>ts</code> is null then zero time is used.
370 |  |
          *
371 |  |
          * @param ts NTP timestamp
372 |  |
          */
373 |  |
         public void setOriginateTimeStamp(TimeStamp ts)
374 |  |
         {
375 | 0 |
             setTimestamp(ORIGINATE_TIMESTAMP_INDEX, ts);
376 | 0 |
         }
377 |  |
378 |  |
         /***
379 |  |
          * Returns the originate time as defined in RFC-1305.
380 |  |
          *
381 |  |
          * @return the originate time.
382 |  |
          * Never returns null.
383 |  |
          */
384 |  |
         public TimeStamp getOriginateTimeStamp()
385 |  |
         {
386 | 0 |
             return getTimestamp(ORIGINATE_TIMESTAMP_INDEX);
387 |  |
         }
388 |  |
389 |  |
         /***
390 |  |
          * Returns the reference time as defined in RFC-1305.
391 |  |
          *
392 |  |
          * @return the reference time as <code>TimeStamp</code> object.
393 |  |
          * Never returns null.
394 |  |
          */
395 |  |
         public TimeStamp getReferenceTimeStamp()
396 |  |
         {
397 | 0 |
             return getTimestamp(REFERENCE_TIMESTAMP_INDEX);
398 |  |
         }
399 |  |
400 |  |
         /***
401 |  |
          * Set Reference time with NTP timestamp. If <code>ts</code> is null
402 |  |
          * then zero time is used.
403 |  |
          *
404 |  |
          * @param ts NTP timestamp
405 |  |
          */
406 |  |
         public void setReferenceTime(TimeStamp ts)
407 |  |
         {
408 | 0 |
             setTimestamp(REFERENCE_TIMESTAMP_INDEX, ts);
409 | 0 |
         }
410 |  |
411 |  |
         /***
412 |  |
          * Returns receive timestamp as defined in RFC-1305.
413 |  |
          *
414 |  |
          * @return the receive time.
415 |  |
          * Never returns null.
416 |  |
          */
417 |  |
         public TimeStamp getReceiveTimeStamp()
418 |  |
         {
419 | 0 |
             return getTimestamp(RECEIVE_TIMESTAMP_INDEX);
420 |  |
         }
421 |  |
422 |  |
         /***
423 |  |
          * Set receive timestamp given NTP TimeStamp object.
424 |  |
          * If <code>ts</code> is null then zero time is used.
425 |  |
          *
426 |  |
          * @param ts timestamp
427 |  |
          */
428 |  |
         public void setReceiveTimeStamp(TimeStamp ts)
429 |  |
         {
430 | 0 |
             setTimestamp(RECEIVE_TIMESTAMP_INDEX, ts);
431 | 0 |
         }
432 |  |
433 |  |
         /***
434 |  |
          * Return type of time packet. The values (e.g. NTP, TIME, ICMP, ...)
435 |  |
          * correspond to the protocol used to obtain the timing information.
436 |  |
          *
437 |  |
          * @return packet type string identifier which in this case is "NTP".
438 |  |
          */
439 |  |
         public String getType()
440 |  |
         {
441 | 0 |
             return "NTP";
442 |  |
         }
443 |  |
444 |  |
         /***
445 |  |
          * @return 4 bytes as 32-bit int
446 |  |
          */
447 |  |
         private int getInt(class="keyword">int index)
448 |  |
         {
449 | 0 |
             int i = ui(buf[index]) << 24 |
450 |  |
                     ui(buf[index + 1]) << 16 |
451 |  |
                     ui(buf[index + 2]) << 8 |
452 |  |
                     ui(buf[index + 3]);
453 |  |
454 | 0 |
             return i;
455 |  |
         }
456 |  |
457 |  |
         /***
458 |  |
          * Get NTP Timestamp at specified starting index.
459 |  |
          *
460 |  |
          * @param index index into data array
461 |  |
          * @return TimeStamp object for 64 bits starting at index
462 |  |
          */
463 |  |
         private TimeStamp getTimestamp(int index)
464 |  |
         {
465 | 0 |
             return new TimeStamp(getLong(index));
466 |  |
         }
467 |  |
468 |  |
         /***
469 |  |
          * Get Long value represented by bits starting at specified index.
470 |  |
          *
471 |  |
          * @return 8 bytes as 64-bit long
472 |  |
          */
473 |  |
         private long getLong(int index)
474 |  |
         {
475 | 0 |
             long i = ul(buf[index]) << 56 |
476 |  |
                     ul(buf[index + 1]) << 48 |
477 |  |
                     ul(buf[index + 2]) << 40 |
478 |  |
                     ul(buf[index + 3]) << 32 |
479 |  |
                     ul(buf[index + 4]) << 24 |
480 |  |
                     ul(buf[index + 5]) << 16 |
481 |  |
                     ul(buf[index + 6]) << 8 |
482 |  |
                     ul(buf[index + 7]);
483 | 0 |
             return i;
484 |  |
         }
485 |  |
486 |  |
         /***
487 |  |
          * Sets the NTP timestamp at the given array index.
488 |  |
          *
489 |  |
          * @param index index into the byte array.
490 |  |
          * @param t TimeStamp.
491 |  |
          */
492 |  |
         private void setTimestamp(int index, TimeStamp t)
493 |  |
         {
494 | 0 |
             long ntpTime = (t == null) ? 0 : t.ntpValue();
495 |  |
             // copy 64-bits from Long value into 8 x 8-bit bytes of array
496 |  |
             // one byte at a time shifting 8-bits for each position.
497 | 0 |
             for (int i = 7; i >= 0; i--) {
498 | 0 |
                 buf[index + i] = (byte) (ntpTime & 0xFF);
499 | 0 |
                 ntpTime >>>= 8; // shift to next byte
500 |  |
             }
501 |  |
             // buf[index] |= 0x80;  // only set if 1900 baseline....
502 | 0 |
         }
503 |  |
504 |  |
         /***
505 |  |
          * Returns the datagram packet with the NTP details already filled in.
506 |  |
          *
507 |  |
          * @return a datagram packet.
508 |  |
          */
509 |  |
         public DatagramPacket getDatagramPacket()
510 |  |
         {
511 | 0 |
             if (dp == null)
512 | 0 |
                 synchronized(this) {
513 | 0 |
                     if (dp == null) {
514 | 0 |
                         dp = new DatagramPacket(buf, buf.length);
515 | 0 |
                         dp.setPort(NTP_PORT);
516 |  |
                     }
517 | 0 |
                 }
518 | 0 |
             return dp;
519 |  |
         }
520 |  |
521 |  |
         /***
522 |  |
          * Set the contents of this object from source datagram packet.
523 |  |
          *
524 |  |
          * @param srcDp source DatagramPacket to copy contents from.
525 |  |
          */
526 |  |
         public void setDatagramPacket(DatagramPacket srcDp)
527 |  |
         {
528 | 0 |
             byte[] incomingBuf = srcDp.getData();
529 | 0 |
             int len = srcDp.getLength();
530 | 0 |
             if (len > buf.length)
531 | 0 |
                 len = buf.length;
532 |  |
533 | 0 |
             System.arraycopy(incomingBuf, 0, buf, 0, len);
534 | 0 |
         }
535 |  |
536 |  |
         /***
537 |  |
          * Convert byte to unsigned integer.
538 |  |
          * Java only has signed types so we have to do
539 |  |
          * more work to get unsigned ops.
540 |  |
          *
541 |  |
          * @param b
542 |  |
          * @return unsigned int value of byte
543 |  |
          */
544 |  |
         protected final static int ui(byte b)
545 |  |
         {
546 | 0 |
             int i = b & 0xFF;
547 | 0 |
             return i;
548 |  |
         }
549 |  |
550 |  |
         /***
551 |  |
          * Convert byte to unsigned long.
552 |  |
          * Java only has signed types so we have to do
553 |  |
          * more work to get unsigned ops
554 |  |
          *
555 |  |
          * @param b
556 |  |
          * @return unsigned long value of byte
557 |  |
          */
558 |  |
         protected final static long ul(byte b)
559 |  |
         {
560 | 0 |
             long i = b & 0xFF;
561 | 0 |
             return i;
562 |  |
         }
563 |  |
564 |  |
         /***
565 |  |
          * Returns details of NTP packet as a string.
566 |  |
          *
567 |  |
          * @return details of NTP packet as a string.
568 |  |
          */
569 |  |
         public String toString()
570 |  |
         {
571 | 0 |
             return "[" +
572 |  |
                     "version:" + getVersion() +
573 |  |
                     ", mode:" + getMode() +
574 |  |
                     ", poll:" + getPoll() +
575 |  |
                     ", precision:" + getPrecision() +
576 |  |
                     ", delay:" + getRootDelay() +
577 |  |
                     ", dispersion(ms):" + getRootDispersionInMillisDouble() +
578 |  |
                     ", id:" + getReferenceIdString() +
579 |  |
                     ", xmitTime:" + getTransmitTimeStamp().toDateString() +
580 |  |
                     " ]";
581 |  |
         }
582 |  |
583 |  |
     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.