Commit | Line | Data |
---|---|---|
16035098 | 1 | /******************************************************************************* |
ed902a2b | 2 | * Copyright (c) 2013, 2014 Ericsson |
16035098 PT |
3 | * |
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 | |
8 | * | |
9 | * Contributors: | |
10 | * Francois Chouinard - Initial API and implementation | |
11 | * Patrick Tasse - Modified from TmfSimpleTimestamp to use nanosecond scale | |
12 | *******************************************************************************/ | |
13 | ||
2bdf0193 | 14 | package org.eclipse.tracecompass.tmf.core.tests.event; |
16035098 PT |
15 | |
16 | import static org.junit.Assert.assertEquals; | |
17 | import static org.junit.Assert.assertFalse; | |
18 | import static org.junit.Assert.assertTrue; | |
16035098 PT |
19 | |
20 | import java.text.DateFormat; | |
21 | import java.text.SimpleDateFormat; | |
22 | import java.util.Date; | |
23 | ||
dd21f749 | 24 | import org.eclipse.tracecompass.internal.tmf.core.timestamp.TmfNanoTimestamp; |
2bdf0193 | 25 | import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp; |
2bdf0193 | 26 | import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp; |
16035098 PT |
27 | import org.junit.Test; |
28 | ||
29 | /** | |
30 | * Test suite for the TmfNanoTimestampTest class. | |
31 | */ | |
32 | @SuppressWarnings("javadoc") | |
33 | public class TmfNanoTimestampTest { | |
34 | ||
35 | // ------------------------------------------------------------------------ | |
36 | // Variables | |
37 | // ------------------------------------------------------------------------ | |
38 | ||
b2c971ec | 39 | private final ITmfTimestamp ts0 = new TmfNanoTimestamp(0); |
16035098 PT |
40 | private final ITmfTimestamp ts1 = new TmfNanoTimestamp(12345); |
41 | private final ITmfTimestamp ts2 = new TmfNanoTimestamp(-1234); | |
42 | ||
43 | // ------------------------------------------------------------------------ | |
44 | // Constructors | |
45 | // ------------------------------------------------------------------------ | |
46 | ||
47 | @Test | |
48 | public void testDefaultConstructor() { | |
49 | assertEquals("getValue", 0, ts0.getValue()); | |
50 | assertEquals("getscale", -9, ts0.getScale()); | |
16035098 PT |
51 | } |
52 | ||
53 | @Test | |
54 | public void testFullConstructor() { | |
55 | assertEquals("getValue", 12345, ts1.getValue()); | |
56 | assertEquals("getscale", -9, ts1.getScale()); | |
16035098 PT |
57 | } |
58 | ||
59 | @Test | |
60 | public void testCopyConstructor() { | |
b2c971ec | 61 | final long copy = ts1.toNanos(); |
16035098 | 62 | |
b2c971ec MK |
63 | assertEquals("getValue", ts1.getValue(), copy); |
64 | assertEquals("getscale", ts1.getScale(), -9); | |
16035098 | 65 | |
b2c971ec | 66 | assertEquals("getValue", 12345, copy); |
16035098 PT |
67 | } |
68 | ||
69 | // ------------------------------------------------------------------------ | |
70 | // equals | |
71 | // ------------------------------------------------------------------------ | |
72 | ||
73 | @Test | |
74 | public void testEqualsReflexivity() { | |
75 | assertTrue("equals", ts0.equals(ts0)); | |
76 | assertTrue("equals", ts1.equals(ts1)); | |
77 | assertTrue("equals", ts2.equals(ts2)); | |
78 | ||
79 | assertTrue("equals", !ts0.equals(ts1)); | |
80 | assertTrue("equals", !ts0.equals(ts2)); | |
81 | ||
82 | assertTrue("equals", !ts1.equals(ts0)); | |
83 | assertTrue("equals", !ts1.equals(ts2)); | |
84 | ||
85 | assertTrue("equals", !ts2.equals(ts0)); | |
86 | assertTrue("equals", !ts2.equals(ts1)); | |
87 | } | |
88 | ||
89 | @Test | |
90 | public void testEqualsSymmetry() { | |
b2c971ec | 91 | final ITmfTimestamp ts0copy = TmfTimestamp.fromNanos(ts0.toNanos()); |
16035098 PT |
92 | assertTrue("equals", ts0.equals(ts0copy)); |
93 | assertTrue("equals", ts0copy.equals(ts0)); | |
94 | ||
b2c971ec | 95 | final ITmfTimestamp ts1copy = TmfTimestamp.fromNanos(ts1.toNanos()); |
16035098 PT |
96 | assertTrue("equals", ts1.equals(ts1copy)); |
97 | assertTrue("equals", ts1copy.equals(ts1)); | |
98 | } | |
99 | ||
100 | @Test | |
101 | public void testEqualsTransivity() { | |
b2c971ec MK |
102 | final ITmfTimestamp ts0copy1 = TmfTimestamp.fromNanos(ts0.toNanos()); |
103 | final ITmfTimestamp ts0copy2 = TmfTimestamp.fromNanos(ts0copy1.toNanos()); | |
16035098 PT |
104 | assertTrue("equals", ts0.equals(ts0copy1)); |
105 | assertTrue("equals", ts0copy1.equals(ts0copy2)); | |
106 | assertTrue("equals", ts0.equals(ts0copy2)); | |
107 | ||
b2c971ec MK |
108 | final ITmfTimestamp ts1copy1 = TmfTimestamp.fromNanos(ts1.toNanos()); |
109 | final ITmfTimestamp ts1copy2 = TmfTimestamp.fromNanos(ts1copy1.toNanos()); | |
16035098 PT |
110 | assertTrue("equals", ts1.equals(ts1copy1)); |
111 | assertTrue("equals", ts1copy1.equals(ts1copy2)); | |
112 | assertTrue("equals", ts1.equals(ts1copy2)); | |
113 | } | |
114 | ||
115 | @Test | |
116 | public void testEqualsNull() { | |
117 | assertTrue("equals", !ts0.equals(null)); | |
118 | assertTrue("equals", !ts1.equals(null)); | |
119 | assertTrue("equals", !ts2.equals(null)); | |
120 | } | |
121 | ||
122 | @Test | |
123 | public void testEqualsNonTimestamp() { | |
124 | assertFalse("equals", ts0.equals(ts0.toString())); | |
125 | } | |
126 | ||
127 | // ------------------------------------------------------------------------ | |
128 | // toString | |
129 | // ------------------------------------------------------------------------ | |
130 | ||
131 | @Test | |
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()); | |
140 | } | |
141 | ||
142 | // ------------------------------------------------------------------------ | |
143 | // hashCode | |
144 | // ------------------------------------------------------------------------ | |
145 | ||
146 | @Test | |
147 | public void testHashCode() { | |
b2c971ec MK |
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()); | |
16035098 | 151 | |
b2c971ec MK |
152 | assertEquals("hashCode", ts0.hashCode(), ts0copy.hashCode()); |
153 | assertEquals("hashCode", ts1.hashCode(), ts1copy.hashCode()); | |
154 | assertEquals("hashCode", ts2.hashCode(), ts2copy.hashCode()); | |
16035098 PT |
155 | |
156 | assertTrue("hashCode", ts0.hashCode() != ts1.hashCode()); | |
157 | } | |
158 | ||
159 | // ------------------------------------------------------------------------ | |
160 | // normalize | |
161 | // ------------------------------------------------------------------------ | |
162 | ||
163 | @Test | |
164 | public void testNormalizeScale0() { | |
165 | ITmfTimestamp ts = ts0.normalize(0, 0); | |
166 | assertEquals("getValue", 0, ts.getValue()); | |
167 | assertEquals("getscale", 0, ts.getScale()); | |
16035098 PT |
168 | |
169 | ts = ts0.normalize(12345, 0); | |
170 | assertEquals("getValue", 12345, ts.getValue()); | |
171 | assertEquals("getscale", 0, ts.getScale()); | |
16035098 PT |
172 | |
173 | ts = ts0.normalize(10, 0); | |
174 | assertEquals("getValue", 10, ts.getValue()); | |
175 | assertEquals("getscale", 0, ts.getScale()); | |
16035098 PT |
176 | |
177 | ts = ts0.normalize(-10, 0); | |
178 | assertEquals("getValue", -10, ts.getValue()); | |
179 | assertEquals("getscale", 0, ts.getScale()); | |
16035098 PT |
180 | } |
181 | ||
182 | @Test | |
183 | public void testNormalizeScaleNot0() { | |
184 | ITmfTimestamp ts = ts0.normalize(0, 1); | |
c61fcbab | 185 | assertEquals("Zero", TmfTimestamp.ZERO, ts); |
16035098 PT |
186 | |
187 | ts = ts0.normalize(12345, 1); | |
188 | assertEquals("getValue", 12345, ts.getValue()); | |
189 | assertEquals("getscale", 1, ts.getScale()); | |
16035098 PT |
190 | |
191 | ts = ts0.normalize(10, 1); | |
192 | assertEquals("getValue", 10, ts.getValue()); | |
193 | assertEquals("getscale", 1, ts.getScale()); | |
16035098 PT |
194 | |
195 | ts = ts0.normalize(-10, 1); | |
196 | assertEquals("getValue", -10, ts.getValue()); | |
197 | assertEquals("getscale", 1, ts.getScale()); | |
16035098 PT |
198 | } |
199 | ||
200 | // ------------------------------------------------------------------------ | |
201 | // compareTo | |
202 | // ------------------------------------------------------------------------ | |
203 | ||
204 | @Test | |
205 | public void testBasicCompareTo() { | |
b2c971ec MK |
206 | final ITmfTimestamp tstamp1 = TmfTimestamp.fromNanos(900); |
207 | final ITmfTimestamp tstamp2 = TmfTimestamp.fromNanos(1000); | |
208 | final ITmfTimestamp tstamp3 = TmfTimestamp.fromNanos(1100); | |
16035098 PT |
209 | |
210 | assertTrue(tstamp1.compareTo(tstamp1) == 0); | |
211 | ||
212 | assertTrue("CompareTo", tstamp1.compareTo(tstamp2) < 0); | |
213 | assertTrue("CompareTo", tstamp1.compareTo(tstamp3) < 0); | |
214 | ||
215 | assertTrue("CompareTo", tstamp2.compareTo(tstamp1) > 0); | |
216 | assertTrue("CompareTo", tstamp2.compareTo(tstamp3) < 0); | |
217 | ||
218 | assertTrue("CompareTo", tstamp3.compareTo(tstamp1) > 0); | |
219 | assertTrue("CompareTo", tstamp3.compareTo(tstamp2) > 0); | |
220 | } | |
221 | ||
222 | @Test | |
223 | public void testCompareTo() { | |
b2c971ec MK |
224 | final ITmfTimestamp ts0a = TmfTimestamp.create(0, 2); |
225 | final ITmfTimestamp ts1a = TmfTimestamp.create(123450, -10); | |
226 | final ITmfTimestamp ts2a = TmfTimestamp.create(-12340, -10); | |
16035098 PT |
227 | |
228 | assertTrue(ts1.compareTo(ts1) == 0); | |
229 | ||
230 | assertTrue("CompareTo", ts0.compareTo(ts0a) == 0); | |
231 | assertTrue("CompareTo", ts1.compareTo(ts1a) == 0); | |
232 | assertTrue("CompareTo", ts2.compareTo(ts2a) == 0); | |
233 | } | |
234 | ||
235 | // ------------------------------------------------------------------------ | |
236 | // getDelta | |
237 | // ------------------------------------------------------------------------ | |
238 | ||
239 | @Test | |
240 | public void testDelta() { | |
241 | // Delta for same scale and precision (delta > 0) | |
b2c971ec MK |
242 | ITmfTimestamp tstamp0 = TmfTimestamp.fromNanos(10); |
243 | ITmfTimestamp tstamp1 = TmfTimestamp.fromNanos(5); | |
244 | ITmfTimestamp expectd = TmfTimestamp.fromNanos(5); | |
16035098 PT |
245 | |
246 | ITmfTimestamp delta = tstamp0.getDelta(tstamp1); | |
065cc19b | 247 | assertEquals("getDelta", 0, delta.compareTo(expectd)); |
16035098 PT |
248 | |
249 | // Delta for same scale and precision (delta < 0) | |
b2c971ec MK |
250 | tstamp0 = TmfTimestamp.fromSeconds(5); |
251 | tstamp1 = TmfTimestamp.fromSeconds(10); | |
252 | expectd = TmfTimestamp.fromSeconds(-5); | |
16035098 PT |
253 | |
254 | delta = tstamp0.getDelta(tstamp1); | |
065cc19b | 255 | assertEquals("getDelta", 0, delta.compareTo(expectd)); |
16035098 PT |
256 | } |
257 | ||
258 | @Test | |
259 | public void testDelta2() { | |
260 | // Delta for different scale and same precision (delta > 0) | |
b2c971ec MK |
261 | final ITmfTimestamp tstamp0 = TmfTimestamp.fromNanos(10); |
262 | final ITmfTimestamp tstamp1 = TmfTimestamp.create(1, -8); | |
263 | final ITmfTimestamp expectd = TmfTimestamp.create(0, 0); | |
16035098 PT |
264 | |
265 | final ITmfTimestamp delta = tstamp0.getDelta(tstamp1); | |
065cc19b | 266 | assertEquals("getDelta", 0, delta.compareTo(expectd)); |
16035098 PT |
267 | } |
268 | ||
269 | } |