--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2016 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+
+package org.eclipse.tracecompass.analysis.timing.core.tests.callgraph;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.CalledFunction;
+import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.CalledFunctionFactory;
+import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.CalledStringFunction;
+import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.ICalledFunction;
+import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Unit Tests for the CalledFunction data structure
+ *
+ * @author Matthew Khouzam
+ */
+public class CalledFunctionTest {
+
+ private CalledStringFunction fFixture = null;
+ private ICalledFunction f42Fixture;
+ private ICalledFunction fHiFixture;
+
+ /**
+ * Set up values
+ */
+ @Before
+ public void setup() {
+ ICalledFunction fixture = CalledFunctionFactory.create(10, 1010, 0, TmfStateValue.newValueString("Hello"), 0, null);
+ assertTrue(fixture instanceof CalledStringFunction);
+ fFixture = (CalledStringFunction) fixture;
+ ICalledFunction hiFixture = CalledFunctionFactory.create(20, 50, 1, "Hi", 0, fFixture);
+ fHiFixture = hiFixture;
+ ICalledFunction fixture42 = CalledFunctionFactory.create(400, 500, 1, TmfStateValue.newValueLong(0x42), 0, fFixture);
+ f42Fixture = fixture42;
+ fFixture.addChild(fixture42);
+ fFixture.addChild(hiFixture);
+ }
+
+ /**
+ * This is more to make sure that the arguments are OK except for the state
+ * value
+ */
+ public void createValid() {
+ assertNotNull(CalledFunctionFactory.create(0, 0, 0, TmfStateValue.newValueLong(0), 0, null));
+ assertNotNull(CalledFunctionFactory.create(0, 0, 0, TmfStateValue.newValueInt(0), 0, null));
+ assertNotNull(CalledFunctionFactory.create(0, 0, 0, TmfStateValue.newValueString(""), 0, null));
+ }
+
+ /**
+ * Test a value with a floating point memory address.
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void createInvalidDouble() {
+ CalledFunctionFactory.create(0, 0, 0, TmfStateValue.newValueDouble(3.14), 0, null);
+ }
+
+ /**
+ * Test a value with a null memory address.
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void createInvalidNull() {
+ CalledFunctionFactory.create(0, 0, 0, TmfStateValue.nullValue(), 0, null);
+ }
+
+ /**
+ * Test a value with an invalid time range
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void createInvalidTimeRange() {
+ CalledFunctionFactory.create(10, -10, 0, "", 0, null);
+ }
+
+ /**
+ * Test a value with an invalid time range
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void createInvalidTimeRangeStateLong() {
+ CalledFunctionFactory.create(10, -10, 0, TmfStateValue.newValueLong(42), 0, null);
+ }
+
+ /**
+ * Test a value with an invalid time range
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void createInvalidTimeRangeStateInteger() {
+ CalledFunctionFactory.create(10, -10, 0, TmfStateValue.newValueInt(42), 0, null);
+ }
+
+ /**
+ * Test a value with an invalid time range
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void createInvalidTimeRangeStateString() {
+ CalledFunctionFactory.create(10, -10, 0, TmfStateValue.newValueString("42"), 0, null);
+ }
+
+ /**
+ * Cannot have a cycle
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testAddChildSelf() {
+ assertNotNull(fFixture);
+ assertNotNull(f42Fixture);
+ assertNotNull(fHiFixture);
+ fFixture.addChild(fFixture);
+ }
+
+ /**
+ * Cannot have a cycle
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testAddChildCycle1() {
+ assertNotNull(fFixture);
+ assertNotNull(fHiFixture);
+ assertNotNull(f42Fixture);
+ ((CalledStringFunction) fHiFixture).addChild(f42Fixture);
+ }
+
+ /**
+ * Cannot have a cycle
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testAddChildCycle2() {
+ ICalledFunction fixture42 = f42Fixture;
+ assertNotNull(fFixture);
+ assertNotNull(fixture42);
+ assertNotNull(fHiFixture);
+ fFixture.addChild(fixture42);
+ ((CalledFunction) fixture42).addChild(fFixture);
+ }
+
+ /**
+ * Cannot have a cycle
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testAddChildCycle3() {
+ assertNotNull(fFixture);
+ assertNotNull(f42Fixture);
+ assertNotNull(fHiFixture);
+ ((CalledFunction) f42Fixture).addChild(fHiFixture);
+ }
+
+ /**
+ * Ok to add like this
+ */
+ @Test
+ public void testAddChildOk1() {
+ assertNotNull(fFixture);
+ CalledFunction newchild = (CalledFunction) CalledFunctionFactory.create(100, 200, 1, TmfStateValue.newValueInt(0x64), 0, fFixture);
+ fFixture.addChild(newchild);
+ ICalledFunction hiFixture = fHiFixture;
+ ICalledFunction fixture42 = f42Fixture;
+ assertNotNull(hiFixture);
+ assertNotNull(fixture42);
+ assertEquals(ImmutableList.of(fixture42, hiFixture, newchild), fFixture.getChildren());
+ assertEquals(Collections.emptyList(), fixture42.getChildren());
+ assertEquals(Collections.emptyList(), hiFixture.getChildren());
+ }
+
+ /**
+ * Ok to add like this
+ */
+ @Test
+ public void testAddChildOk2() {
+ assertNotNull(fFixture);
+ CalledStringFunction newchild = CalledFunctionFactory.create(450, 490, 1, "OK", 0, f42Fixture);
+ ICalledFunction hiFixture = fHiFixture;
+ ICalledFunction fixture42 = f42Fixture;
+ assertNotNull(hiFixture);
+ assertNotNull(fixture42);
+ ((CalledFunction) fixture42).addChild(newchild);
+ assertEquals(ImmutableList.of(fixture42, hiFixture), fFixture.getChildren());
+ assertEquals(ImmutableList.of(newchild), f42Fixture.getChildren());
+ assertEquals(Collections.emptyList(), fHiFixture.getChildren());
+ }
+
+ /**
+ * Ok to add like this
+ */
+ @Test
+ public void testAddChildOk3() {
+ assertNotNull(fFixture);
+ CalledStringFunction newchild = CalledFunctionFactory.create(450, 490, 1, "OK", 0, fHiFixture);
+ ICalledFunction hiFixture = fHiFixture;
+ ICalledFunction fixture42 = f42Fixture;
+ assertNotNull(hiFixture);
+ assertNotNull(fixture42);
+ ((CalledStringFunction) hiFixture).addChild(newchild);
+ assertEquals(ImmutableList.of(fixture42, hiFixture), fFixture.getChildren());
+ assertEquals(ImmutableList.of(newchild), fHiFixture.getChildren());
+ assertEquals(Collections.emptyList(), f42Fixture.getChildren());
+ }
+
+ /**
+ * Test Comparison
+ */
+ @Test
+ public void testCompareTo() {
+ CalledStringFunction fixture = fFixture;
+ assertEquals(0, fixture.compareTo(fixture));
+ assertTrue(fixture.compareTo(f42Fixture) < 0);
+ assertTrue(f42Fixture.compareTo(fixture) > 0);
+ }
+
+ /**
+ * Test bad Comparison
+ */
+ @Test(expected = IllegalArgumentException.class)
+ public void testCompareToBad() {
+ CalledStringFunction fixture = fFixture;
+ assertTrue(fixture.compareTo(null) == 0);
+ }
+
+ /**
+ * Test equality and inequality
+ */
+ @Test
+ public void testEquals() {
+ assertEquals(fFixture, fFixture);
+ assertEquals(fHiFixture, CalledFunctionFactory.create(20, 50, 1, "Hi", 0, fFixture));
+ assertNotEquals(fFixture, f42Fixture);
+ assertNotEquals(fFixture, fHiFixture);
+ assertNotEquals(fFixture, null);
+ assertNotEquals(fFixture, new ArrayList<>());
+ }
+
+ /**
+ * Test get children
+ */
+ @Test
+ public void testGetChildren() {
+ ICalledFunction fixture42 = f42Fixture;
+ ICalledFunction fixtureHi = fHiFixture;
+ assertNotNull(fixture42);
+ assertNotNull(fixtureHi);
+ assertEquals(ImmutableList.of(fixture42, fixtureHi), fFixture.getChildren());
+ assertEquals(Collections.emptyList(), fixture42.getChildren());
+ assertEquals(Collections.emptyList(), fixtureHi.getChildren());
+ }
+
+ /**
+ * Test get depth
+ */
+ @Test
+ public void testGetDepth() {
+ assertEquals(0, fFixture.getDepth());
+ assertEquals(1, fHiFixture.getDepth());
+ assertEquals(1, f42Fixture.getDepth());
+ }
+
+ /**
+ * Test get end. Simple getter test
+ */
+ @Test
+ public void testGetEnd() {
+ assertEquals(1010, fFixture.getEnd());
+ assertEquals(50, fHiFixture.getEnd());
+ assertEquals(500, f42Fixture.getEnd());
+ }
+
+ /**
+ * Test get parent. Can be null
+ */
+ @Test
+ public void testGetParent() {
+ assertEquals(null, fFixture.getParent());
+ assertEquals(fFixture, f42Fixture.getParent());
+ assertEquals(fFixture, fHiFixture.getParent());
+ }
+
+ /**
+ * Test get process ID
+ */
+ @Test
+ public void testGetProcessId() {
+ assertEquals(0, fFixture.getProcessId());
+ assertEquals(0, fHiFixture.getProcessId());
+ assertEquals(0, f42Fixture.getProcessId());
+ }
+
+ /**
+ * Test get self time
+ */
+ @Test
+ public void testGetSelfTime() {
+ assertEquals(870, fFixture.getSelfTime());
+ assertEquals(30, fHiFixture.getSelfTime());
+ assertEquals(100, f42Fixture.getSelfTime());
+ }
+
+ /**
+ * Test get start
+ */
+ @Test
+ public void testGetStart() {
+ assertEquals(10, fFixture.getStart());
+ assertEquals(20, fHiFixture.getStart());
+ assertEquals(400, f42Fixture.getStart());
+
+ }
+
+ /**
+ * Test hashcode. Reminder: hashcodes are only guaranteed to be the same for
+ * the same element, two different things may return the same hash.
+ */
+ @Test
+ public void testHashCode() {
+ assertEquals(f42Fixture.hashCode(), f42Fixture.hashCode());
+ ICalledFunction calledFunction = CalledFunctionFactory.create(400, 500, 1, TmfStateValue.newValueLong(0x42), 0, fFixture);
+ assertEquals(f42Fixture, calledFunction);
+ assertEquals(f42Fixture.hashCode(), calledFunction.hashCode());
+ calledFunction = CalledFunctionFactory.create(20, 50, 1, "Hi", 0, fFixture);
+ assertEquals(fHiFixture, calledFunction);
+ assertEquals(fHiFixture.hashCode(), calledFunction.hashCode());
+ }
+
+ /**
+ * Test toString()
+ */
+ @Test
+ public void testToString() {
+ assertEquals("[10, 1010]", fFixture.toString());
+ assertEquals("[400, 500]", f42Fixture.toString());
+ assertEquals("[20, 50]", fHiFixture.toString());
+ }
+}