1 /*******************************************************************************
2 * Copyright (c) 2013, 2014 Ericsson
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * Francois Chouinard - Initial API and implementation
11 * Patrick Tasse - Modified from TmfSimpleTimestamp to use nanosecond scale
12 *******************************************************************************/
14 package org
.eclipse
.tracecompass
.tmf
.core
.tests
.event
;
16 import static org
.junit
.Assert
.assertEquals
;
17 import static org
.junit
.Assert
.assertFalse
;
18 import static org
.junit
.Assert
.assertTrue
;
20 import java
.text
.DateFormat
;
21 import java
.text
.SimpleDateFormat
;
22 import java
.util
.Date
;
24 import org
.eclipse
.tracecompass
.internal
.tmf
.core
.timestamp
.TmfNanoTimestamp
;
25 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.ITmfTimestamp
;
26 import org
.eclipse
.tracecompass
.tmf
.core
.timestamp
.TmfTimestamp
;
27 import org
.junit
.Test
;
30 * Test suite for the TmfNanoTimestampTest class.
32 @SuppressWarnings("javadoc")
33 public class TmfNanoTimestampTest
{
35 // ------------------------------------------------------------------------
37 // ------------------------------------------------------------------------
39 private final ITmfTimestamp ts0
= new TmfNanoTimestamp(0);
40 private final ITmfTimestamp ts1
= new TmfNanoTimestamp(12345);
41 private final ITmfTimestamp ts2
= new TmfNanoTimestamp(-1234);
43 // ------------------------------------------------------------------------
45 // ------------------------------------------------------------------------
48 public void testDefaultConstructor() {
49 assertEquals("getValue", 0, ts0
.getValue());
50 assertEquals("getscale", -9, ts0
.getScale());
54 public void testFullConstructor() {
55 assertEquals("getValue", 12345, ts1
.getValue());
56 assertEquals("getscale", -9, ts1
.getScale());
60 public void testCopyConstructor() {
61 final long copy
= ts1
.toNanos();
63 assertEquals("getValue", ts1
.getValue(), copy
);
64 assertEquals("getscale", ts1
.getScale(), -9);
66 assertEquals("getValue", 12345, copy
);
69 // ------------------------------------------------------------------------
71 // ------------------------------------------------------------------------
74 public void testEqualsReflexivity() {
75 assertTrue("equals", ts0
.equals(ts0
));
76 assertTrue("equals", ts1
.equals(ts1
));
77 assertTrue("equals", ts2
.equals(ts2
));
79 assertTrue("equals", !ts0
.equals(ts1
));
80 assertTrue("equals", !ts0
.equals(ts2
));
82 assertTrue("equals", !ts1
.equals(ts0
));
83 assertTrue("equals", !ts1
.equals(ts2
));
85 assertTrue("equals", !ts2
.equals(ts0
));
86 assertTrue("equals", !ts2
.equals(ts1
));
90 public void testEqualsSymmetry() {
91 final ITmfTimestamp ts0copy
= TmfTimestamp
.fromNanos(ts0
.toNanos());
92 assertTrue("equals", ts0
.equals(ts0copy
));
93 assertTrue("equals", ts0copy
.equals(ts0
));
95 final ITmfTimestamp ts1copy
= TmfTimestamp
.fromNanos(ts1
.toNanos());
96 assertTrue("equals", ts1
.equals(ts1copy
));
97 assertTrue("equals", ts1copy
.equals(ts1
));
101 public void testEqualsTransivity() {
102 final ITmfTimestamp ts0copy1
= TmfTimestamp
.fromNanos(ts0
.toNanos());
103 final ITmfTimestamp ts0copy2
= TmfTimestamp
.fromNanos(ts0copy1
.toNanos());
104 assertTrue("equals", ts0
.equals(ts0copy1
));
105 assertTrue("equals", ts0copy1
.equals(ts0copy2
));
106 assertTrue("equals", ts0
.equals(ts0copy2
));
108 final ITmfTimestamp ts1copy1
= TmfTimestamp
.fromNanos(ts1
.toNanos());
109 final ITmfTimestamp ts1copy2
= TmfTimestamp
.fromNanos(ts1copy1
.toNanos());
110 assertTrue("equals", ts1
.equals(ts1copy1
));
111 assertTrue("equals", ts1copy1
.equals(ts1copy2
));
112 assertTrue("equals", ts1
.equals(ts1copy2
));
116 public void testEqualsNull() {
117 assertTrue("equals", !ts0
.equals(null));
118 assertTrue("equals", !ts1
.equals(null));
119 assertTrue("equals", !ts2
.equals(null));
123 public void testEqualsNonTimestamp() {
124 assertFalse("equals", ts0
.equals(ts0
.toString()));
127 // ------------------------------------------------------------------------
129 // ------------------------------------------------------------------------
132 public void testToString() {
133 DateFormat df
= new SimpleDateFormat("HH:mm:ss.SSS");
134 Date d0
= new Date(ts0
.getValue() / 1000000);
135 Date d1
= new Date(ts1
.getValue() / 1000000);
136 Date d2
= new Date(ts2
.getValue() / 1000000 - 1);
137 assertEquals("toString", df
.format(d0
) + " 000 000", ts0
.toString());
138 assertEquals("toString", df
.format(d1
) + " 012 345", ts1
.toString());
139 assertEquals("toString", df
.format(d2
) + " 998 766", ts2
.toString());
142 // ------------------------------------------------------------------------
144 // ------------------------------------------------------------------------
147 public void testHashCode() {
148 final ITmfTimestamp ts0copy
= TmfTimestamp
.create(ts0
.getValue(), ts0
.getScale());
149 final ITmfTimestamp ts1copy
= TmfTimestamp
.create(ts1
.getValue(), ts1
.getScale());
150 final ITmfTimestamp ts2copy
= TmfTimestamp
.create(ts2
.getValue(), ts2
.getScale());
152 assertEquals("hashCode", ts0
.hashCode(), ts0copy
.hashCode());
153 assertEquals("hashCode", ts1
.hashCode(), ts1copy
.hashCode());
154 assertEquals("hashCode", ts2
.hashCode(), ts2copy
.hashCode());
156 assertTrue("hashCode", ts0
.hashCode() != ts1
.hashCode());
159 // ------------------------------------------------------------------------
161 // ------------------------------------------------------------------------
164 public void testNormalizeScale0() {
165 ITmfTimestamp ts
= ts0
.normalize(0, 0);
166 assertEquals("getValue", 0, ts
.getValue());
167 assertEquals("getscale", 0, ts
.getScale());
169 ts
= ts0
.normalize(12345, 0);
170 assertEquals("getValue", 12345, ts
.getValue());
171 assertEquals("getscale", 0, ts
.getScale());
173 ts
= ts0
.normalize(10, 0);
174 assertEquals("getValue", 10, ts
.getValue());
175 assertEquals("getscale", 0, ts
.getScale());
177 ts
= ts0
.normalize(-10, 0);
178 assertEquals("getValue", -10, ts
.getValue());
179 assertEquals("getscale", 0, ts
.getScale());
183 public void testNormalizeScaleNot0() {
184 ITmfTimestamp ts
= ts0
.normalize(0, 1);
185 assertEquals("Zero", TmfTimestamp
.ZERO
, ts
);
187 ts
= ts0
.normalize(12345, 1);
188 assertEquals("getValue", 12345, ts
.getValue());
189 assertEquals("getscale", 1, ts
.getScale());
191 ts
= ts0
.normalize(10, 1);
192 assertEquals("getValue", 10, ts
.getValue());
193 assertEquals("getscale", 1, ts
.getScale());
195 ts
= ts0
.normalize(-10, 1);
196 assertEquals("getValue", -10, ts
.getValue());
197 assertEquals("getscale", 1, ts
.getScale());
200 // ------------------------------------------------------------------------
202 // ------------------------------------------------------------------------
205 public void testBasicCompareTo() {
206 final ITmfTimestamp tstamp1
= TmfTimestamp
.fromNanos(900);
207 final ITmfTimestamp tstamp2
= TmfTimestamp
.fromNanos(1000);
208 final ITmfTimestamp tstamp3
= TmfTimestamp
.fromNanos(1100);
210 assertTrue(tstamp1
.compareTo(tstamp1
) == 0);
212 assertTrue("CompareTo", tstamp1
.compareTo(tstamp2
) < 0);
213 assertTrue("CompareTo", tstamp1
.compareTo(tstamp3
) < 0);
215 assertTrue("CompareTo", tstamp2
.compareTo(tstamp1
) > 0);
216 assertTrue("CompareTo", tstamp2
.compareTo(tstamp3
) < 0);
218 assertTrue("CompareTo", tstamp3
.compareTo(tstamp1
) > 0);
219 assertTrue("CompareTo", tstamp3
.compareTo(tstamp2
) > 0);
223 public void testCompareTo() {
224 final ITmfTimestamp ts0a
= TmfTimestamp
.create(0, 2);
225 final ITmfTimestamp ts1a
= TmfTimestamp
.create(123450, -10);
226 final ITmfTimestamp ts2a
= TmfTimestamp
.create(-12340, -10);
228 assertTrue(ts1
.compareTo(ts1
) == 0);
230 assertTrue("CompareTo", ts0
.compareTo(ts0a
) == 0);
231 assertTrue("CompareTo", ts1
.compareTo(ts1a
) == 0);
232 assertTrue("CompareTo", ts2
.compareTo(ts2a
) == 0);
235 // ------------------------------------------------------------------------
237 // ------------------------------------------------------------------------
240 public void testDelta() {
241 // Delta for same scale and precision (delta > 0)
242 ITmfTimestamp tstamp0
= TmfTimestamp
.fromNanos(10);
243 ITmfTimestamp tstamp1
= TmfTimestamp
.fromNanos(5);
244 ITmfTimestamp expectd
= TmfTimestamp
.fromNanos(5);
246 ITmfTimestamp delta
= tstamp0
.getDelta(tstamp1
);
247 assertEquals("getDelta", 0, delta
.compareTo(expectd
));
249 // Delta for same scale and precision (delta < 0)
250 tstamp0
= TmfTimestamp
.fromSeconds(5);
251 tstamp1
= TmfTimestamp
.fromSeconds(10);
252 expectd
= TmfTimestamp
.fromSeconds(-5);
254 delta
= tstamp0
.getDelta(tstamp1
);
255 assertEquals("getDelta", 0, delta
.compareTo(expectd
));
259 public void testDelta2() {
260 // Delta for different scale and same precision (delta > 0)
261 final ITmfTimestamp tstamp0
= TmfTimestamp
.fromNanos(10);
262 final ITmfTimestamp tstamp1
= TmfTimestamp
.create(1, -8);
263 final ITmfTimestamp expectd
= TmfTimestamp
.create(0, 0);
265 final ITmfTimestamp delta
= tstamp0
.getDelta(tstamp1
);
266 assertEquals("getDelta", 0, delta
.compareTo(expectd
));
This page took 0.040188 seconds and 5 git commands to generate.