package org.lttng.ust.agent.integration.client;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
import org.lttng.tools.ILttngSession;
import org.lttng.tools.LttngToolsHelper;
import org.lttng.ust.agent.ILttngAgent;
import org.lttng.ust.agent.session.LogLevelSelector.LogLevelType;
import org.lttng.ust.agent.utils.EventRuleFactory;
import org.lttng.ust.agent.utils.ILogLevelStrings;
-import org.lttng.ust.agent.utils.TestPrintRunner;
+import org.lttng.ust.agent.utils.TestPrintExtension;
/**
* Tests for the TCP client only, without using an agent.
*
* @author Alexandre Montplaisir
*/
-@RunWith(TestPrintRunner.class)
+@ExtendWith(TestPrintExtension.class)
public class TcpClientIT {
// ------------------------------------------------------------------------
private static LttngTcpSessiondClient client;
private static Thread clientThread;
+ private static EventRuleFactory eventRuleFactory = new EventRuleFactory(SESSION_DOMAIN);
+
private ILttngSession session;
// ------------------------------------------------------------------------
/**
* Class setup
*/
- @BeforeClass
+ @BeforeAll
public static void setupClass() {
LttngToolsHelper.destroyAllSessions();
clientThread = new Thread(client);
clientThread.start();
- assertTrue("Timed out waiting for a sessiond", client.waitForConnection(5));
+ assertTrue(client.waitForConnection(5), "Timed out waiting for a sessiond");
}
/**
* Class teardown
*/
- @AfterClass
+ @AfterAll
public static void teardownClass() {
if (client != null) {
client.close();
/**
* Test setup
*/
- @Before
+ @BeforeEach
public void setup() {
session = ILttngSession.createSession(null, SESSION_DOMAIN);
clientListener.clearAllCommands();
/**
* Test teardown
*/
- @After
+ @AfterEach
public void teardown() {
session.close();
}
session.enableEvent(EVENT_NAME_A, null, false, null);
List<EventRule> expectedCommands = Collections.singletonList(
- EventRuleFactory.createRule(EVENT_NAME_A));
+ eventRuleFactory.createRule(EVENT_NAME_A));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableAllEvents();
List<EventRule> expectedCommands = Collections.singletonList(
- EventRuleFactory.createRuleAllEvents());
+ eventRuleFactory.createRuleAllEvents());
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.disableEvents(EVENT_NAME_A);
List<EventRule> expectedEnableCommands = Collections.singletonList(
- EventRuleFactory.createRule(EVENT_NAME_A));
+ eventRuleFactory.createRule(EVENT_NAME_A));
List<String> expectedDisableCommands = Collections.singletonList(EVENT_NAME_A);
assertEquals(expectedEnableCommands, clientListener.getEnabledEventCommands());
session.disableAllEvents();
List<EventRule> expectedEnableCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A),
- EventRuleFactory.createRule(EVENT_NAME_B),
- EventRuleFactory.createRule(EVENT_NAME_C));
+ eventRuleFactory.createRule(EVENT_NAME_A),
+ eventRuleFactory.createRule(EVENT_NAME_B),
+ eventRuleFactory.createRule(EVENT_NAME_C));
/*
* A "disable-event -a" will send one command for each enabled event.
* The order may be different though.
session.enableAllEvents();
session.disableAllEvents();
- List<EventRule> expectedEnableCommands = Arrays.asList(EventRuleFactory.createRuleAllEvents());
+ List<EventRule> expectedEnableCommands = Arrays.asList(eventRuleFactory.createRuleAllEvents());
List<String> expectedDisableCommands = Arrays.asList(EventRuleFactory.EVENT_NAME_ALL);
assertEquals(expectedEnableCommands, clientListener.getEnabledEventCommands());
session2.enableEvent(EVENT_NAME_B, null, false, null);
} // close(), aka destroy the session, sending "disable event" messages
- List<EventRule> expectedEnabledCommands = Arrays.asList(EventRuleFactory.createRule(EVENT_NAME_A), EventRuleFactory.createRule(EVENT_NAME_B));
+ List<EventRule> expectedEnabledCommands = Arrays.asList(eventRuleFactory.createRule(EVENT_NAME_A), eventRuleFactory.createRule(EVENT_NAME_B));
List<String> expectedDisabledCommands = Arrays.asList(EVENT_NAME_A, EVENT_NAME_B);
assertEquals(expectedEnabledCommands, clientListener.getEnabledEventCommands());
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, null);
List<EventRule> expectedCommands = Collections.singletonList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls));
+ eventRuleFactory.createRule(EVENT_NAME_A, lls));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
List<EventRule> expectedCommands = Collections.singletonList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls));
+ eventRuleFactory.createRule(EVENT_NAME_A, lls));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls1),
- EventRuleFactory.createRule(EVENT_NAME_A, lls2)
+ eventRuleFactory.createRule(EVENT_NAME_A, lls1),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls2)
);
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, null);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls1),
- EventRuleFactory.createRule(EVENT_NAME_A, lls2)
+ eventRuleFactory.createRule(EVENT_NAME_A, lls1),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls2)
);
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
session2.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A, lls1),
- EventRuleFactory.createRule(EVENT_NAME_A, lls2));
+ eventRuleFactory.createRule(EVENT_NAME_A, lls1),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls2));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableEvent(EVENT_NAME_A, null, false, filter2);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A),
- EventRuleFactory.createRule(EVENT_NAME_A, EventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter1),
- EventRuleFactory.createRule(EVENT_NAME_A, EventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter2));
+ eventRuleFactory.createRule(EVENT_NAME_A),
+ eventRuleFactory.createRule(EVENT_NAME_A, eventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter1),
+ eventRuleFactory.createRule(EVENT_NAME_A, eventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter2));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);
session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, filter);
List<EventRule> expectedCommands = Arrays.asList(
- EventRuleFactory.createRule(EVENT_NAME_A),
- EventRuleFactory.createRule(EVENT_NAME_A, lls),
- EventRuleFactory.createRule(EVENT_NAME_A, EventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter),
- EventRuleFactory.createRule(EVENT_NAME_A, lls, filter));
+ eventRuleFactory.createRule(EVENT_NAME_A),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls),
+ eventRuleFactory.createRule(EVENT_NAME_A, eventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter),
+ eventRuleFactory.createRule(EVENT_NAME_A, lls, filter));
List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
assertEquals(expectedCommands, actualCommands);