Apache
/
activemq-artemis
mirror of https://github.com/apache/activemq-artemis.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ARTEMIS-4790: use JUnit 5 for the tests

This commit is contained in:
Robbie Gemmell 2024-06-03 13:14:01 +01:00 committed by Justin Bertram
parent b9bb494b58
commit 362dbd11ac
1570 changed files with 32173 additions and 26021 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
artemis-cdi-client/pom.xml
View File

@ -80,8 +80,9 @@
<artifactId>arquillian-junit-core</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>jakarta.jms</groupId>

9
artemis-cli/pom.xml
View File

@ -150,8 +150,13 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>

2
artemis-cli/src/test/java/org/apache/activemq/SecurityManagerHandlerTest.java
View File

@ -19,7 +19,7 @@ package org.apache.activemq;
import org.apache.activemq.artemis.cli.factory.security.SecurityManagerHandler;
import org.apache.activemq.artemis.dto.SecurityManagerDTO;
import org.apache.activemq.artemis.spi.core.security.ActiveMQBasicSecurityManager;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class SecurityManagerHandlerTest {

20
artemis-cli/src/test/java/org/apache/activemq/artemis/cli/commands/CreateTest.java
View File

@ -16,6 +16,8 @@
*/
package org.apache.activemq.artemis.cli.commands;
import static org.junit.jupiter.api.Assertions.assertTrue;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
@ -23,16 +25,16 @@ import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import org.apache.activemq.artemis.tests.extensions.parameterized.ParameterizedTestExtension;
import org.apache.activemq.artemis.tests.extensions.parameterized.Parameters;
import org.apache.activemq.artemis.utils.XmlProvider;
import org.apache.activemq.cli.test.CliTestBase;
import org.apache.activemq.cli.test.TestActionContext;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import org.xml.sax.SAXException;
@RunWith(Parameterized.class)
@ExtendWith(ParameterizedTestExtension.class)
public class CreateTest extends CliTestBase {
private final String testName;
@ -45,7 +47,7 @@ public class CreateTest extends CliTestBase {
this.relaxJolokia = relaxJolokia;
}
@Parameterized.Parameters(name = "{0}")
@Parameters(name = "{0}")
public static Collection<Object[]> testData() {
return Arrays.asList(new Object[][]{
{"Happy path + relaxJolokia", "sampledomain.com", true},
@ -61,10 +63,10 @@ public class CreateTest extends CliTestBase {
});
}
@Test
@TestTemplate
public void testWriteJolokiaAccessXmlCreatesValidXml() throws Exception {
TestActionContext context = new TestActionContext();
File testInstance = new File(temporaryFolder.getRoot(), "test-instance");
File testInstance = new File(temporaryFolder, "test-instance");
Create c = new Create();
c.setNoAutoTune(true);
@ -73,7 +75,7 @@ public class CreateTest extends CliTestBase {
c.setRelaxJolokia(relaxJolokia);
c.execute(context);
Assert.assertTrue(isXmlValid(new File(testInstance, "etc/" + Create.ETC_JOLOKIA_ACCESS_XML)));
assertTrue(isXmlValid(new File(testInstance, "etc/" + Create.ETC_JOLOKIA_ACCESS_XML)));
}
/**

13
artemis-cli/src/test/java/org/apache/activemq/artemis/cli/commands/messages/ConnectionAbstractTest.java
View File

@ -16,12 +16,13 @@
*/
package org.apache.activemq.artemis.cli.commands.messages;
import static org.junit.jupiter.api.Assertions.assertEquals;
import javax.jms.JMSException;
import org.apache.activemq.artemis.cli.commands.ActionAbstractAccessor;
import org.apache.activemq.cli.test.TestActionContext;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.io.File;
@ -40,7 +41,7 @@ public class ConnectionAbstractTest {
connectionAbstract.execute(new TestActionContext());
Assert.assertEquals(ConnectionAbstract.DEFAULT_BROKER_URL, connectionAbstract.getBrokerURL());
assertEquals(ConnectionAbstract.DEFAULT_BROKER_URL, connectionAbstract.getBrokerURL());
} finally {
System.clearProperty("artemis.instance.etc");
}
@ -62,10 +63,10 @@ public class ConnectionAbstractTest {
connectionAbstract.execute(new TestActionContext());
} catch (Exception e) {
e.printStackTrace();
Assert.assertEquals(JMSException.class, e.getClass());
assertEquals(JMSException.class, e.getClass());
}
Assert.assertEquals("tcp://localhost:3344", connectionAbstract.getBrokerURL());
assertEquals("tcp://localhost:3344", connectionAbstract.getBrokerURL());
} finally {
System.clearProperty("artemis.instance.etc");
}
@ -86,7 +87,7 @@ public class ConnectionAbstractTest {
connectionAbstract.execute(new TestActionContext());
Assert.assertEquals("tcp://localhost:5672", connectionAbstract.getBrokerURL());
assertEquals("tcp://localhost:5672", connectionAbstract.getBrokerURL());
} finally {
System.clearProperty("artemis.instance.etc");
}

12
artemis-cli/src/test/java/org/apache/activemq/artemis/cli/commands/messages/ProducerThreadTest.java
View File

@ -16,25 +16,25 @@
*/
package org.apache.activemq.artemis.cli.commands.messages;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
import javax.jms.JMSException;
import javax.jms.Message;
import org.apache.activemq.artemis.jms.client.ActiveMQDestination;
import org.apache.activemq.artemis.utils.RandomUtil;
import org.apache.activemq.cli.test.TestActionContext;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
public class ProducerThreadTest {
ProducerThread producer;
Message mockMessage;
@Before
@BeforeEach
public void setUp() {
producer = new ProducerThread(null, ActiveMQDestination.createQueue(RandomUtil.randomString()), 0, null);
mockMessage = Mockito.mock(Message.class);

17
artemis-cli/src/test/java/org/apache/activemq/artemis/cli/commands/messages/TransferTest.java
View File

@ -16,10 +16,11 @@
*/
package org.apache.activemq.artemis.cli.commands.messages;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.apache.activemq.artemis.cli.commands.ActionAbstractAccessor;
import org.apache.activemq.cli.test.TestActionContext;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import javax.jms.JMSException;
import java.io.File;
@ -40,10 +41,10 @@ public class TransferTest {
try {
transfer.execute(new TestActionContext());
} catch (Exception e) {
Assert.assertEquals(JMSException.class, e.getClass());
assertEquals(JMSException.class, e.getClass());
}
Assert.assertEquals(ConnectionAbstract.DEFAULT_BROKER_URL, transfer.getSourceURL());
assertEquals(ConnectionAbstract.DEFAULT_BROKER_URL, transfer.getSourceURL());
} finally {
System.clearProperty("artemis.instance.etc");
}
@ -67,10 +68,10 @@ public class TransferTest {
transfer.execute(new TestActionContext());
} catch (Exception e) {
e.printStackTrace();
Assert.assertEquals(JMSException.class, e.getClass());
assertEquals(JMSException.class, e.getClass());
}
Assert.assertEquals("tcp://localhost:3344", transfer.getSourceURL());
assertEquals("tcp://localhost:3344", transfer.getSourceURL());
} finally {
System.clearProperty("artemis.instance.etc");
}
@ -91,10 +92,10 @@ public class TransferTest {
try {
transfer.execute(new TestActionContext());
} catch (Exception e) {
Assert.assertEquals(JMSException.class, e.getClass());
assertEquals(JMSException.class, e.getClass());
}
Assert.assertEquals("tcp://localhost:5672", transfer.getSourceURL());
assertEquals("tcp://localhost:5672", transfer.getSourceURL());
} finally {
System.clearProperty("artemis.instance.etc");
}

14
artemis-cli/src/test/java/org/apache/activemq/artemis/cli/commands/tools/xml/XmlDataImporterTest.java
View File

@ -16,30 +16,30 @@
*/
package org.apache.activemq.artemis.cli.commands.tools.xml;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.InputStream;
import org.apache.activemq.artemis.api.core.Pair;
import org.apache.activemq.artemis.core.server.ActiveMQServer;
import org.apache.activemq.artemis.core.server.management.ManagementContext;
import org.apache.activemq.cli.test.CliTestBase;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class XmlDataImporterTest extends CliTestBase {
ActiveMQServer server;
@Before
@BeforeEach
@Override
public void setup() throws Exception {
super.setup();
server = ((Pair<ManagementContext, ActiveMQServer>)startServer()).getB();
}
@After
@AfterEach
@Override
public void tearDown() throws Exception {
stopServer();

12
artemis-cli/src/test/java/org/apache/activemq/artemis/integration/bootstrap/BootstrapLogBundleTest.java
View File

@ -16,25 +16,25 @@
*/
package org.apache.activemq.artemis.integration.bootstrap;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.logs.AssertionLoggerHandler;
import org.apache.activemq.artemis.logs.AssertionLoggerHandler.LogLevel;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
public class BootstrapLogBundleTest {
private static final String LOGGER_NAME = ActiveMQBootstrapLogger.class.getPackage().getName();
private static LogLevel origLevel;
@BeforeClass
@BeforeAll
public static void setLogLevel() {
origLevel = AssertionLoggerHandler.setLevel(LOGGER_NAME, LogLevel.DEBUG);
}
@AfterClass
@AfterAll
public static void restoreLogLevel() throws Exception {
AssertionLoggerHandler.setLevel(LOGGER_NAME, origLevel);
}

41
artemis-cli/src/test/java/org/apache/activemq/artemis/util/JVMArgumentTest.java
View File

@ -17,10 +17,13 @@
package org.apache.activemq.artemis.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.HashMap;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class JVMArgumentTest {
@ -34,9 +37,9 @@ public class JVMArgumentTest {
HashMap<String, String> usedArgs = new HashMap<>();
JVMArgumentParser.parseOriginalArgs(prefix, "\"", arguments, fixedArguments, usedArgs);
Assert.assertEquals(2, usedArgs.size());
Assert.assertEquals("-Xmx77G", usedArgs.get("-Xmx"));
Assert.assertEquals("-Xms333M", usedArgs.get("-Xms"));
assertEquals(2, usedArgs.size());
assertEquals("-Xmx77G", usedArgs.get("-Xmx"));
assertEquals("-Xms333M", usedArgs.get("-Xms"));
String newLine = "IF \"%JAVA_ARGS%\"==\"\" (set JAVA_ARGS= -XX:AutoBoxCacheMax=20000 -XX:+PrintClassHistogram -XX:+UseG1GC -XX:+UseStringDeduplication -Xms512M -Xmx1G -Djava.security.auth.login.config=%ARTEMIS_ETC_DIR%\\login.config -Dhawtio.disableProxy=true -Dhawtio.offline=true -Dhawtio.realm=activemq -Dhawtio.role=amq -Dhawtio.rolePrincipalClasses=org.apache.activemq.artemis.spi.core.security.jaas.RolePrincipal -Djolokia.policyLocation=%ARTEMIS_INSTANCE_ETC_URI%\\jolokia-access.xml -Dartemis.instance=%ARTEMIS_INSTANCE%)";
@ -44,11 +47,11 @@ public class JVMArgumentTest {
System.out.println("output::" + resultLine);
Assert.assertFalse(resultLine.contains("-must-go"));
Assert.assertTrue(resultLine.contains("-Xmx77G"));
Assert.assertTrue(resultLine.contains("-Xms333M"));
Assert.assertFalse(resultLine.contains("-Xmx1G"));
Assert.assertFalse(resultLine.contains("-Xmx512M"));
assertFalse(resultLine.contains("-must-go"));
assertTrue(resultLine.contains("-Xmx77G"));
assertTrue(resultLine.contains("-Xms333M"));
assertFalse(resultLine.contains("-Xmx1G"));
assertFalse(resultLine.contains("-Xmx512M"));
}
@ -62,9 +65,9 @@ public class JVMArgumentTest {
HashMap<String, String> usedArgs = new HashMap<>();
JVMArgumentParser.parseOriginalArgs(prefix, "\"", arguments, fixedArguments, usedArgs);
Assert.assertEquals(2, usedArgs.size());
Assert.assertEquals("-Xmx77G", usedArgs.get("-Xmx"));
Assert.assertEquals("-Xms333M", usedArgs.get("-Xms"));
assertEquals(2, usedArgs.size());
assertEquals("-Xmx77G", usedArgs.get("-Xmx"));
assertEquals("-Xms333M", usedArgs.get("-Xms"));
String newLine = " JAVA_ARGS= -XX:AutoBoxCacheMax=20000 -XX:+PrintClassHistogram -XX:+UseG1GC -XX:+UseStringDeduplication -Xms512M -Xmx1G -Djava.security.auth.login.config=%ARTEMIS_ETC_DIR%\\login.config -Dhawtio.disableProxy=true -Dhawtio.offline=true -Dhawtio.realm=activemq -Dhawtio.role=amq -Dhawtio.rolePrincipalClasses=org.apache.activemq.artemis.spi.core.security.jaas.RolePrincipal -Djolokia.policyLocation=%ARTEMIS_INSTANCE_ETC_URI%\\jolokia-access.xml -Dartemis.instance=%ARTEMIS_INSTANCE%)";
@ -72,13 +75,13 @@ public class JVMArgumentTest {
System.out.println("output::" + resultLine);
Assert.assertFalse(resultLine.contains("-must-go"));
Assert.assertTrue(resultLine.contains("-Xmx77G"));
Assert.assertTrue(resultLine.contains("-Xms333M"));
Assert.assertFalse(resultLine.contains("-Xmx1G"));
Assert.assertFalse(resultLine.contains("-Xmx512M"));
assertFalse(resultLine.contains("-must-go"));
assertTrue(resultLine.contains("-Xmx77G"));
assertTrue(resultLine.contains("-Xms333M"));
assertFalse(resultLine.contains("-Xmx1G"));
assertFalse(resultLine.contains("-Xmx512M"));
Assert.assertTrue(resultLine.startsWith(" "));
assertTrue(resultLine.startsWith(" "));
}
}

423
artemis-cli/src/test/java/org/apache/activemq/cli/test/ArtemisTest.java
View File

File diff suppressed because it is too large Load Diff

15
artemis-cli/src/test/java/org/apache/activemq/cli/test/CliPerfClientTest.java
View File

@ -16,12 +16,13 @@
*/
package org.apache.activemq.cli.test;
import static org.junit.jupiter.api.Assertions.fail;
import org.apache.activemq.artemis.cli.commands.messages.perf.PerfClientCommand;
import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import javax.jms.Connection;
@ -29,7 +30,7 @@ public class CliPerfClientTest extends CliTestBase {
private Connection connection;
private ActiveMQConnectionFactory cf;
@Before
@BeforeEach
@Override
public void setup() throws Exception {
setupAuth();
@ -39,7 +40,7 @@ public class CliPerfClientTest extends CliTestBase {
connection = cf.createConnection("admin", "admin");
}
@After
@AfterEach
@Override
public void tearDown() throws Exception {
closeConnection(cf, connection);
@ -60,7 +61,7 @@ public class CliPerfClientTest extends CliTestBase {
public void testDurableNoClientIDSet() throws Exception {
try {
new PerfClientCommand().setDurableSubscription(true).setMessageCount(1).setUser("admin").setPassword("admin").execute(new TestActionContext());
Assert.fail("Exception expected");
fail("Exception expected");
} catch (IllegalArgumentException cliExpected) {
}
}

16
artemis-cli/src/test/java/org/apache/activemq/cli/test/CliProducerTest.java
View File

@ -16,14 +16,17 @@
*/
package org.apache.activemq.cli.test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.api.core.RoutingType;
import org.apache.activemq.artemis.cli.commands.messages.Producer;
import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory;
import org.apache.activemq.artemis.utils.CompositeAddress;
import org.apache.activemq.artemis.utils.RandomUtil;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import javax.jms.Connection;
import javax.jms.Message;
@ -31,15 +34,12 @@ import javax.jms.Session;
import javax.jms.TextMessage;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class CliProducerTest extends CliTestBase {
private Connection connection;
private ActiveMQConnectionFactory cf;
private static final int TEST_MESSAGE_COUNT = 10;
@Before
@BeforeEach
@Override
public void setup() throws Exception {
setupAuth();
@ -49,7 +49,7 @@ public class CliProducerTest extends CliTestBase {
connection = cf.createConnection("admin", "admin");
}
@After
@AfterEach
@Override
public void tearDown() throws Exception {
closeConnection(cf, connection);

42
artemis-cli/src/test/java/org/apache/activemq/cli/test/CliTestBase.java
View File

@ -16,6 +16,10 @@
*/
package org.apache.activemq.cli.test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.api.core.RoutingType;
import org.apache.activemq.artemis.api.core.client.ActiveMQClient;
import org.apache.activemq.artemis.cli.Artemis;
@ -26,11 +30,11 @@ import org.apache.activemq.artemis.nativo.jlibaio.LibaioContext;
import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory;
import org.apache.activemq.artemis.jms.client.ActiveMQDestination;
import org.apache.activemq.artemis.spi.core.security.jaas.PropertiesLoader;
import org.apache.activemq.artemis.utils.ThreadLeakCheckRule;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.rules.TemporaryFolder;
import org.apache.activemq.artemis.tests.extensions.TargetTempDirFactory;
import org.apache.activemq.artemis.tests.util.ArtemisTestCase;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.io.TempDir;
import javax.jms.Connection;
import javax.jms.Destination;
@ -44,33 +48,21 @@ import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
public class CliTestBase extends ArtemisTestCase {
public class CliTestBase {
@Rule
public TemporaryFolder temporaryFolder;
@Rule
public ThreadLeakCheckRule leakCheckRule = new ThreadLeakCheckRule();
// Temp folder at ./target/tmp/<TestClassName>/<generated>
@TempDir(factory = TargetTempDirFactory.class)
public File temporaryFolder;
private String original = System.getProperty("java.security.auth.login.config");
public CliTestBase() {
File parent = new File("./target/tmp");
parent.mkdirs();
temporaryFolder = new TemporaryFolder(parent);
}
@Before
@BeforeEach
public void setup() throws Exception {
Run.setEmbedded(true);
PropertiesLoader.resetUsersAndGroupsCache();
}
@After
@AfterEach
public void tearDown() throws Exception {
ActiveMQClient.clearThreadPools();
System.clearProperty("artemis.instance");
@ -87,7 +79,7 @@ public class CliTestBase {
}
protected Object startServer() throws Exception {
File rootDirectory = new File(temporaryFolder.getRoot(), "broker");
File rootDirectory = new File(temporaryFolder, "broker");
setupAuth(rootDirectory);
Run.setEmbedded(true);
Artemis.main("create", rootDirectory.getAbsolutePath(), "--silent", "--no-fsync", "--no-autotune", "--no-web", "--require-login", "--disable-persistence");
@ -96,7 +88,7 @@ public class CliTestBase {
}
void setupAuth() {
setupAuth(temporaryFolder.getRoot());
setupAuth(temporaryFolder);
}
void setupAuth(File folder) {

12
artemis-cli/src/test/java/org/apache/activemq/cli/test/ClusterVerifyTest.java
View File

@ -17,6 +17,9 @@
package org.apache.activemq.cli.test;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
@ -25,8 +28,7 @@ import org.apache.activemq.artemis.cli.commands.ActionContext;
import org.apache.activemq.artemis.cli.commands.check.ClusterNodeVerifier;
import org.apache.activemq.artemis.json.JsonArray;
import org.apache.commons.lang3.NotImplementedException;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class ClusterVerifyTest {
@ -103,9 +105,9 @@ public class ClusterVerifyTest {
};
if (fail) {
Assert.assertFalse(fakeVerifier.verify(new ActionContext()));
assertFalse(fakeVerifier.verify(new ActionContext()));
} else {
Assert.assertTrue(fakeVerifier.verify(new ActionContext()));
assertTrue(fakeVerifier.verify(new ActionContext()));
}
}
@ -152,7 +154,7 @@ public class ClusterVerifyTest {
}
};
Assert.assertTrue(fakeVerifier.verify(new ActionContext()));
assertTrue(fakeVerifier.verify(new ActionContext()));
}

41
artemis-cli/src/test/java/org/apache/activemq/cli/test/FileBrokerTest.java
View File

@ -16,6 +16,12 @@
*/
package org.apache.activemq.cli.test;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
@ -37,10 +43,7 @@ import org.apache.activemq.artemis.integration.FileBroker;
import org.apache.activemq.artemis.jms.server.impl.JMSServerManagerImpl;
import org.apache.activemq.artemis.spi.core.security.ActiveMQJAASSecurityManager;
import org.apache.activemq.artemis.spi.core.security.jaas.InVMLoginModule;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.Assert.fail;
import org.junit.jupiter.api.Test;
public class FileBrokerTest {
@ -52,11 +55,11 @@ public class FileBrokerTest {
try {
broker.start();
JMSServerManagerImpl jmsServerManager = (JMSServerManagerImpl) broker.getComponents().get("jms");
Assert.assertNull(jmsServerManager);
assertNull(jmsServerManager);
ActiveMQServerImpl activeMQServer = (ActiveMQServerImpl) broker.getComponents().get("core");
Assert.assertNotNull(activeMQServer);
Assert.assertTrue(activeMQServer.isStarted());
Assert.assertTrue(broker.isStarted());
assertNotNull(activeMQServer);
assertTrue(activeMQServer.isStarted());
assertTrue(broker.isStarted());
} finally {
broker.stop();
}
@ -72,7 +75,7 @@ public class FileBrokerTest {
FileBroker broker2 = new FileBroker(serverDTO2, new ActiveMQJAASSecurityManager(), null);
try {
broker1.start();
Assert.assertTrue(broker1.isStarted());
assertTrue(broker1.isStarted());
Thread thread = new Thread(() -> {
try {
@ -83,13 +86,13 @@ public class FileBrokerTest {
});
thread.start();
Assert.assertFalse(broker2.isStarted());
assertFalse(broker2.isStarted());
//only if broker1 is stopped can broker2 be fully started
broker1.stop();
broker1 = null;
thread.join(5000);
Assert.assertTrue(broker2.isStarted());
assertTrue(broker2.isStarted());
broker2.stop();
} finally {
@ -116,12 +119,12 @@ public class FileBrokerTest {
broker = new FileBroker(serverDTO, securityManager, null);
broker.start();
ActiveMQServerImpl activeMQServer = (ActiveMQServerImpl) broker.getComponents().get("core");
Assert.assertNotNull(activeMQServer);
Assert.assertTrue(activeMQServer.isStarted());
Assert.assertTrue(broker.isStarted());
assertNotNull(activeMQServer);
assertTrue(activeMQServer.isStarted());
assertTrue(broker.isStarted());
File file = new File(activeMQServer.getConfiguration().getConfigurationUrl().toURI());
path = file.getPath();
Assert.assertNotNull(activeMQServer.getConfiguration().getConfigurationUrl());
assertNotNull(activeMQServer.getConfiguration().getConfigurationUrl());
Thread.sleep(activeMQServer.getConfiguration().getConfigurationFileRefreshPeriod() * 2);
@ -164,12 +167,12 @@ public class FileBrokerTest {
broker = new FileBroker(serverDTO, securityManager, null);
broker.start();
ActiveMQServerImpl activeMQServer = (ActiveMQServerImpl) broker.getComponents().get("core");
Assert.assertNotNull(activeMQServer);
Assert.assertTrue(activeMQServer.isStarted());
Assert.assertTrue(broker.isStarted());
assertNotNull(activeMQServer);
assertTrue(activeMQServer.isStarted());
assertTrue(broker.isStarted());
File file = new File(activeMQServer.getConfiguration().getConfigurationUrl().toURI());
path = file.getPath();
Assert.assertNotNull(activeMQServer.getConfiguration().getConfigurationUrl());
assertNotNull(activeMQServer.getConfiguration().getConfigurationUrl());
Thread.sleep(1000);

8
artemis-cli/src/test/java/org/apache/activemq/cli/test/HashUtilTest.java
View File

@ -16,16 +16,16 @@
*/
package org.apache.activemq.cli.test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.cli.commands.util.HashUtil;
import org.apache.activemq.artemis.utils.PasswordMaskingUtil;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class HashUtilTest {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

22
artemis-cli/src/test/java/org/apache/activemq/cli/test/MessageSerializerTest.java
View File

@ -16,6 +16,11 @@
*/
package org.apache.activemq.cli.test;
import static org.apache.activemq.cli.test.ArtemisTest.getOutputLines;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.MapMessage;
@ -44,14 +49,9 @@ import org.apache.activemq.artemis.jms.client.ActiveMQDestination;
import org.apache.activemq.artemis.utils.CompositeAddress;
import org.apache.activemq.artemis.utils.RandomUtil;
import org.apache.activemq.artemis.utils.Wait;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.apache.activemq.cli.test.ArtemisTest.getOutputLines;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* Test to validate that the CLI doesn't throw improper exceptions when invoked.
@ -62,7 +62,7 @@ public class MessageSerializerTest extends CliTestBase {
private ActiveMQConnectionFactory cf;
private static final int TEST_MESSAGE_COUNT = 10;
@Before
@BeforeEach
@Override
public void setup() throws Exception {
setupAuth();
@ -72,7 +72,7 @@ public class MessageSerializerTest extends CliTestBase {
connection = cf.createConnection("admin", "admin");
}
@After
@AfterEach
@Override
public void tearDown() throws Exception {
closeConnection(cf, connection);
@ -80,7 +80,7 @@ public class MessageSerializerTest extends CliTestBase {
}
private File createMessageFile() throws IOException {
return temporaryFolder.newFile("messages.xml");
return File.createTempFile("messages.xml", null, temporaryFolder);
}
private List<Message> generateTextMessages(Session session, Destination destination) throws Exception {

9
artemis-cli/src/test/java/org/apache/activemq/cli/test/RetryCLIClientIDTest.java
View File

@ -17,6 +17,8 @@
package org.apache.activemq.cli.test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.File;
import org.apache.activemq.artemis.api.core.Pair;
@ -27,8 +29,7 @@ import org.apache.activemq.artemis.cli.commands.messages.ConnectionAbstract;
import org.apache.activemq.artemis.core.server.ActiveMQServer;
import org.apache.activemq.artemis.core.server.management.ManagementContext;
import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class RetryCLIClientIDTest extends CliTestBase {
@ -36,7 +37,7 @@ public class RetryCLIClientIDTest extends CliTestBase {
public void testWrongUserAndPass() throws Exception {
try {
Run.setEmbedded(true);
File instance1 = new File(temporaryFolder.getRoot(), "instance_user");
File instance1 = new File(temporaryFolder, "instance_user");
System.setProperty("java.security.auth.login.config", instance1.getAbsolutePath() + "/etc/login.config");
Artemis.main("create", instance1.getAbsolutePath(), "--silent", "--no-autotune", "--no-web", "--no-amqp-acceptor", "--no-mqtt-acceptor", "--no-stomp-acceptor", "--no-hornetq-acceptor", "--user", "dumb", "--password", "dumber", "--require-login");
System.setProperty("artemis.instance", instance1.getAbsolutePath());
@ -48,7 +49,7 @@ public class RetryCLIClientIDTest extends CliTestBase {
test.setSilentInput(true);
test.setClientID("someClientID");
ActiveMQConnectionFactory cf = test.newCF();
Assert.assertEquals("someClientID", cf.getClientID());
assertEquals("someClientID", cf.getClientID());
} finally {
stopServer();

7
artemis-cli/src/test/java/org/apache/activemq/cli/test/StreamClassPathTest.java
View File

@ -17,12 +17,13 @@
package org.apache.activemq.cli.test;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.io.InputStream;
import org.apache.activemq.artemis.cli.commands.Create;
import org.apache.activemq.artemis.cli.commands.messages.Producer;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class StreamClassPathTest {
@ -70,7 +71,7 @@ public class StreamClassPathTest {
private void testStream(Class clazz, String source) throws Exception {
InputStream in = clazz.getResourceAsStream(source);
Assert.assertNotNull(source + " not found", in);
assertNotNull(in, source + " not found");
in.close();
}
}

17
artemis-cli/src/test/java/org/apache/activemq/cli/test/TransferTest.java
View File

@ -16,6 +16,8 @@
*/
package org.apache.activemq.cli.test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.apache.activemq.artemis.api.core.Pair;
import org.apache.activemq.artemis.api.core.QueueConfiguration;
import org.apache.activemq.artemis.api.core.RoutingType;
@ -25,10 +27,9 @@ import org.apache.activemq.artemis.core.server.Queue;
import org.apache.activemq.artemis.core.server.management.ManagementContext;
import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory;
import org.apache.activemq.artemis.utils.Wait;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import javax.jms.Connection;
import javax.jms.Session;
@ -39,7 +40,7 @@ public class TransferTest extends CliTestBase {
private ActiveMQServer server;
private static final int TEST_MESSAGE_COUNT = 10;
@Before
@BeforeEach
@Override
public void setup() throws Exception {
setupAuth();
@ -49,7 +50,7 @@ public class TransferTest extends CliTestBase {
connection = cf.createConnection("admin", "admin");
}
@After
@AfterEach
@Override
public void tearDown() throws Exception {
closeConnection(cf, connection);
@ -92,13 +93,13 @@ public class TransferTest extends CliTestBase {
if (limit > 0) {
transfer.setMessageCount(limit);
Assert.assertEquals(limit, transfer.execute(new TestActionContext()));
assertEquals(limit, transfer.execute(new TestActionContext()));
Queue targetQueue = server.locateQueue(targetQueueName);
Wait.assertEquals(messages - limit, sourceQueue::getMessageCount);
Wait.assertEquals(limit, targetQueue::getMessageCount);
} else {
Assert.assertEquals(messages, transfer.execute(new TestActionContext()));
assertEquals(messages, transfer.execute(new TestActionContext()));
Queue targetQueue = server.locateQueue(targetQueueName);
Wait.assertEquals(0, sourceQueue::getMessageCount);

10
artemis-commons/pom.xml
View File

@ -67,7 +67,6 @@
<artifactId>log4j-slf4j2-impl</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-buffer</artifactId>
@ -81,8 +80,13 @@
<artifactId>commons-beanutils</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>

41
artemis-commons/src/test/java/org/apache/activemq/artemis/api/core/QueueConfigurationTest.java
View File

@ -16,10 +16,15 @@
*/
package org.apache.activemq.artemis.api.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.utils.CompositeAddress;
import org.apache.activemq.artemis.utils.RandomUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class QueueConfigurationTest {
@ -27,19 +32,23 @@ public class QueueConfigurationTest {
public void testSetGroupRebalancePauseDispatch() {
QueueConfiguration queueConfiguration = new QueueConfiguration("TEST");
Assert.assertEquals(null, queueConfiguration.isGroupRebalancePauseDispatch());
assertNull(queueConfiguration.isGroupRebalancePauseDispatch());
queueConfiguration.setGroupRebalancePauseDispatch(true);
Assert.assertEquals(true, queueConfiguration.isGroupRebalancePauseDispatch());
assertNotNull(queueConfiguration.isGroupRebalancePauseDispatch());
assertTrue(queueConfiguration.isGroupRebalancePauseDispatch());
queueConfiguration.setGroupRebalancePauseDispatch(false);
Assert.assertEquals(false, queueConfiguration.isGroupRebalancePauseDispatch());
assertNotNull(queueConfiguration.isGroupRebalancePauseDispatch());
assertFalse(queueConfiguration.isGroupRebalancePauseDispatch());
queueConfiguration.set(QueueConfiguration.GROUP_REBALANCE_PAUSE_DISPATCH, Boolean.toString(true));
Assert.assertEquals(true, queueConfiguration.isGroupRebalancePauseDispatch());
assertNotNull(queueConfiguration.isGroupRebalancePauseDispatch());
assertTrue(queueConfiguration.isGroupRebalancePauseDispatch());
queueConfiguration.set(QueueConfiguration.GROUP_REBALANCE_PAUSE_DISPATCH, Boolean.toString(false));
Assert.assertEquals(false, queueConfiguration.isGroupRebalancePauseDispatch());
assertNotNull(queueConfiguration.isGroupRebalancePauseDispatch());
assertFalse(queueConfiguration.isGroupRebalancePauseDispatch());
}
@Test
@ -47,9 +56,9 @@ public class QueueConfigurationTest {
final SimpleString ADDRESS = RandomUtil.randomSimpleString();
final SimpleString QUEUE = RandomUtil.randomSimpleString();
QueueConfiguration queueConfiguration = new QueueConfiguration(CompositeAddress.toFullyQualified(ADDRESS, QUEUE));
Assert.assertEquals(ADDRESS, queueConfiguration.getAddress());
Assert.assertEquals(QUEUE, queueConfiguration.getName());
Assert.assertTrue(queueConfiguration.isFqqn());
assertEquals(ADDRESS, queueConfiguration.getAddress());
assertEquals(QUEUE, queueConfiguration.getName());
assertTrue(queueConfiguration.isFqqn());
}
@Test
@ -57,9 +66,9 @@ public class QueueConfigurationTest {
final SimpleString ADDRESS = RandomUtil.randomSimpleString();
final SimpleString QUEUE = RandomUtil.randomSimpleString();
QueueConfiguration queueConfiguration = new QueueConfiguration(QUEUE).setAddress(ADDRESS);
Assert.assertEquals(ADDRESS, queueConfiguration.getAddress());
Assert.assertEquals(QUEUE, queueConfiguration.getName());
Assert.assertFalse(queueConfiguration.isFqqn());
assertEquals(ADDRESS, queueConfiguration.getAddress());
assertEquals(QUEUE, queueConfiguration.getName());
assertFalse(queueConfiguration.isFqqn());
}
@Test
@ -67,8 +76,8 @@ public class QueueConfigurationTest {
final SimpleString ADDRESS = RandomUtil.randomSimpleString();
final SimpleString QUEUE = RandomUtil.randomSimpleString();
QueueConfiguration queueConfiguration = new QueueConfiguration(RandomUtil.randomSimpleString()).setAddress(CompositeAddress.toFullyQualified(ADDRESS, QUEUE));
Assert.assertEquals(ADDRESS, queueConfiguration.getAddress());
Assert.assertEquals(QUEUE, queueConfiguration.getName());
Assert.assertTrue(queueConfiguration.isFqqn());
assertEquals(ADDRESS, queueConfiguration.getAddress());
assertEquals(QUEUE, queueConfiguration.getName());
assertTrue(queueConfiguration.isFqqn());
}
}

18
artemis-commons/src/test/java/org/apache/activemq/artemis/logs/CommonsLogBundlesTest.java
View File

@ -16,14 +16,14 @@
*/
package org.apache.activemq.artemis.logs;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.api.core.ActiveMQIllegalStateException;
import org.apache.activemq.artemis.logs.AssertionLoggerHandler.LogLevel;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
public class CommonsLogBundlesTest {
@ -32,13 +32,13 @@ public class CommonsLogBundlesTest {
private static LogLevel origAuditLoggersLevel;
private static LogLevel origUtilLoggersLevel;
@BeforeClass
@BeforeAll
public static void setLogLevel() {
origAuditLoggersLevel = AssertionLoggerHandler.setLevel(AUDIT_LOGGERS, LogLevel.INFO);
origUtilLoggersLevel = AssertionLoggerHandler.setLevel(UTIL_LOGGER, LogLevel.INFO);
}
@AfterClass
@AfterAll
public static void restoreLogLevel() throws Exception {
AssertionLoggerHandler.setLevel(AUDIT_LOGGERS, origAuditLoggersLevel);
AssertionLoggerHandler.setLevel(UTIL_LOGGER, origUtilLoggersLevel);
@ -59,8 +59,8 @@ public class CommonsLogBundlesTest {
String message = e.getMessage();
assertNotNull(message);
assertTrue("unexpected message: " + message, message.startsWith("AMQ209000"));
assertTrue("unexpected message: " + message, message.contains("breadcrumb"));
assertTrue(message.startsWith("AMQ209000"), "unexpected message: " + message);
assertTrue(message.contains("breadcrumb"), "unexpected message: " + message);
}
@Test

58
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/ActiveMQScheduledComponentTest.java
View File

@ -16,6 +16,10 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@ -25,27 +29,23 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.activemq.artemis.core.server.ActiveMQScheduledComponent;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.apache.activemq.artemis.tests.util.ArtemisTestCase;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class ActiveMQScheduledComponentTest {
@Rule
public ThreadLeakCheckRule rule = new ThreadLeakCheckRule();
public class ActiveMQScheduledComponentTest extends ArtemisTestCase {
ScheduledExecutorService scheduledExecutorService;
ExecutorService executorService;
@Before
@BeforeEach
public void before() {
scheduledExecutorService = new ScheduledThreadPoolExecutor(5);
executorService = Executors.newSingleThreadExecutor();
}
@After
@AfterEach
public void after() {
executorService.shutdown();
scheduledExecutorService.shutdown();
@ -74,7 +74,7 @@ public class ActiveMQScheduledComponentTest {
local.stop();
Assert.assertTrue("just because one took a lot of time, it doesn't mean we can accumulate many, we got " + count + " executions", count.get() < 5);
assertTrue(count.get() < 5, "just because one took a lot of time, it doesn't mean we can accumulate many, we got " + count + " executions");
}
@Test
@ -89,7 +89,7 @@ public class ActiveMQScheduledComponentTest {
}
};
local.start();
Assert.assertTrue(triggered.await(10, TimeUnit.SECONDS));
assertTrue(triggered.await(10, TimeUnit.SECONDS));
local.stop();
}
@ -106,12 +106,12 @@ public class ActiveMQScheduledComponentTest {
local.start();
final long newInitialDelay = 1000;
//the parameters are valid?
Assert.assertTrue(initialDelay != newInitialDelay);
Assert.assertTrue(newInitialDelay != period);
assertTrue(initialDelay != newInitialDelay);
assertTrue(newInitialDelay != period);
local.setInitialDelay(newInitialDelay);
local.stop();
Assert.assertEquals("the initial dalay can't change", newInitialDelay, local.getInitialDelay());
assertEquals(newInitialDelay, local.getInitialDelay(), "the initial dalay can't change");
}
@Test
@ -137,7 +137,7 @@ public class ActiveMQScheduledComponentTest {
local.stop();
Assert.assertTrue("just because one took a lot of time, it doesn't mean we can accumulate many, we got " + count + " executions", count.get() <= 5 && count.get() > 0);
assertTrue(count.get() <= 5 && count.get() > 0, "just because one took a lot of time, it doesn't mean we can accumulate many, we got " + count + " executions");
}
@Test
@ -155,7 +155,7 @@ public class ActiveMQScheduledComponentTest {
local.start(); // should be ok to call start again
try {
Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));
assertTrue(latch.await(10, TimeUnit.SECONDS));
// re-scheduling the executor at a big interval..
// just to make sure it won't hung
@ -183,13 +183,13 @@ public class ActiveMQScheduledComponentTest {
try {
Assert.assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
local.delay();
Assert.assertTrue(latch.await(20, TimeUnit.MILLISECONDS));
assertTrue(latch.await(20, TimeUnit.MILLISECONDS));
latch.setCount(1);
Assert.assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
// re-scheduling the executor at a big interval..
// just to make sure it won't hung
@ -216,31 +216,31 @@ public class ActiveMQScheduledComponentTest {
local.start();
try {
Assert.assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
latch.setCount(1);
local.delay();
Assert.assertTrue(latch.await(20, TimeUnit.MILLISECONDS));
assertTrue(latch.await(20, TimeUnit.MILLISECONDS));
latch.setCount(1);
Assert.assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
local.setPeriod(TimeUnit.HOURS.toMillis(1), TimeUnit.MILLISECONDS);
latch.setCount(1);
local.delay();
Assert.assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
assertFalse(latch.await(20, TimeUnit.MILLISECONDS));
local.setPeriod(1);
local.delay();
Assert.assertTrue(latch.await(20, TimeUnit.MILLISECONDS));
assertTrue(latch.await(20, TimeUnit.MILLISECONDS));
local.setPeriod(1, TimeUnit.SECONDS);
latch.setCount(1);
local.delay();
Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
assertTrue(latch.await(5, TimeUnit.SECONDS));
} finally {
local.stop();
local.stop(); // calling stop again should not be an issue.
@ -263,8 +263,8 @@ public class ActiveMQScheduledComponentTest {
try {
final boolean triggeredBeforePeriod = latch.await(local.getPeriod(), local.getTimeUnit());
final long timeToFirstTrigger = TimeUnit.NANOSECONDS.convert(System.nanoTime() - start, local.getTimeUnit());
Assert.assertTrue("Takes too long to start", triggeredBeforePeriod);
Assert.assertTrue("Started too early", timeToFirstTrigger >= local.getInitialDelay());
assertTrue(triggeredBeforePeriod, "Takes too long to start");
assertTrue(timeToFirstTrigger >= local.getInitialDelay(), "Started too early");
} finally {
local.stop();
}

226
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/ByteUtilTest.java
View File

@ -16,6 +16,15 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeFalse;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.ReadOnlyBufferException;
@ -27,17 +36,10 @@ import java.util.Map;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.util.internal.PlatformDependent;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Test;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
public class ByteUtilTest {
@ -67,7 +69,7 @@ public class ByteUtilTest {
void testEquals(String string1, String string2) {
if (!string1.equals(string2)) {
Assert.fail("String are not the same:=" + string1 + "!=" + string2);
fail("String are not the same:=" + string1 + "!=" + string2);
}
}
@ -95,8 +97,8 @@ public class ByteUtilTest {
@Test
public void testUnsafeUnalignedByteArrayHashCode() {
Assume.assumeTrue(PlatformDependent.hasUnsafe());
Assume.assumeTrue(PlatformDependent.isUnaligned());
assumeTrue(PlatformDependent.hasUnsafe());
assumeTrue(PlatformDependent.isUnaligned());
Map<byte[], Integer> map = new LinkedHashMap<>();
map.put(new byte[0], 1);
map.put(new byte[]{1}, 32);
@ -113,14 +115,14 @@ public class ByteUtilTest {
map.put(new byte[]{-1, -1, -1, (byte) 0xE1}, -503316450);
}
for (Map.Entry<byte[], Integer> e : map.entrySet()) {
assertEquals("input = " + Arrays.toString(e.getKey()), e.getValue().intValue(), ByteUtil.hashCode(e.getKey()));
assertEquals(e.getValue().intValue(), ByteUtil.hashCode(e.getKey()), "input = " + Arrays.toString(e.getKey()));
}
}
@Test
public void testNoUnsafeAlignedByteArrayHashCode() {
Assume.assumeFalse(PlatformDependent.hasUnsafe());
Assume.assumeFalse(PlatformDependent.isUnaligned());
assumeFalse(PlatformDependent.hasUnsafe());
assumeFalse(PlatformDependent.isUnaligned());
ArrayList<byte[]> inputs = new ArrayList<>();
inputs.add(new byte[0]);
inputs.add(new byte[]{1});
@ -130,7 +132,7 @@ public class ByteUtilTest {
inputs.add(new byte[]{0, 1, 2, 3, 4, 5});
inputs.add(new byte[]{6, 7, 8, 9, 0, 1});
inputs.add(new byte[]{-1, -1, -1, (byte) 0xE1});
inputs.forEach(input -> assertEquals("input = " + Arrays.toString(input), Arrays.hashCode(input), ByteUtil.hashCode(input)));
inputs.forEach(input -> assertEquals(Arrays.hashCode(input), ByteUtil.hashCode(input), "input = " + Arrays.toString(input)));
}
@Test
@ -175,26 +177,26 @@ public class ByteUtilTest {
final int position = buffer.position();
final int limit = buffer.limit();
ByteUtil.zeros(buffer, offset, bytes);
Assert.assertEquals(position, buffer.position());
Assert.assertEquals(limit, buffer.limit());
assertEquals(position, buffer.position());
assertEquals(limit, buffer.limit());
final byte[] zeros = new byte[bytes];
final byte[] content = new byte[bytes];
final ByteBuffer duplicate = buffer.duplicate();
duplicate.clear().position(offset);
duplicate.get(content, 0, bytes);
Assert.assertArrayEquals(zeros, content);
assertArrayEquals(zeros, content);
if (originalRemaining != null) {
final byte[] remaining = new byte[duplicate.remaining()];
//duplicate position has been moved of bytes
duplicate.get(remaining);
Assert.assertArrayEquals(originalRemaining, remaining);
assertArrayEquals(originalRemaining, remaining);
}
if (originalBefore != null) {
final byte[] before = new byte[offset];
//duplicate position has been moved of bytes: need to reset it
duplicate.position(0);
duplicate.get(before);
Assert.assertArrayEquals(originalBefore, before);
assertArrayEquals(originalBefore, before);
}
}
@ -263,96 +265,106 @@ public class ByteUtilTest {
shouldZeroesByteBuffer(buffer, offset, bytes);
}
@Test(expected = ReadOnlyBufferException.class)
@Test
public void shouldFailWithReadOnlyHeapByteBuffer() {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = 32;
final int offset = 1;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
buffer = buffer.asReadOnlyBuffer();
shouldZeroesByteBuffer(buffer, offset, bytes);
assertThrows(ReadOnlyBufferException.class, () -> {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = 32;
final int offset = 1;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
buffer = buffer.asReadOnlyBuffer();
shouldZeroesByteBuffer(buffer, offset, bytes);
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void shouldFailIfOffsetIsGreaterOrEqualHeapByteBufferCapacity() {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = 0;
final int offset = 64;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
try {
shouldZeroesByteBuffer(buffer, offset, bytes);
} catch (IndexOutOfBoundsException expectedEx) {
//verify that the buffer hasn't changed
final byte[] originalContent = duplicateRemaining(buffer, 0, 0);
final byte[] expectedContent = new byte[capacity];
Arrays.fill(expectedContent, one);
Assert.assertArrayEquals(expectedContent, originalContent);
throw expectedEx;
}
assertThrows(IndexOutOfBoundsException.class, () -> {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = 0;
final int offset = 64;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
try {
shouldZeroesByteBuffer(buffer, offset, bytes);
} catch (IndexOutOfBoundsException expectedEx) {
//verify that the buffer hasn't changed
final byte[] originalContent = duplicateRemaining(buffer, 0, 0);
final byte[] expectedContent = new byte[capacity];
Arrays.fill(expectedContent, one);
assertArrayEquals(expectedContent, originalContent);
throw expectedEx;
}
});
}
@Test(expected = IllegalArgumentException.class)
@Test
public void shouldFailIfOffsetIsNegative() {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = 1;
final int offset = -1;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
try {
shouldZeroesByteBuffer(buffer, offset, bytes);
} catch (IndexOutOfBoundsException expectedEx) {
//verify that the buffer hasn't changed
final byte[] originalContent = duplicateRemaining(buffer, 0, 0);
final byte[] expectedContent = new byte[capacity];
Arrays.fill(expectedContent, one);
Assert.assertArrayEquals(expectedContent, originalContent);
throw expectedEx;
}
assertThrows(IllegalArgumentException.class, () -> {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = 1;
final int offset = -1;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
try {
shouldZeroesByteBuffer(buffer, offset, bytes);
} catch (IndexOutOfBoundsException expectedEx) {
//verify that the buffer hasn't changed
final byte[] originalContent = duplicateRemaining(buffer, 0, 0);
final byte[] expectedContent = new byte[capacity];
Arrays.fill(expectedContent, one);
assertArrayEquals(expectedContent, originalContent);
throw expectedEx;
}
});
}
@Test(expected = IllegalArgumentException.class)
@Test
public void shouldFailIfBytesIsNegative() {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = -1;
final int offset = 0;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
try {
shouldZeroesByteBuffer(buffer, offset, bytes);
} catch (IndexOutOfBoundsException expectedEx) {
//verify that the buffer hasn't changed
final byte[] originalContent = duplicateRemaining(buffer, 0, 0);
final byte[] expectedContent = new byte[capacity];
Arrays.fill(expectedContent, one);
Assert.assertArrayEquals(expectedContent, originalContent);
throw expectedEx;
}
assertThrows(IllegalArgumentException.class, () -> {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = -1;
final int offset = 0;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
try {
shouldZeroesByteBuffer(buffer, offset, bytes);
} catch (IndexOutOfBoundsException expectedEx) {
//verify that the buffer hasn't changed
final byte[] originalContent = duplicateRemaining(buffer, 0, 0);
final byte[] expectedContent = new byte[capacity];
Arrays.fill(expectedContent, one);
assertArrayEquals(expectedContent, originalContent);
throw expectedEx;
}
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void shouldFailIfExceedingHeapByteBufferCapacity() {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = 65;
final int offset = 1;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
try {
shouldZeroesByteBuffer(buffer, offset, bytes);
} catch (IndexOutOfBoundsException expectedEx) {
//verify that the buffer hasn't changed
final byte[] originalContent = duplicateRemaining(buffer, 0, 0);
final byte[] expectedContent = new byte[capacity];
Arrays.fill(expectedContent, one);
Assert.assertArrayEquals(expectedContent, originalContent);
throw expectedEx;
}
assertThrows(IndexOutOfBoundsException.class, () -> {
final byte one = (byte) 1;
final int capacity = 64;
final int bytes = 65;
final int offset = 1;
ByteBuffer buffer = ByteBuffer.allocate(capacity);
fill(buffer, 0, capacity, one);
try {
shouldZeroesByteBuffer(buffer, offset, bytes);
} catch (IndexOutOfBoundsException expectedEx) {
//verify that the buffer hasn't changed
final byte[] originalContent = duplicateRemaining(buffer, 0, 0);
final byte[] expectedContent = new byte[capacity];
Arrays.fill(expectedContent, one);
assertArrayEquals(expectedContent, originalContent);
throw expectedEx;
}
});
}
@Test
@ -368,7 +380,7 @@ public class ByteUtilTest {
byte[] expected = ByteBuffer.allocate(4).putInt(intValue).array();
byte[] actual = ByteUtil.intToBytes(intValue);
if (manualExpect != null) {
Assert.assertEquals(4, manualExpect.length);
assertEquals(4, manualExpect.length);
assertArrayEquals(manualExpect, actual);
}
assertArrayEquals(expected, actual);
@ -390,7 +402,7 @@ public class ByteUtilTest {
byte[] expected = ByteBuffer.allocate(8).putLong(longValue).array();
byte[] actual = ByteUtil.longToBytes(longValue);
if (manualExpected != null) {
Assert.assertEquals(8, manualExpected.length);
assertEquals(8, manualExpected.length);
assertArrayEquals(manualExpected, actual);
}
assertArrayEquals(expected, actual);
@ -413,12 +425,14 @@ public class ByteUtilTest {
assertArrayEquals(assertContent, convertedContent);
}
@Test(expected = IllegalArgumentException.class)
@Test
public void shouldEnsureExactWritableFailToEnlargeWrappedByteBuf() {
byte[] wrapped = new byte[32];
ByteBuf buffer = Unpooled.wrappedBuffer(wrapped);
buffer.writerIndex(wrapped.length);
ByteUtil.ensureExactWritable(buffer, 1);
assertThrows(IllegalArgumentException.class, () -> {
byte[] wrapped = new byte[32];
ByteBuf buffer = Unpooled.wrappedBuffer(wrapped);
buffer.writerIndex(wrapped.length);
ByteUtil.ensureExactWritable(buffer, 1);
});
}
@Test
@ -427,7 +441,7 @@ public class ByteUtilTest {
ByteBuf buffer = Unpooled.wrappedBuffer(wrapped);
buffer.writerIndex(wrapped.length - 1);
ByteUtil.ensureExactWritable(buffer, 1);
Assert.assertSame(wrapped, buffer.array());
assertSame(wrapped, buffer.array());
}
@Test
@ -435,7 +449,7 @@ public class ByteUtilTest {
ByteBuf buffer = Unpooled.buffer(32);
buffer.writerIndex(32);
ByteUtil.ensureExactWritable(buffer, 1);
Assert.assertEquals(33, buffer.capacity());
assertEquals(33, buffer.capacity());
}
}

63
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/ConcurrentHashSetTest.java
View File

@ -16,15 +16,18 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Iterator;
import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
import org.apache.activemq.artemis.utils.collections.ConcurrentSet;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class ConcurrentHashSetTest extends Assert {
public class ConcurrentHashSetTest {
private ConcurrentSet<String> set;
@ -34,64 +37,64 @@ public class ConcurrentHashSetTest extends Assert {
@Test
public void testAdd() throws Exception {
Assert.assertTrue(set.add(element));
Assert.assertFalse(set.add(element));
assertTrue(set.add(element));
assertFalse(set.add(element));
}
@Test
public void testAddIfAbsent() throws Exception {
Assert.assertTrue(set.addIfAbsent(element));
Assert.assertFalse(set.addIfAbsent(element));
assertTrue(set.addIfAbsent(element));
assertFalse(set.addIfAbsent(element));
}
@Test
public void testRemove() throws Exception {
Assert.assertTrue(set.add(element));
assertTrue(set.add(element));
Assert.assertTrue(set.remove(element));
Assert.assertFalse(set.remove(element));
assertTrue(set.remove(element));
assertFalse(set.remove(element));
}
@Test
public void testContains() throws Exception {
Assert.assertFalse(set.contains(element));
assertFalse(set.contains(element));
Assert.assertTrue(set.add(element));
Assert.assertTrue(set.contains(element));
assertTrue(set.add(element));
assertTrue(set.contains(element));
Assert.assertTrue(set.remove(element));
Assert.assertFalse(set.contains(element));
assertTrue(set.remove(element));
assertFalse(set.contains(element));
}
@Test
public void testSize() throws Exception {
Assert.assertEquals(0, set.size());
assertEquals(0, set.size());
Assert.assertTrue(set.add(element));
Assert.assertEquals(1, set.size());
assertTrue(set.add(element));
assertEquals(1, set.size());
Assert.assertTrue(set.remove(element));
Assert.assertEquals(0, set.size());
assertTrue(set.remove(element));
assertEquals(0, set.size());
}
@Test
public void testClear() throws Exception {
Assert.assertTrue(set.add(element));
assertTrue(set.add(element));
Assert.assertTrue(set.contains(element));
assertTrue(set.contains(element));
set.clear();
Assert.assertFalse(set.contains(element));
assertFalse(set.contains(element));
}
@Test
public void testIsEmpty() throws Exception {
Assert.assertTrue(set.isEmpty());
assertTrue(set.isEmpty());
Assert.assertTrue(set.add(element));
Assert.assertFalse(set.isEmpty());
assertTrue(set.add(element));
assertFalse(set.isEmpty());
set.clear();
Assert.assertTrue(set.isEmpty());
assertTrue(set.isEmpty());
}
@Test
@ -101,11 +104,11 @@ public class ConcurrentHashSetTest extends Assert {
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
String e = iterator.next();
Assert.assertEquals(element, e);
assertEquals(element, e);
}
}
@Before
@BeforeEach
public void setUp() throws Exception {
set = new ConcurrentHashSet<>();
element = RandomUtil.randomString();

16
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/DefaultSensitiveStringCodecTest.java
View File

@ -16,20 +16,20 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
public class DefaultSensitiveStringCodecTest {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@ -68,7 +68,7 @@ public class DefaultSensitiveStringCodecTest {
String decoded = codec.decode(maskedText);
logger.debug("encoded value: {}", maskedText);
assertEquals("decoded result not match: " + decoded, decoded, plainText);
assertEquals(decoded, plainText, "decoded result not match: " + decoded);
}
assertTrue(codec.verify(plainText.toCharArray(), maskedText));

15
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/HashProcessorTest.java
View File

@ -16,16 +16,17 @@
*/
package org.apache.activemq.artemis.utils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.Arrays;
import java.util.Collection;
import static org.junit.Assert.assertEquals;
import org.apache.activemq.artemis.tests.extensions.parameterized.ParameterizedTestExtension;
import org.apache.activemq.artemis.tests.extensions.parameterized.Parameters;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
@RunWith(Parameterized.class)
@ExtendWith(ParameterizedTestExtension.class)
public class HashProcessorTest {
private static final String USER1_PASSWORD = "password";
@ -36,7 +37,7 @@ public class HashProcessorTest {
private static final String USER3_PASSWORD = "artemis000";
@Parameterized.Parameters(name = "{index}: testing password {0}")
@Parameters(name = "{index}: testing password {0}")
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][] {
{USER1_PASSWORD, USER1_HASHED_PASSWORD, true},
@ -57,7 +58,7 @@ public class HashProcessorTest {
this.match = match;
}
@Test
@TestTemplate
public void testPasswordVerification() throws Exception {
HashProcessor processor = PasswordMaskingUtil.getHashProcessor(storedPassword);
boolean result = processor.compare(password.toCharArray(), storedPassword);

6
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/HumanReadableByteCountTest.java
View File

@ -16,13 +16,13 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Locale;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.jupiter.api.Test;
public class HumanReadableByteCountTest {

4
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/IPv6UtilTest.java
View File

@ -16,9 +16,9 @@
*/
package org.apache.activemq.artemis.utils;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertEquals;
import org.junit.jupiter.api.Test;
public class IPv6UtilTest {

20
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/MaskPasswordResolvingTest.java
View File

@ -16,19 +16,21 @@
*/
package org.apache.activemq.artemis.utils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.apache.activemq.artemis.tests.extensions.parameterized.ParameterizedTestExtension;
import org.apache.activemq.artemis.tests.extensions.parameterized.Parameters;
import org.apache.activemq.artemis.tests.util.ArtemisTestCase;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class)
public class MaskPasswordResolvingTest {
@ExtendWith(ParameterizedTestExtension.class)
public class MaskPasswordResolvingTest extends ArtemisTestCase {
private static final String plainPassword = "password";
private static final String defaultMaskPassword = "defaultmasked";
@ -37,7 +39,7 @@ public class MaskPasswordResolvingTest {
private static final String oldCustomizedCodecPassword = "secret";
private static final String oldExplicitPlainPassword = "PASSWORD";
@Parameterized.Parameters(name = "mask({0})password({1})codec({2})")
@Parameters(name = "mask({0})password({1})codec({2})")
public static Collection<Object[]> params() {
return Arrays.asList(new Object[][]{{null, plainPassword, null},
{null, "ENC(3bdfd94fe8cdf710e7fefa72f809ea90)", null},
@ -58,7 +60,7 @@ public class MaskPasswordResolvingTest {
this.codec = codec;
}
@Test
@TestTemplate
public void testPasswordResolving() throws Exception {
String resolved = PasswordMaskingUtil.resolveMask(maskPassword, password, codec);
checkResult(resolved);

81
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/NetworkHealthTest.java
View File

@ -16,6 +16,12 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Inet6Address;
@ -32,12 +38,10 @@ import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import org.apache.activemq.artemis.core.server.ActiveMQComponent;
import org.apache.activemq.artemis.core.server.NetworkHealthCheck;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assume.assumeTrue;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
public class NetworkHealthTest {
@ -87,13 +91,13 @@ public class NetworkHealthTest {
}
};
@Before
@BeforeEach
public void before() throws Exception {
latch.setCount(1);
}
private void startHTTPServer() throws IOException {
Assert.assertNull(httpServer);
assertNull(httpServer);
InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8787);
httpServer = HttpServer.create(address, 100);
httpServer.start();
@ -119,7 +123,7 @@ public class NetworkHealthTest {
}
}
@After
@AfterEach
public void after() {
stopHTTPServer();
for (NetworkHealthCheck check : this.list) {
@ -135,11 +139,11 @@ public class NetworkHealthTest {
InetAddress address = InetAddress.getByName(IPV6_LOCAL);
Assert.assertTrue(address instanceof Inet6Address);
assertTrue(address instanceof Inet6Address);
Assert.assertTrue(check.purePing(address));
assertTrue(check.purePing(address));
Assert.assertTrue(check.check(address));
assertTrue(check.check(address));
}
@Test
@ -159,9 +163,9 @@ public class NetworkHealthTest {
component.stop();
latch.setCount(1);
Assert.assertTrue(latch.await(1, TimeUnit.MINUTES));
assertTrue(latch.await(1, TimeUnit.MINUTES));
Assert.assertFalse("NetworkHealthCheck should have no business on restarting the component, the network was never down, hence no check needed!", component.isStarted());
assertFalse(component.isStarted(), "NetworkHealthCheck should have no business on restarting the component, the network was never down, hence no check needed!");
}
@ -171,7 +175,7 @@ public class NetworkHealthTest {
// using two addresses for URI and localhost
check.parseAddressList("localhost, , 127.0.0.2");
Assert.assertEquals(2, check.getAddresses().size());
assertEquals(2, check.getAddresses().size());
}
@Test
@ -180,8 +184,8 @@ public class NetworkHealthTest {
// using two addresses for URI and localhost
check.parseAddressList("localhost, , 127.0.0.2");
Assert.assertEquals(2, check.getAddresses().size());
Assert.assertEquals(0, check.getUrls().size());
assertEquals(2, check.getAddresses().size());
assertEquals(0, check.getUrls().size());
}
@Test
@ -197,11 +201,11 @@ public class NetworkHealthTest {
// Any external IP, to make sure we would use a PING
InetAddress address = InetAddress.getByName(localaddress);
Assert.assertTrue(check.check(address));
assertTrue(check.check(address));
Assert.assertTrue(check.purePing(address));
assertTrue(check.purePing(address));
Assert.assertFalse(check.purePing(INVALID_ADDRESS));
assertFalse(check.purePing(INVALID_ADDRESS));
}
@ -222,7 +226,7 @@ public class NetworkHealthTest {
@Test
public void testCheckNoNodes() throws Exception {
NetworkHealthCheck check = addCheck(new NetworkHealthCheck());
Assert.assertTrue(check.check());
assertTrue(check.check());
}
@Test
@ -232,38 +236,38 @@ public class NetworkHealthTest {
NetworkHealthCheck check = addCheck(new NetworkHealthCheck(null, 100, 1000));
Assert.assertTrue(check.check(new URL("http://localhost:8787")));
assertTrue(check.check(new URL("http://localhost:8787")));
stopHTTPServer();
Assert.assertFalse(check.check(new URL("http://localhost:8787")));
assertFalse(check.check(new URL("http://localhost:8787")));
check.addComponent(component);
URL url = new URL("http://localhost:8787");
Assert.assertFalse(check.check(url));
assertFalse(check.check(url));
startHTTPServer();
Assert.assertTrue(check.check(url));
assertTrue(check.check(url));
check.addURL(url);
Assert.assertFalse(latch.await(500, TimeUnit.MILLISECONDS));
Assert.assertTrue(component.isStarted());
assertFalse(latch.await(500, TimeUnit.MILLISECONDS));
assertTrue(component.isStarted());
// stopping the web server should stop the component
stopHTTPServer();
Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));
Assert.assertFalse(component.isStarted());
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertFalse(component.isStarted());
latch.setCount(1);
startHTTPServer();
Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));
Assert.assertTrue(component.isStarted());
assertTrue(latch.await(10, TimeUnit.SECONDS));
assertTrue(component.isStarted());
}
@ -292,8 +296,8 @@ public class NetworkHealthTest {
myCheck.check(InetAddress.getByName("127.0.0.1"));
Assert.assertEquals(0, isReacheable.get());
Assert.assertEquals(1, purePing.get());
assertEquals(0, isReacheable.get());
assertEquals(1, purePing.get());
}
@Test
@ -320,18 +324,19 @@ public class NetworkHealthTest {
myCheck.check(InetAddress.getByName("127.0.0.1"));
Assert.assertEquals(1, isReacheable.get());
Assert.assertEquals(0, purePing.get());
assertEquals(1, isReacheable.get());
assertEquals(0, purePing.get());
}
@Test(timeout = 30_000)
@Test
@Timeout(value = 30_000, unit = TimeUnit.MILLISECONDS)
public void testPurePingTimeout() throws Exception {
NetworkHealthCheck check = new NetworkHealthCheck(null, 100, 2000);
long time = System.currentTimeMillis();
//[RFC1166] reserves the address block 192.0.2.0/24 for test.
Assert.assertFalse(check.purePing(InetAddress.getByName("192.0.2.0")));
Assert.assertTrue(System.currentTimeMillis() - time >= 2000);
assertFalse(check.purePing(InetAddress.getByName("192.0.2.0")));
assertTrue(System.currentTimeMillis() - time >= 2000);
}
}

9
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/PairTest.java
View File

@ -16,11 +16,12 @@
*/
package org.apache.activemq.artemis.utils;
import org.apache.activemq.artemis.api.core.Pair;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class PairTest extends Assert {
import org.apache.activemq.artemis.api.core.Pair;
import org.junit.jupiter.api.Test;
public class PairTest {
@Test
public void testPair() {

11
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/PasswordMaskingUtilTest.java
View File

@ -16,9 +16,10 @@
*/
package org.apache.activemq.artemis.utils;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.Test;
public class PasswordMaskingUtilTest {
@ -28,8 +29,10 @@ public class PasswordMaskingUtilTest {
assertTrue(codec instanceof DefaultSensitiveStringCodec);
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testGetCodecUsingInvalidCodec() throws Exception {
PasswordMaskingUtil.getCodec("codec doesn't exist");
assertThrows(IllegalArgumentException.class, () -> {
PasswordMaskingUtil.getCodec("codec doesn't exist");
});
}
}

18
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/PowerOf2UtilTest.java
View File

@ -16,27 +16,27 @@
*/
package org.apache.activemq.artemis.utils;
import org.junit.Assert;
import org.junit.Test;
import static org.apache.activemq.artemis.utils.PowerOf2Util.align;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class PowerOf2UtilTest {
@Test
public void shouldAlignToNextMultipleOfAlignment() {
final int alignment = 512;
Assert.assertEquals(0, align(0, alignment));
Assert.assertEquals(alignment, align(1, alignment));
Assert.assertEquals(alignment, align(alignment, alignment));
Assert.assertEquals(alignment * 2, align(alignment + 1, alignment));
assertEquals(0, align(0, alignment));
assertEquals(alignment, align(1, alignment));
assertEquals(alignment, align(alignment, alignment));
assertEquals(alignment * 2, align(alignment + 1, alignment));
final int remainder = Integer.MAX_VALUE % alignment;
final int alignedMax = Integer.MAX_VALUE - remainder;
Assert.assertEquals(alignedMax, align(alignedMax, alignment));
assertEquals(alignedMax, align(alignedMax, alignment));
//given that Integer.MAX_VALUE is the max value that can be represented with int
//the aligned value would be > 2^32, but (int)(2^32) = Integer.MIN_VALUE due to the sign bit
Assert.assertEquals(Integer.MIN_VALUE, align(Integer.MAX_VALUE, alignment));
assertEquals(Integer.MIN_VALUE, align(Integer.MAX_VALUE, alignment));
}
}

9
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/ReferenceCounterTest.java
View File

@ -16,16 +16,19 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class ReferenceCounterTest extends Assert {
public class ReferenceCounterTest {
class LatchRunner implements Runnable {

15
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/SimpleFutureTest.java
View File

@ -16,14 +16,13 @@
*/
package org.apache.activemq.artemis.utils;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class SimpleFutureTest {
import org.apache.activemq.artemis.tests.util.ArtemisTestCase;
import org.junit.jupiter.api.Test;
@Rule
public ThreadLeakCheckRule threadLeakCheckRule = new ThreadLeakCheckRule();
public class SimpleFutureTest extends ArtemisTestCase {
@Test
public void testFuture() throws Exception {
@ -37,7 +36,7 @@ public class SimpleFutureTest {
};
t.start();
Assert.assertEquals(randomStart, simpleFuture.get().longValue());
assertEquals(randomStart, simpleFuture.get().longValue());
}
@ -60,7 +59,7 @@ public class SimpleFutureTest {
}
Assert.assertTrue(failed);
assertTrue(failed);
}

6
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/SimpleStringTest.java
View File

@ -16,12 +16,12 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertTrue;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import org.apache.activemq.artemis.api.core.SimpleString;
import org.junit.Test;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.Test;
public class SimpleStringTest {

325
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/SizeAwareMetricTest.java
View File

@ -16,6 +16,10 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
@ -24,9 +28,8 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
public class SizeAwareMetricTest {
@ -38,11 +41,11 @@ public class SizeAwareMetricTest {
}
}
@After
@AfterEach
public void shutdownExecutor() throws Exception {
if (executor != null) {
executor.shutdownNow();
Assert.assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS));
assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS));
executor = null;
}
}
@ -66,53 +69,53 @@ public class SizeAwareMetricTest {
child.addSize(1, true);
}
Assert.assertEquals(4, child.getSize());
Assert.assertEquals(4, parent.getSize());
Assert.assertEquals(0, child.getElements());
Assert.assertEquals(0, parent.getElements());
Assert.assertFalse(childBoolean.get());
Assert.assertFalse(parentBoolean.get());
assertEquals(4, child.getSize());
assertEquals(4, parent.getSize());
assertEquals(0, child.getElements());
assertEquals(0, parent.getElements());
assertFalse(childBoolean.get());
assertFalse(parentBoolean.get());
child.addSize(1, true);
Assert.assertEquals(5, child.getSize());
Assert.assertTrue(childBoolean.get());
Assert.assertFalse(parentBoolean.get());
Assert.assertEquals(0, child.getElements());
Assert.assertEquals(0, parent.getElements());
assertEquals(5, child.getSize());
assertTrue(childBoolean.get());
assertFalse(parentBoolean.get());
assertEquals(0, child.getElements());
assertEquals(0, parent.getElements());
child.addSize(-5, true);
Assert.assertEquals(0, child.getSize());
Assert.assertEquals(0, parent.getSize());
assertEquals(0, child.getSize());
assertEquals(0, parent.getSize());
for (int i = 0; i < 5; i++) {
child.addSize(1, false);
}
Assert.assertEquals(5, child.getSize());
Assert.assertEquals(5, parent.getSize());
Assert.assertEquals(5, child.getElements());
Assert.assertEquals(5, parent.getElements());
Assert.assertTrue(childBoolean.get());
Assert.assertFalse(parentBoolean.get());
Assert.assertTrue(child.isOverElements());
assertEquals(5, child.getSize());
assertEquals(5, parent.getSize());
assertEquals(5, child.getElements());
assertEquals(5, parent.getElements());
assertTrue(childBoolean.get());
assertFalse(parentBoolean.get());
assertTrue(child.isOverElements());
for (int i = 0; i < 5; i++) {
child.addSize(1, false);
}
Assert.assertEquals(10, child.getSize());
Assert.assertEquals(10, parent.getSize());
Assert.assertEquals(10, child.getElements());
Assert.assertEquals(10, parent.getElements());
assertEquals(10, child.getSize());
assertEquals(10, parent.getSize());
assertEquals(10, child.getElements());
assertEquals(10, parent.getElements());
Assert.assertTrue(childBoolean.get());
Assert.assertTrue(parentBoolean.get());
Assert.assertTrue(child.isOverElements());
Assert.assertFalse(parent.isOverElements());
Assert.assertTrue(parent.isOverSize());
assertTrue(childBoolean.get());
assertTrue(parentBoolean.get());
assertTrue(child.isOverElements());
assertFalse(parent.isOverElements());
assertTrue(parent.isOverSize());
}
@ -174,27 +177,27 @@ public class SizeAwareMetricTest {
}
flagStart.await(10, TimeUnit.SECONDS);
Assert.assertTrue(latchDone.await(10, TimeUnit.SECONDS));
assertTrue(latchDone.await(10, TimeUnit.SECONDS));
Assert.assertTrue(metricOver.get());
Assert.assertTrue(metric.isOver());
Assert.assertTrue(metric.isOverSize());
Assert.assertFalse(metric.isOverElements());
assertTrue(metricOver.get());
assertTrue(metric.isOver());
assertTrue(metric.isOverSize());
assertFalse(metric.isOverElements());
Assert.assertTrue(globalMetricOver.get());
Assert.assertTrue(globalMetric.isOver());
assertTrue(globalMetricOver.get());
assertTrue(globalMetric.isOver());
Assert.assertEquals(1, metricOverCalls.get());
Assert.assertEquals(1, globalMetricOverCalls.get());
Assert.assertEquals(0, metricUnderCalls.get());
Assert.assertEquals(0, globalMetricUnderCalls.get());
assertEquals(1, metricOverCalls.get());
assertEquals(1, globalMetricOverCalls.get());
assertEquals(0, metricUnderCalls.get());
assertEquals(0, globalMetricUnderCalls.get());
Assert.assertEquals(ELEMENTS * THREADS, metric.getSize());
Assert.assertEquals(ELEMENTS * THREADS, metric.getElements());
Assert.assertEquals(ELEMENTS * THREADS, globalMetric.getSize());
Assert.assertEquals(ELEMENTS * THREADS, globalMetric.getElements());
assertEquals(ELEMENTS * THREADS, metric.getSize());
assertEquals(ELEMENTS * THREADS, metric.getElements());
assertEquals(ELEMENTS * THREADS, globalMetric.getSize());
assertEquals(ELEMENTS * THREADS, globalMetric.getElements());
Assert.assertEquals(0, errors.get());
assertEquals(0, errors.get());
latchDone.setCount(10);
@ -215,14 +218,14 @@ public class SizeAwareMetricTest {
}
flagStart.await(10, TimeUnit.SECONDS);
Assert.assertTrue(latchDone.await(10, TimeUnit.SECONDS));
assertTrue(latchDone.await(10, TimeUnit.SECONDS));
Assert.assertEquals(0, globalMetric.getSize());
Assert.assertEquals(0, globalMetric.getElements());
Assert.assertEquals(0, metric.getSize());
Assert.assertEquals(0, metric.getElements());
Assert.assertFalse(globalMetricOver.get());
Assert.assertFalse(globalMetric.isOver());
assertEquals(0, globalMetric.getSize());
assertEquals(0, globalMetric.getElements());
assertEquals(0, metric.getSize());
assertEquals(0, metric.getElements());
assertFalse(globalMetricOver.get());
assertFalse(globalMetric.isOver());
}
@ -238,16 +241,16 @@ public class SizeAwareMetricTest {
metric.addSize(10, false);
}
Assert.assertTrue(over.get());
Assert.assertEquals(110, metric.getSize());
Assert.assertEquals(11, metric.getElements());
assertTrue(over.get());
assertEquals(110, metric.getSize());
assertEquals(11, metric.getElements());
metric.addSize(1000, false);
for (int i = 0; i < 12; i++) {
metric.addSize(-10, false);
}
Assert.assertFalse(over.get());
assertFalse(over.get());
}
@Test
@ -266,35 +269,35 @@ public class SizeAwareMetricTest {
}
metric.addSize(1000, true);
Assert.assertEquals(1110L, metricMain.getSize());
Assert.assertEquals(11, metricMain.getElements());
Assert.assertEquals(1110L, metric.getSize());
Assert.assertEquals(11, metric.getElements());
Assert.assertTrue(metricMain.isOverElements());
Assert.assertFalse(metricMain.isOverSize());
Assert.assertFalse(metric.isOverElements());
Assert.assertFalse(metric.isOverSize());
Assert.assertTrue(over.get());
assertEquals(1110L, metricMain.getSize());
assertEquals(11, metricMain.getElements());
assertEquals(1110L, metric.getSize());
assertEquals(11, metric.getElements());
assertTrue(metricMain.isOverElements());
assertFalse(metricMain.isOverSize());
assertFalse(metric.isOverElements());
assertFalse(metric.isOverSize());
assertTrue(over.get());
metric.addSize(-1000, true);
Assert.assertEquals(110L, metricMain.getSize());
Assert.assertEquals(11, metricMain.getElements());
Assert.assertTrue(metricMain.isOverElements());
Assert.assertFalse(metricMain.isOverSize());
Assert.assertTrue(over.get());
assertEquals(110L, metricMain.getSize());
assertEquals(11, metricMain.getElements());
assertTrue(metricMain.isOverElements());
assertFalse(metricMain.isOverSize());
assertTrue(over.get());
for (int i = 0; i < 11; i++) {
metric.addSize(-10);
}
Assert.assertEquals(0L, metricMain.getSize());
Assert.assertEquals(0L, metricMain.getElements());
Assert.assertFalse(metricMain.isOver());
Assert.assertEquals(0L, metric.getSize());
Assert.assertEquals(0L, metric.getElements());
Assert.assertFalse(metric.isOver());
Assert.assertFalse(over.get());
assertEquals(0L, metricMain.getSize());
assertEquals(0L, metricMain.getElements());
assertFalse(metricMain.isOver());
assertEquals(0L, metric.getSize());
assertEquals(0L, metric.getElements());
assertFalse(metric.isOver());
assertFalse(over.get());
}
@ -311,28 +314,28 @@ public class SizeAwareMetricTest {
}
metric.addSize(1000, true);
Assert.assertEquals(1110L, metric.getSize());
Assert.assertEquals(11, metric.getElements());
Assert.assertTrue(metric.isOverElements());
Assert.assertFalse(metric.isOverSize());
Assert.assertTrue(over.get());
assertEquals(1110L, metric.getSize());
assertEquals(11, metric.getElements());
assertTrue(metric.isOverElements());
assertFalse(metric.isOverSize());
assertTrue(over.get());
metric.addSize(-1000, true);
Assert.assertEquals(110L, metric.getSize());
Assert.assertEquals(11, metric.getElements());
Assert.assertTrue(metric.isOverElements());
Assert.assertFalse(metric.isOverSize());
Assert.assertTrue(over.get());
assertEquals(110L, metric.getSize());
assertEquals(11, metric.getElements());
assertTrue(metric.isOverElements());
assertFalse(metric.isOverSize());
assertTrue(over.get());
for (int i = 0; i < 11; i++) {
metric.addSize(-10);
}
Assert.assertEquals(0L, metric.getSize());
Assert.assertEquals(0L, metric.getElements());
Assert.assertFalse(metric.isOver());
Assert.assertFalse(over.get());
assertEquals(0L, metric.getSize());
assertEquals(0L, metric.getElements());
assertFalse(metric.isOver());
assertFalse(over.get());
}
@Test
@ -397,30 +400,30 @@ public class SizeAwareMetricTest {
}
flagStart.await(10, TimeUnit.SECONDS);
Assert.assertTrue(latchDone.await(10, TimeUnit.SECONDS));
assertTrue(latchDone.await(10, TimeUnit.SECONDS));
for (SizeAwareMetric theMetric : metric) {
Assert.assertTrue(theMetric.isOver());
Assert.assertEquals(ELEMENTS, theMetric.getSize());
Assert.assertEquals(ELEMENTS, theMetric.getElements());
assertTrue(theMetric.isOver());
assertEquals(ELEMENTS, theMetric.getSize());
assertEquals(ELEMENTS, theMetric.getElements());
}
for (AtomicBoolean theBool : metricOverArray) {
Assert.assertTrue(theBool.get());
assertTrue(theBool.get());
}
Assert.assertTrue(globalMetricOver.get());
Assert.assertTrue(globalMetric.isOver());
assertTrue(globalMetricOver.get());
assertTrue(globalMetric.isOver());
Assert.assertEquals(10, metricOverCalls.get());
Assert.assertEquals(1, globalMetricOverCalls.get());
Assert.assertEquals(0, metricUnderCalls.get());
Assert.assertEquals(0, globalMetricUnderCalls.get());
assertEquals(10, metricOverCalls.get());
assertEquals(1, globalMetricOverCalls.get());
assertEquals(0, metricUnderCalls.get());
assertEquals(0, globalMetricUnderCalls.get());
Assert.assertEquals(ELEMENTS * THREADS, globalMetric.getSize());
Assert.assertEquals(ELEMENTS * THREADS, globalMetric.getElements());
assertEquals(ELEMENTS * THREADS, globalMetric.getSize());
assertEquals(ELEMENTS * THREADS, globalMetric.getElements());
Assert.assertEquals(0, errors.get());
assertEquals(0, errors.get());
latchDone.setCount(10);
@ -442,23 +445,23 @@ public class SizeAwareMetricTest {
}
flagStart.await(10, TimeUnit.SECONDS);
Assert.assertTrue(latchDone.await(10, TimeUnit.SECONDS));
assertTrue(latchDone.await(10, TimeUnit.SECONDS));
Assert.assertEquals(0, globalMetric.getSize());
Assert.assertEquals(0, globalMetric.getElements());
assertEquals(0, globalMetric.getSize());
assertEquals(0, globalMetric.getElements());
for (SizeAwareMetric theMetric : metric) {
Assert.assertEquals(0, theMetric.getSize());
Assert.assertEquals(0, theMetric.getElements());
assertEquals(0, theMetric.getSize());
assertEquals(0, theMetric.getElements());
}
Assert.assertEquals(10, metricOverCalls.get());
Assert.assertEquals(1, globalMetricOverCalls.get());
Assert.assertEquals(10, metricUnderCalls.get());
Assert.assertEquals(1, globalMetricUnderCalls.get());
Assert.assertFalse(globalMetricOver.get());
Assert.assertFalse(globalMetric.isOver());
assertEquals(10, metricOverCalls.get());
assertEquals(1, globalMetricOverCalls.get());
assertEquals(10, metricUnderCalls.get());
assertEquals(1, globalMetricUnderCalls.get());
assertFalse(globalMetricOver.get());
assertFalse(globalMetric.isOver());
for (AtomicBoolean theBool : metricOverArray) {
Assert.assertFalse(theBool.get());
assertFalse(theBool.get());
}
}
@ -470,13 +473,13 @@ public class SizeAwareMetricTest {
metric.setUnderCallback(() -> over.set(false));
metric.addSize(900);
Assert.assertFalse(over.get());
assertFalse(over.get());
metric.setMax(800, 700, -1, -1);
Assert.assertTrue(over.get());
assertTrue(over.get());
metric.addSize(-201);
Assert.assertFalse(over.get());
assertFalse(over.get());
}
@Test
@ -486,9 +489,9 @@ public class SizeAwareMetricTest {
metric.setOverCallback(() -> over.set(true));
metric.addSize(100);
Assert.assertEquals(100, metric.getSize());
Assert.assertEquals(1, metric.getElements());
Assert.assertFalse(over.get());
assertEquals(100, metric.getSize());
assertEquals(1, metric.getElements());
assertFalse(over.get());
}
@Test
@ -503,21 +506,21 @@ public class SizeAwareMetricTest {
metric.addSize(10, true);
}
Assert.assertEquals(100, metricMain.getSize());
Assert.assertEquals(100, metric.getSize());
Assert.assertEquals(0, metricMain.getElements());
Assert.assertEquals(0, metric.getElements());
assertEquals(100, metricMain.getSize());
assertEquals(100, metric.getSize());
assertEquals(0, metricMain.getElements());
assertEquals(0, metric.getElements());
for (int i = 0; i < 10; i++) {
metric.addSize(10, false);
}
Assert.assertEquals(200, metricMain.getSize());
Assert.assertEquals(200, metric.getSize());
Assert.assertEquals(10, metricMain.getElements());
Assert.assertEquals(10, metric.getElements());
assertEquals(200, metricMain.getSize());
assertEquals(200, metric.getSize());
assertEquals(10, metricMain.getElements());
assertEquals(10, metric.getElements());
Assert.assertFalse(over.get());
assertFalse(over.get());
}
@Test
@ -528,8 +531,8 @@ public class SizeAwareMetricTest {
metric.setOverCallback(() -> over.set(true));
metric.setMax(0, 0, 0, 0);
Assert.assertFalse(over.get());
Assert.assertFalse(metric.isOver());
assertFalse(over.get());
assertFalse(metric.isOver());
}
@Test
@ -542,36 +545,36 @@ public class SizeAwareMetricTest {
metric.addSize(2500, true);
Assert.assertTrue(over.get());
assertTrue(over.get());
metric.addSize(1000);
Assert.assertTrue(metric.isOverSize());
assertTrue(metric.isOverSize());
metric.addSize(-2500, true);
// Even though we are free from maxSize, we are still bound by maxElements, it should still be over
Assert.assertTrue(over.get());
Assert.assertTrue("Switch did not work", metric.isOverElements());
assertTrue(over.get());
assertTrue(metric.isOverElements(), "Switch did not work");
Assert.assertEquals(1, metric.getElements());
Assert.assertEquals(1000, metric.getSize());
assertEquals(1, metric.getElements());
assertEquals(1000, metric.getSize());
metric.addSize(5000, true);
Assert.assertTrue(metric.isOverElements());
Assert.assertEquals(6000, metric.getSize());
assertTrue(metric.isOverElements());
assertEquals(6000, metric.getSize());
metric.addSize(-1000);
Assert.assertTrue(metric.isOverSize());
Assert.assertEquals(0, metric.getElements());
Assert.assertEquals(5000, metric.getSize());
assertTrue(metric.isOverSize());
assertEquals(0, metric.getElements());
assertEquals(5000, metric.getSize());
metric.addSize(-5000, true);
Assert.assertFalse(metric.isOver());
Assert.assertEquals(0, metric.getSize());
Assert.assertEquals(0, metric.getElements());
assertFalse(metric.isOver());
assertEquals(0, metric.getSize());
assertEquals(0, metric.getElements());
}
@ -630,20 +633,20 @@ public class SizeAwareMetricTest {
});
}
Assert.assertTrue(done.await(10, TimeUnit.SECONDS));
assertTrue(done.await(10, TimeUnit.SECONDS));
Assert.assertEquals(0, metric.getSize());
Assert.assertEquals(0, metric.getElements());
Assert.assertEquals(0, errors.get());
assertEquals(0, metric.getSize());
assertEquals(0, metric.getElements());
assertEquals(0, errors.get());
}
@Test
public void testConsistency() {
SizeAwareMetric metric = new SizeAwareMetric(-1, -1, -1, -1);
Assert.assertFalse(metric.isSizeEnabled());
Assert.assertFalse(metric.isElementsEnabled());
assertFalse(metric.isSizeEnabled());
assertFalse(metric.isElementsEnabled());
metric.setMax(1, 1, 1, 1);
Assert.assertTrue(metric.isSizeEnabled());
Assert.assertTrue(metric.isElementsEnabled());
assertTrue(metric.isSizeEnabled());
assertTrue(metric.isElementsEnabled());
}
}

20
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/TableOutTest.java
View File

@ -19,8 +19,8 @@ package org.apache.activemq.artemis.utils;
import java.util.ArrayList;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class TableOutTest {
@ -29,10 +29,10 @@ public class TableOutTest {
String bigCell = "1234554321321";
TableOut tableOut = new TableOut("|", 0, new int[] {10, 3, 3});
ArrayList<String> lines = tableOut.splitLine(bigCell, 5);
Assert.assertEquals(3, lines.size());
Assert.assertEquals("12345", lines.get(0));
Assert.assertEquals("54321", lines.get(1));
Assert.assertEquals("321", lines.get(2));
Assertions.assertEquals(3, lines.size());
Assertions.assertEquals("12345", lines.get(0));
Assertions.assertEquals("54321", lines.get(1));
Assertions.assertEquals("321", lines.get(2));
}
@Test
@ -40,10 +40,10 @@ public class TableOutTest {
String bigCell = "1234532132";
TableOut tableOut = new TableOut("|", 2, new int[] {10, 3, 3});
ArrayList<String> lines = tableOut.splitLine(bigCell, 5);
Assert.assertEquals(3, lines.size());
Assert.assertEquals("12345", lines.get(0));
Assert.assertEquals(" 321", lines.get(1));
Assert.assertEquals(" 32", lines.get(2));
Assertions.assertEquals(3, lines.size());
Assertions.assertEquals("12345", lines.get(0));
Assertions.assertEquals(" 321", lines.get(1));
Assertions.assertEquals(" 32", lines.get(2));
}
@Test

19
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/TimeUnitsTest.java
View File

@ -16,24 +16,25 @@
*/
package org.apache.activemq.artemis.utils;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.tests.extensions.TargetTempDirFactory;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.io.File;
import java.io.IOException;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class TimeUnitsTest {
@Rule
public TemporaryFolder folder = new TemporaryFolder();
// Temp folder at ./target/tmp/<TestClassName>/<generated>
@TempDir(factory = TargetTempDirFactory.class)
public File folder;
@Test
public void testWaitOnBoolean() throws IOException {
File tmpFile = folder.newFile("myfile.txt");
File tmpFile = File.createTempFile("myfile", ".txt", folder);
assertTrue(tmpFile.exists());
long begin = System.currentTimeMillis();
boolean result = TimeUtils.waitOnBoolean(false, 100, tmpFile::exists);

12
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/TypedPropertiesConcurrencyTest.java
View File

@ -16,8 +16,9 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.ConcurrentModificationException;
import java.util.concurrent.CountDownLatch;
@ -27,8 +28,7 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import org.apache.activemq.artemis.api.core.SimpleString;
import org.apache.activemq.artemis.utils.collections.TypedProperties;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class TypedPropertiesConcurrencyTest {
@ -77,7 +77,7 @@ public class TypedPropertiesConcurrencyTest {
executorService.shutdown();
executorService.awaitTermination(10, TimeUnit.SECONDS);
executorService.shutdown();
Assert.assertFalse(hasError.get());
assertFalse(hasError.get());
}
@Test
@ -127,7 +127,7 @@ public class TypedPropertiesConcurrencyTest {
executorService.shutdown();
executorService.awaitTermination(10, TimeUnit.SECONDS);
executorService.shutdown();
Assert.assertFalse(hasError.get());
assertFalse(hasError.get());
}
@Test

126
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/TypedPropertiesConversionTest.java
View File

@ -16,12 +16,18 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import org.apache.activemq.artemis.api.core.ActiveMQPropertyConversionException;
import org.apache.activemq.artemis.api.core.SimpleString;
import org.apache.activemq.artemis.utils.collections.TypedProperties;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class TypedPropertiesConversionTest {
@ -32,7 +38,7 @@ public class TypedPropertiesConversionTest {
private final SimpleString unknownKey = new SimpleString("this.key.is.never.used");
@Before
@BeforeEach
public void setUp() throws Exception {
key = RandomUtil.randomSimpleString();
props = new TypedProperties();
@ -43,20 +49,20 @@ public class TypedPropertiesConversionTest {
Boolean val = RandomUtil.randomBoolean();
props.putBooleanProperty(key, val);
Assert.assertEquals(val, props.getBooleanProperty(key));
Assert.assertEquals(new SimpleString(Boolean.toString(val)), props.getSimpleStringProperty(key));
assertEquals(val, props.getBooleanProperty(key));
assertEquals(new SimpleString(Boolean.toString(val)), props.getSimpleStringProperty(key));
props.putSimpleStringProperty(key, new SimpleString(Boolean.toString(val)));
Assert.assertEquals(val, props.getBooleanProperty(key));
assertEquals(val, props.getBooleanProperty(key));
try {
props.putByteProperty(key, RandomUtil.randomByte());
props.getBooleanProperty(key);
Assert.fail();
fail();
} catch (ActiveMQPropertyConversionException e) {
}
Assert.assertFalse(props.getBooleanProperty(unknownKey));
assertFalse(props.getBooleanProperty(unknownKey));
}
@Test
@ -64,19 +70,19 @@ public class TypedPropertiesConversionTest {
Character val = RandomUtil.randomChar();
props.putCharProperty(key, val);
Assert.assertEquals(val, props.getCharProperty(key));
Assert.assertEquals(new SimpleString(Character.toString(val)), props.getSimpleStringProperty(key));
assertEquals(val, props.getCharProperty(key));
assertEquals(new SimpleString(Character.toString(val)), props.getSimpleStringProperty(key));
try {
props.putByteProperty(key, RandomUtil.randomByte());
props.getCharProperty(key);
Assert.fail();
fail();
} catch (ActiveMQPropertyConversionException e) {
}
try {
props.getCharProperty(unknownKey);
Assert.fail();
fail();
} catch (NullPointerException e) {
}
}
@ -86,36 +92,36 @@ public class TypedPropertiesConversionTest {
Byte val = RandomUtil.randomByte();
props.putByteProperty(key, val);
Assert.assertEquals(val, props.getByteProperty(key));
Assert.assertEquals(new SimpleString(Byte.toString(val)), props.getSimpleStringProperty(key));
assertEquals(val, props.getByteProperty(key));
assertEquals(new SimpleString(Byte.toString(val)), props.getSimpleStringProperty(key));
props.putSimpleStringProperty(key, new SimpleString(Byte.toString(val)));
Assert.assertEquals(val, props.getByteProperty(key));
assertEquals(val, props.getByteProperty(key));
try {
props.putBooleanProperty(key, RandomUtil.randomBoolean());
props.getByteProperty(key);
Assert.fail();
fail();
} catch (ActiveMQPropertyConversionException e) {
}
try {
props.getByteProperty(unknownKey);
Assert.fail();
fail();
} catch (NumberFormatException e) {
}
}
@Test
public void testNoByteProperty() {
Assert.assertEquals(0, props.size());
Assert.assertNull(props.getByteProperty(key, () -> null));
assertEquals(0, props.size());
assertNull(props.getByteProperty(key, () -> null));
props.putByteProperty(key.concat('0'), RandomUtil.randomByte());
Assert.assertEquals(1, props.size());
Assert.assertNull(props.getByteProperty(key, () -> null));
assertEquals(1, props.size());
assertNull(props.getByteProperty(key, () -> null));
props.putNullValue(key);
Assert.assertTrue(props.containsProperty(key));
Assert.assertNull(props.getByteProperty(key, () -> null));
assertTrue(props.containsProperty(key));
assertNull(props.getByteProperty(key, () -> null));
}
@Test
@ -123,26 +129,26 @@ public class TypedPropertiesConversionTest {
Integer val = RandomUtil.randomInt();
props.putIntProperty(key, val);
Assert.assertEquals(val, props.getIntProperty(key));
Assert.assertEquals(new SimpleString(Integer.toString(val)), props.getSimpleStringProperty(key));
assertEquals(val, props.getIntProperty(key));
assertEquals(new SimpleString(Integer.toString(val)), props.getSimpleStringProperty(key));
props.putSimpleStringProperty(key, new SimpleString(Integer.toString(val)));
Assert.assertEquals(val, props.getIntProperty(key));
assertEquals(val, props.getIntProperty(key));
Byte byteVal = RandomUtil.randomByte();
props.putByteProperty(key, byteVal);
Assert.assertEquals(Integer.valueOf(byteVal), props.getIntProperty(key));
assertEquals(Integer.valueOf(byteVal), props.getIntProperty(key));
try {
props.putBooleanProperty(key, RandomUtil.randomBoolean());
props.getIntProperty(key);
Assert.fail();
fail();
} catch (ActiveMQPropertyConversionException e) {
}
try {
props.getIntProperty(unknownKey);
Assert.fail();
fail();
} catch (NumberFormatException e) {
}
}
@ -152,34 +158,34 @@ public class TypedPropertiesConversionTest {
Long val = RandomUtil.randomLong();
props.putLongProperty(key, val);
Assert.assertEquals(val, props.getLongProperty(key));
Assert.assertEquals(new SimpleString(Long.toString(val)), props.getSimpleStringProperty(key));
assertEquals(val, props.getLongProperty(key));
assertEquals(new SimpleString(Long.toString(val)), props.getSimpleStringProperty(key));
props.putSimpleStringProperty(key, new SimpleString(Long.toString(val)));
Assert.assertEquals(val, props.getLongProperty(key));
assertEquals(val, props.getLongProperty(key));
Byte byteVal = RandomUtil.randomByte();
props.putByteProperty(key, byteVal);
Assert.assertEquals(Long.valueOf(byteVal), props.getLongProperty(key));
assertEquals(Long.valueOf(byteVal), props.getLongProperty(key));
Short shortVal = RandomUtil.randomShort();
props.putShortProperty(key, shortVal);
Assert.assertEquals(Long.valueOf(shortVal), props.getLongProperty(key));
assertEquals(Long.valueOf(shortVal), props.getLongProperty(key));
Integer intVal = RandomUtil.randomInt();
props.putIntProperty(key, intVal);
Assert.assertEquals(Long.valueOf(intVal), props.getLongProperty(key));
assertEquals(Long.valueOf(intVal), props.getLongProperty(key));
try {
props.putBooleanProperty(key, RandomUtil.randomBoolean());
props.getLongProperty(key);
Assert.fail();
fail();
} catch (ActiveMQPropertyConversionException e) {
}
try {
props.getLongProperty(unknownKey);
Assert.fail();
fail();
} catch (NumberFormatException e) {
}
}
@ -189,22 +195,22 @@ public class TypedPropertiesConversionTest {
Double val = RandomUtil.randomDouble();
props.putDoubleProperty(key, val);
Assert.assertEquals(val, props.getDoubleProperty(key));
Assert.assertEquals(new SimpleString(Double.toString(val)), props.getSimpleStringProperty(key));
assertEquals(val, props.getDoubleProperty(key));
assertEquals(new SimpleString(Double.toString(val)), props.getSimpleStringProperty(key));
props.putSimpleStringProperty(key, new SimpleString(Double.toString(val)));
Assert.assertEquals(val, props.getDoubleProperty(key));
assertEquals(val, props.getDoubleProperty(key));
try {
props.putBooleanProperty(key, RandomUtil.randomBoolean());
props.getDoubleProperty(key);
Assert.fail();
fail();
} catch (ActiveMQPropertyConversionException e) {
}
try {
props.getDoubleProperty(unknownKey);
Assert.fail();
fail();
} catch (Exception e) {
}
}
@ -214,23 +220,23 @@ public class TypedPropertiesConversionTest {
Float val = RandomUtil.randomFloat();
props.putFloatProperty(key, val);
Assert.assertEquals(val, props.getFloatProperty(key));
Assert.assertEquals(Double.valueOf(val), props.getDoubleProperty(key));
Assert.assertEquals(new SimpleString(Float.toString(val)), props.getSimpleStringProperty(key));
assertEquals(val, props.getFloatProperty(key));
assertEquals(Double.valueOf(val), props.getDoubleProperty(key));
assertEquals(new SimpleString(Float.toString(val)), props.getSimpleStringProperty(key));
props.putSimpleStringProperty(key, new SimpleString(Float.toString(val)));
Assert.assertEquals(val, props.getFloatProperty(key));
assertEquals(val, props.getFloatProperty(key));
try {
props.putBooleanProperty(key, RandomUtil.randomBoolean());
props.getFloatProperty(key);
Assert.fail();
fail();
} catch (ActiveMQPropertyConversionException e) {
}
try {
props.getFloatProperty(unknownKey);
Assert.fail();
fail();
} catch (Exception e) {
}
}
@ -240,27 +246,27 @@ public class TypedPropertiesConversionTest {
Short val = RandomUtil.randomShort();
props.putShortProperty(key, val);
Assert.assertEquals(val, props.getShortProperty(key));
Assert.assertEquals(Integer.valueOf(val), props.getIntProperty(key));
Assert.assertEquals(new SimpleString(Short.toString(val)), props.getSimpleStringProperty(key));
assertEquals(val, props.getShortProperty(key));
assertEquals(Integer.valueOf(val), props.getIntProperty(key));
assertEquals(new SimpleString(Short.toString(val)), props.getSimpleStringProperty(key));
props.putSimpleStringProperty(key, new SimpleString(Short.toString(val)));
Assert.assertEquals(val, props.getShortProperty(key));
assertEquals(val, props.getShortProperty(key));
Byte byteVal = RandomUtil.randomByte();
props.putByteProperty(key, byteVal);
Assert.assertEquals(Short.valueOf(byteVal), props.getShortProperty(key));
assertEquals(Short.valueOf(byteVal), props.getShortProperty(key));
try {
props.putBooleanProperty(key, RandomUtil.randomBoolean());
props.getShortProperty(key);
Assert.fail();
fail();
} catch (ActiveMQPropertyConversionException e) {
}
try {
props.getShortProperty(unknownKey);
Assert.fail();
fail();
} catch (NumberFormatException e) {
}
}
@ -269,7 +275,7 @@ public class TypedPropertiesConversionTest {
public void testSimpleStringProperty() throws Exception {
SimpleString strVal = RandomUtil.randomSimpleString();
props.putSimpleStringProperty(key, strVal);
Assert.assertEquals(strVal, props.getSimpleStringProperty(key));
assertEquals(strVal, props.getSimpleStringProperty(key));
}
@Test
@ -277,16 +283,16 @@ public class TypedPropertiesConversionTest {
byte[] val = RandomUtil.randomBytes();
props.putBytesProperty(key, val);
Assert.assertArrayEquals(val, props.getBytesProperty(key));
assertArrayEquals(val, props.getBytesProperty(key));
try {
props.putBooleanProperty(key, RandomUtil.randomBoolean());
props.getBytesProperty(key);
Assert.fail();
fail();
} catch (ActiveMQPropertyConversionException e) {
}
Assert.assertNull(props.getBytesProperty(unknownKey));
assertNull(props.getBytesProperty(unknownKey));
}
}

191
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/TypedPropertiesTest.java
View File

@ -16,6 +16,17 @@
*/
package org.apache.activemq.artemis.utils;
import static org.apache.activemq.artemis.utils.collections.TypedProperties.searchProperty;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Iterator;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
@ -26,19 +37,16 @@ import org.apache.activemq.artemis.api.core.ActiveMQBuffer;
import org.apache.activemq.artemis.api.core.ActiveMQBuffers;
import org.apache.activemq.artemis.api.core.SimpleString;
import org.apache.activemq.artemis.utils.collections.TypedProperties;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import static org.apache.activemq.artemis.utils.collections.TypedProperties.searchProperty;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class TypedPropertiesTest {
private static void assertEqualsTypeProperties(final TypedProperties expected, final TypedProperties actual) {
Assert.assertNotNull(expected);
Assert.assertNotNull(actual);
Assert.assertEquals(expected.getEncodeSize(), actual.getEncodeSize());
Assert.assertEquals(expected.getPropertyNames(), actual.getPropertyNames());
assertNotNull(expected);
assertNotNull(actual);
assertEquals(expected.getEncodeSize(), actual.getEncodeSize());
assertEquals(expected.getPropertyNames(), actual.getPropertyNames());
Iterator<SimpleString> iterator = actual.getPropertyNames().iterator();
while (iterator.hasNext()) {
SimpleString key = iterator.next();
@ -47,9 +55,9 @@ public class TypedPropertiesTest {
if (expectedValue instanceof byte[] && actualValue instanceof byte[]) {
byte[] expectedBytes = (byte[]) expectedValue;
byte[] actualBytes = (byte[]) actualValue;
Assert.assertArrayEquals(expectedBytes, actualBytes);
assertArrayEquals(expectedBytes, actualBytes);
} else {
Assert.assertEquals(expectedValue, actualValue);
assertEquals(expectedValue, actualValue);
}
}
}
@ -66,80 +74,81 @@ public class TypedPropertiesTest {
TypedProperties copy = new TypedProperties(props);
Assert.assertEquals(props.getEncodeSize(), copy.getEncodeSize());
Assert.assertEquals(props.getPropertyNames(), copy.getPropertyNames());
assertEquals(props.getEncodeSize(), copy.getEncodeSize());
assertEquals(props.getPropertyNames(), copy.getPropertyNames());
Assert.assertTrue(copy.containsProperty(key));
Assert.assertEquals(props.getProperty(key), copy.getProperty(key));
assertTrue(copy.containsProperty(key));
assertEquals(props.getProperty(key), copy.getProperty(key));
}
@Test
public void testRemove() throws Exception {
props.putSimpleStringProperty(key, RandomUtil.randomSimpleString());
Assert.assertTrue(props.containsProperty(key));
Assert.assertNotNull(props.getProperty(key));
assertTrue(props.containsProperty(key));
assertNotNull(props.getProperty(key));
props.removeProperty(key);
Assert.assertFalse(props.containsProperty(key));
Assert.assertNull(props.getProperty(key));
assertFalse(props.containsProperty(key));
assertNull(props.getProperty(key));
}
@Test
public void testClear() throws Exception {
props.putSimpleStringProperty(key, RandomUtil.randomSimpleString());
Assert.assertTrue(props.containsProperty(key));
Assert.assertNotNull(props.getProperty(key));
assertTrue(props.containsProperty(key));
assertNotNull(props.getProperty(key));
Assert.assertTrue("encodeSize <= " + 0, props.getEncodeSize() > 0);
assertTrue(props.getEncodeSize() > 0, "encodeSize <= " + 0);
props.clear();
Assert.assertEquals(1, props.getEncodeSize());
assertEquals(1, props.getEncodeSize());
Assert.assertFalse(props.containsProperty(key));
Assert.assertNull(props.getProperty(key));
assertFalse(props.containsProperty(key));
assertNull(props.getProperty(key));
}
@Test
public void testKey() throws Exception {
props.putBooleanProperty(key, true);
boolean bool = (Boolean) props.getProperty(key);
Assert.assertEquals(true, bool);
Boolean bool = (Boolean) props.getProperty(key);
assertNotNull(bool);
assertTrue(bool);
props.putCharProperty(key, 'a');
char c = (Character) props.getProperty(key);
Assert.assertEquals('a', c);
assertEquals('a', c);
}
@Test
public void testGetPropertyOnEmptyProperties() throws Exception {
Assert.assertFalse(props.containsProperty(key));
Assert.assertNull(props.getProperty(key));
assertFalse(props.containsProperty(key));
assertNull(props.getProperty(key));
}
@Test
public void testRemovePropertyOnEmptyProperties() throws Exception {
Assert.assertFalse(props.containsProperty(key));
Assert.assertNull(props.removeProperty(key));
assertFalse(props.containsProperty(key));
assertNull(props.removeProperty(key));
}
@Test
public void testNullProperty() throws Exception {
props.putSimpleStringProperty(key, null);
Assert.assertTrue(props.containsProperty(key));
Assert.assertNull(props.getProperty(key));
assertTrue(props.containsProperty(key));
assertNull(props.getProperty(key));
}
@Test
public void testBytesPropertyWithNull() throws Exception {
props.putBytesProperty(key, null);
Assert.assertTrue(props.containsProperty(key));
assertTrue(props.containsProperty(key));
byte[] bb = (byte[]) props.getProperty(key);
Assert.assertNull(bb);
assertNull(bb);
}
@Test
@ -155,27 +164,27 @@ public class TypedPropertiesTest {
props.putTypedProperties(otherProps);
long ll = props.getLongProperty(longKey);
Assert.assertEquals(longValue, ll);
assertEquals(longValue, ll);
SimpleString ss = props.getSimpleStringProperty(simpleStringKey);
Assert.assertEquals(simpleStringValue, ss);
assertEquals(simpleStringValue, ss);
}
@Test
public void testEmptyTypedProperties() throws Exception {
Assert.assertEquals(0, props.getPropertyNames().size());
assertEquals(0, props.getPropertyNames().size());
props.putTypedProperties(new TypedProperties());
Assert.assertEquals(0, props.getPropertyNames().size());
assertEquals(0, props.getPropertyNames().size());
}
@Test
public void testNullTypedProperties() throws Exception {
Assert.assertEquals(0, props.getPropertyNames().size());
assertEquals(0, props.getPropertyNames().size());
props.putTypedProperties(null);
Assert.assertEquals(0, props.getPropertyNames().size());
assertEquals(0, props.getPropertyNames().size());
}
@Test
@ -198,7 +207,7 @@ public class TypedPropertiesTest {
ActiveMQBuffer buffer = ActiveMQBuffers.dynamicBuffer(1024);
props.encode(buffer.byteBuf());
Assert.assertEquals(props.getEncodeSize(), buffer.writerIndex());
assertEquals(props.getEncodeSize(), buffer.writerIndex());
TypedProperties decodedProps = new TypedProperties();
decodedProps.decode(buffer.byteBuf());
@ -211,7 +220,7 @@ public class TypedPropertiesTest {
props.removeProperty(keyToRemove);
props.encode(buffer.byteBuf());
Assert.assertEquals(props.getEncodeSize(), buffer.writerIndex());
assertEquals(props.getEncodeSize(), buffer.writerIndex());
}
@Test
@ -221,7 +230,7 @@ public class TypedPropertiesTest {
ActiveMQBuffer buffer = ActiveMQBuffers.dynamicBuffer(1024);
emptyProps.encode(buffer.byteBuf());
Assert.assertEquals(props.getEncodeSize(), buffer.writerIndex());
assertEquals(props.getEncodeSize(), buffer.writerIndex());
TypedProperties decodedProps = new TypedProperties();
decodedProps.decode(buffer.byteBuf());
@ -234,23 +243,23 @@ public class TypedPropertiesTest {
@Test
public void testCannotClearInternalPropertiesIfEmpty() {
TypedProperties properties = new TypedProperties();
Assert.assertFalse(properties.clearInternalProperties());
assertFalse(properties.clearInternalProperties());
}
@Test
public void testClearInternalPropertiesIfAny() {
TypedProperties properties = new TypedProperties(PROP_NAME::equals);
properties.putBooleanProperty(PROP_NAME, RandomUtil.randomBoolean());
Assert.assertTrue(properties.clearInternalProperties());
Assert.assertFalse(properties.containsProperty(PROP_NAME));
assertTrue(properties.clearInternalProperties());
assertFalse(properties.containsProperty(PROP_NAME));
}
@Test
public void testCannotClearInternalPropertiesTwiceIfAny() {
TypedProperties properties = new TypedProperties(PROP_NAME::equals);
properties.putBooleanProperty(PROP_NAME, RandomUtil.randomBoolean());
Assert.assertTrue(properties.clearInternalProperties());
Assert.assertFalse(properties.clearInternalProperties());
assertTrue(properties.clearInternalProperties());
assertFalse(properties.clearInternalProperties());
}
@Test
@ -259,7 +268,7 @@ public class TypedPropertiesTest {
ByteBuf buf = Unpooled.buffer(Byte.BYTES, Byte.BYTES);
props.encode(buf);
buf.resetReaderIndex();
Assert.assertFalse("There is no property", searchProperty(SimpleString.toSimpleString(""), buf, 0));
assertFalse(searchProperty(SimpleString.toSimpleString(""), buf, 0), "There is no property");
}
@Test
@ -282,50 +291,56 @@ public class TypedPropertiesTest {
ByteBuf buf = Unpooled.buffer();
props.encode(buf);
buf.resetReaderIndex();
Assert.assertFalse(searchProperty(value, buf, 0));
assertFalse(searchProperty(value, buf, 0));
props.forEachKey(key -> {
Assert.assertTrue(searchProperty(key, buf, 0));
Assert.assertTrue(searchProperty(SimpleString.toSimpleString(key.toString()), buf, 0));
assertTrue(searchProperty(key, buf, 0));
assertTrue(searchProperty(SimpleString.toSimpleString(key.toString()), buf, 0));
// concat a string just to check if the search won't perform an eager search to find the string pattern
Assert.assertFalse(searchProperty(key.concat(" "), buf, 0));
assertFalse(searchProperty(key.concat(" "), buf, 0));
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testSearchPartiallyEncodedBuffer() {
final int expectedLength = Integer.BYTES + Byte.BYTES;
ByteBuf buf = Unpooled.buffer(expectedLength, expectedLength);
buf.writeByte(DataConstants.NOT_NULL);
buf.writeInt(1);
buf.resetReaderIndex();
searchProperty(SimpleString.toSimpleString(" "), buf, 0);
assertThrows(IndexOutOfBoundsException.class, () -> {
final int expectedLength = Integer.BYTES + Byte.BYTES;
ByteBuf buf = Unpooled.buffer(expectedLength, expectedLength);
buf.writeByte(DataConstants.NOT_NULL);
buf.writeInt(1);
buf.resetReaderIndex();
searchProperty(SimpleString.toSimpleString(" "), buf, 0);
});
}
@Test(expected = IndexOutOfBoundsException.class)
@Test
public void testSearchPartiallyEncodedString() {
final int expectedLength = Integer.BYTES + Byte.BYTES + Integer.BYTES;
ByteBuf buf = Unpooled.buffer(expectedLength, expectedLength);
buf.writeByte(DataConstants.NOT_NULL);
buf.writeInt(1);
//SimpleString::data length
buf.writeInt(2);
buf.resetReaderIndex();
searchProperty(SimpleString.toSimpleString("a"), buf, 0);
assertThrows(IndexOutOfBoundsException.class, () -> {
final int expectedLength = Integer.BYTES + Byte.BYTES + Integer.BYTES;
ByteBuf buf = Unpooled.buffer(expectedLength, expectedLength);
buf.writeByte(DataConstants.NOT_NULL);
buf.writeInt(1);
//SimpleString::data length
buf.writeInt(2);
buf.resetReaderIndex();
searchProperty(SimpleString.toSimpleString("a"), buf, 0);
});
}
@Test(expected = IllegalStateException.class)
@Test
public void testSearchWithInvalidTypeBeforeEnd() {
ByteBuf buf = Unpooled.buffer();
buf.writeByte(DataConstants.NOT_NULL);
// fake 2 properties
buf.writeInt(2);
// 1 key with length 2
buf.writeInt(2);
buf.writeShort(3);
// invalid type
buf.writeByte(Byte.MIN_VALUE);
buf.resetReaderIndex();
searchProperty(SimpleString.toSimpleString(""), buf, 0);
assertThrows(IllegalStateException.class, () -> {
ByteBuf buf = Unpooled.buffer();
buf.writeByte(DataConstants.NOT_NULL);
// fake 2 properties
buf.writeInt(2);
// 1 key with length 2
buf.writeInt(2);
buf.writeShort(3);
// invalid type
buf.writeByte(Byte.MIN_VALUE);
buf.resetReaderIndex();
searchProperty(SimpleString.toSimpleString(""), buf, 0);
});
}
@Test
@ -340,10 +355,10 @@ public class TypedPropertiesTest {
// invalid type
buf.writeByte(Byte.MIN_VALUE);
buf.resetReaderIndex();
Assert.assertFalse(searchProperty(SimpleString.toSimpleString(""), buf, 0));
assertFalse(searchProperty(SimpleString.toSimpleString(""), buf, 0));
}
@Before
@BeforeEach
public void setUp() throws Exception {
props = new TypedProperties();
key = RandomUtil.randomSimpleString();
@ -363,7 +378,7 @@ public class TypedPropertiesTest {
bb.resetReaderIndex();
final TypedProperties.StringValue expectedPooled = pool.getOrCreate(bb);
bb.resetReaderIndex();
Assert.assertSame(expectedPooled, pool.getOrCreate(bb));
assertSame(expectedPooled, pool.getOrCreate(bb));
bb.resetReaderIndex();
}
}
@ -374,7 +389,7 @@ public class TypedPropertiesTest {
final ByteBuf bb = Unpooled.buffer(tooLong.sizeof(), tooLong.sizeof());
SimpleString.writeSimpleString(bb, tooLong);
final TypedProperties.StringValue.ByteBufStringValuePool pool = new TypedProperties.StringValue.ByteBufStringValuePool(1, tooLong.length() - 1);
Assert.assertNotSame(pool.getOrCreate(bb), pool.getOrCreate(bb.resetReaderIndex()));
assertNotSame(pool.getOrCreate(bb), pool.getOrCreate(bb.resetReaderIndex()));
}
@Test
@ -406,6 +421,6 @@ public class TypedPropertiesTest {
t.join();
Assert.assertFalse(error.get());
assertFalse(error.get());
}
}

42
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/URIParserTest.java
View File

@ -17,6 +17,9 @@
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
@ -25,8 +28,7 @@ import org.apache.activemq.artemis.utils.uri.BeanSupport;
import org.apache.activemq.artemis.utils.uri.URIFactory;
import org.apache.activemq.artemis.utils.uri.URISchema;
import org.apache.activemq.artemis.utils.uri.URISupport;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class URIParserTest {
@ -40,12 +42,12 @@ public class URIParserTest {
FruitParser parser = new FruitParser();
Fruit fruit = (Fruit) parser.newObject(new URI("fruit://some:guy@fair-market:3030?color=green&fluentName=something"), null);
Assert.assertEquals("fruit", fruit.getName());
Assert.assertEquals(3030, fruit.getPort());
Assert.assertEquals("fair-market", fruit.getHost());
Assert.assertEquals("some:guy", fruit.getUserInfo());
Assert.assertEquals("green", fruit.getColor());
Assert.assertEquals("something", fruit.getFluentName());
assertEquals("fruit", fruit.getName());
assertEquals(3030, fruit.getPort());
assertEquals("fair-market", fruit.getHost());
assertEquals("some:guy", fruit.getUserInfo());
assertEquals("green", fruit.getColor());
assertEquals("something", fruit.getFluentName());
}
@ -65,8 +67,8 @@ public class URIParserTest {
Fruit newFruit = (Fruit) parser.newObject(uri, "something");
Assert.assertEquals(myFruit.getHost(), newFruit.getHost());
Assert.assertEquals(myFruit.getFluentName(), newFruit.getFluentName());
assertEquals(myFruit.getHost(), newFruit.getHost());
assertEquals(myFruit.getFluentName(), newFruit.getFluentName());
}
@ -79,9 +81,9 @@ public class URIParserTest {
public void testSchemaNoHosProperty() throws Throwable {
FruitParser parser = new FruitParser();
FruitBase fruit = parser.newObject(new URI("base://some:guy@fair-market:3030?color=green&fluentName=something"), null);
Assert.assertEquals("base", fruit.getName());
Assert.assertEquals("green", fruit.getColor());
Assert.assertEquals("something", fruit.getFluentName());
assertEquals("base", fruit.getName());
assertEquals("green", fruit.getColor());
assertEquals("something", fruit.getFluentName());
}
/**
@ -94,28 +96,28 @@ public class URIParserTest {
FruitParser parser = new FruitParser();
Fruit fruit = (Fruit) parser.newObject(new URI("fruit://some:guy@port?color=green&fluentName=something"), null);
Assert.assertEquals("fruit", fruit.getName());
Assert.assertEquals("green", fruit.getColor());
Assert.assertEquals("something", fruit.getFluentName());
assertEquals("fruit", fruit.getName());
assertEquals("green", fruit.getColor());
assertEquals("something", fruit.getFluentName());
}
@Test
public void testQueryConversion() throws Exception {
Map<String, String> query = new HashMap<>();
String queryString = URISupport.createQueryString(query);
Assert.assertTrue(queryString.isEmpty());
assertTrue(queryString.isEmpty());
query.put("key1", "value1");
queryString = URISupport.createQueryString(query);
Assert.assertEquals("key1=value1", queryString);
assertEquals("key1=value1", queryString);
query.put("key3", "value3");
queryString = URISupport.createQueryString(query);
Assert.assertEquals("key1=value1&key3=value3", queryString);
assertEquals("key1=value1&key3=value3", queryString);
query.put("key2", "value2");
queryString = URISupport.createQueryString(query);
Assert.assertEquals("key1=value1&key2=value2&key3=value3", queryString);
assertEquals("key1=value1&key2=value2&key3=value3", queryString);
}

10
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/WaitTest.java
View File

@ -16,10 +16,12 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class WaitTest {
@ -27,9 +29,9 @@ public class WaitTest {
public void testWait() {
AtomicInteger intValue = new AtomicInteger(0);
Assert.assertFalse(Wait.waitFor(() -> intValue.get() == 1, 100, 10));
assertFalse(Wait.waitFor(() -> intValue.get() == 1, 100, 10));
intValue.set(1);
Assert.assertTrue(Wait.waitFor(() -> intValue.get() == 1, 100, 10));
assertTrue(Wait.waitFor(() -> intValue.get() == 1, 100, 10));
}
}

59
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/XmlProviderTest.java
View File

@ -16,10 +16,15 @@
*/
package org.apache.activemq.artemis.utils;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Validator;
import java.io.File;
import java.lang.invoke.MethodHandles;
import java.util.Arrays;
@ -27,20 +32,20 @@ import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.apache.activemq.artemis.tests.extensions.parameterized.ParameterizedTestExtension;
import org.apache.activemq.artemis.tests.extensions.parameterized.Parameters;
import org.apache.activemq.artemis.tests.util.ArtemisTestCase;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.TestTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
@RunWith(Parameterized.class)
@ExtendWith(ParameterizedTestExtension.class)
public class XmlProviderTest extends ArtemisTestCase {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@ -49,12 +54,12 @@ public class XmlProviderTest extends ArtemisTestCase {
protected boolean xxeEnabled;
@Parameterized.Parameters(name = "xxeEnabled={0}")
@Parameters(name = "xxeEnabled={0}")
public static Collection getParameters() {
return Arrays.asList(new Boolean[]{true, false});
}
@BeforeClass
@BeforeAll
public static void beforeAll() {
if (origXxeEnabled == null) {
origXxeEnabled = XmlProvider.isXxeEnabled();
@ -63,7 +68,7 @@ public class XmlProviderTest extends ArtemisTestCase {
logger.trace("BeforeAll - origXxeEnabled={}, isXxeEnabled={}", origXxeEnabled, XmlProvider.isXxeEnabled());
}
@AfterClass
@AfterAll
public static void afterAll() {
logger.trace("AfterAll - origXxeEnabled={}, isXxeEnabled={} ", origXxeEnabled, XmlProvider.isXxeEnabled());
if (origXxeEnabled != null) {
@ -72,7 +77,7 @@ public class XmlProviderTest extends ArtemisTestCase {
}
}
@Before
@BeforeEach
public void setUp() {
logger.trace("Running setUp - xxeEnabled={}", xxeEnabled);
XmlProvider.setXxeEnabled(xxeEnabled);
@ -82,17 +87,17 @@ public class XmlProviderTest extends ArtemisTestCase {
this.xxeEnabled = xxeEnabled;
}
@Test
@TestTemplate
public void testDocument() throws Exception {
DocumentBuilder documentBuilder = XmlProvider.newDocumentBuilder();
Document document = documentBuilder.parse(new File(getClass().getResource("/document.xml").toURI()));
Element documentElement = document.getDocumentElement();
Assert.assertEquals("t:book", documentElement.getTagName());
Assert.assertEquals(1, documentElement.getElementsByTagName("title").getLength());
assertEquals("t:book", documentElement.getTagName());
assertEquals(1, documentElement.getElementsByTagName("title").getLength());
}
@Test
@TestTemplate
public void testDocumentWithXmlInclude() throws Exception {
Map<String, Boolean> properties = new HashMap<>();
properties.put(XmlProvider.XINCLUDE_AWARE_PROPERTY, true);
@ -101,22 +106,22 @@ public class XmlProviderTest extends ArtemisTestCase {
Document document = documentBuilder.parse(new File(XmlProviderTest.class.getResource("/document-with-xinclude.xml").toURI()));
Element documentElement = document.getDocumentElement();
Assert.assertEquals("t:book", documentElement.getTagName());
assertEquals("t:book", documentElement.getTagName());
if (XmlProvider.isXxeEnabled()) {
Assert.assertEquals(1, documentElement.getElementsByTagName("title").getLength());
assertEquals(1, documentElement.getElementsByTagName("title").getLength());
} else {
Assert.assertEquals(0, documentElement.getElementsByTagName("title").getLength());
assertEquals(0, documentElement.getElementsByTagName("title").getLength());
}
}
@Test
@TestTemplate
public void testSchema() throws Exception {
StreamSource streamSource = new StreamSource(XmlProviderTest.class.getResourceAsStream("/schema.xsd"));
XmlProvider.newSchema(streamSource, null);
}
@Test
@TestTemplate
public void testSchemaWithImport() {
StreamSource streamSource = new StreamSource(XmlProviderTest.class.getResourceAsStream("/schema-with-import.xsd"));
@ -128,13 +133,13 @@ public class XmlProviderTest extends ArtemisTestCase {
}
if (XmlProvider.isXxeEnabled()) {
Assert.assertNull(newSchemaException);
assertNull(newSchemaException);
} else {
Assert.assertNotNull(newSchemaException);
assertNotNull(newSchemaException);
}
}
@Test
@TestTemplate
public void testValidator() throws Exception {
Map<String, Boolean> properties = new HashMap<>();
properties.put(XmlProvider.NAMESPACE_AWARE_PROPERTY, true);
@ -146,7 +151,7 @@ public class XmlProviderTest extends ArtemisTestCase {
validator.validate(new DOMSource(documentElement));
}
@Test
@TestTemplate
public void testValidatorWithImport() throws Exception {
Map<String, Boolean> properties = new HashMap<>();
properties.put(XmlProvider.NAMESPACE_AWARE_PROPERTY, true);
@ -163,9 +168,9 @@ public class XmlProviderTest extends ArtemisTestCase {
}
if (XmlProvider.isXxeEnabled()) {
Assert.assertNull(validateException);
assertNull(validateException);
} else {
Assert.assertNotNull(validateException);
assertNotNull(validateException);
}
}
}

44
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/actors/OrderedExecutorSanityTest.java
View File

@ -16,6 +16,11 @@
*/
package org.apache.activemq.artemis.utils.actors;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
@ -24,12 +29,11 @@ import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;
import org.junit.Assert;
import org.junit.Test;
public class OrderedExecutorSanityTest {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@ -54,8 +58,8 @@ public class OrderedExecutorSanityTest {
});
expectedResults.add(value);
}
Assert.assertTrue("The tasks must be executed in " + timeoutMillis + " ms", executed.await(timeoutMillis, TimeUnit.MILLISECONDS));
Assert.assertArrayEquals("The processing of tasks must be ordered", expectedResults.toArray(), results.toArray());
assertTrue(executed.await(timeoutMillis, TimeUnit.MILLISECONDS), "The tasks must be executed in " + timeoutMillis + " ms");
assertArrayEquals(expectedResults.toArray(), results.toArray(), "The processing of tasks must be ordered");
} finally {
executorService.shutdown();
}
@ -69,13 +73,13 @@ public class OrderedExecutorSanityTest {
final OrderedExecutor executor = new OrderedExecutor(executorService);
final CountDownLatch executed = new CountDownLatch(1);
executor.execute(executed::countDown);
Assert.assertTrue("The task must be executed in " + timeoutMillis + " ms", executed.await(timeoutMillis, TimeUnit.MILLISECONDS));
assertTrue(executed.await(timeoutMillis, TimeUnit.MILLISECONDS), "The task must be executed in " + timeoutMillis + " ms");
executor.shutdownNow();
Assert.assertEquals("There are no remaining tasks to be executed", 0, executor.remaining());
assertEquals(0, executor.remaining(), "There are no remaining tasks to be executed");
//from now on new tasks won't be executed
executor.execute(() -> System.out.println("this will never happen"));
//to avoid memory leaks the executor must take care of the new submitted tasks immediatly
Assert.assertEquals("Any new task submitted after death must be collected", 0, executor.remaining());
assertEquals(0, executor.remaining(), "Any new task submitted after death must be collected");
} finally {
executorService.shutdown();
}
@ -109,10 +113,10 @@ public class OrderedExecutorSanityTest {
latch.await();
ran.await(1, TimeUnit.SECONDS);
Assert.assertEquals(100, numberOfTasks.get());
assertEquals(100, numberOfTasks.get());
Assert.assertEquals(ProcessorBase.STATE_FORCED_SHUTDOWN, executor.status());
Assert.assertEquals(0, executor.remaining());
assertEquals(ProcessorBase.STATE_FORCED_SHUTDOWN, executor.status());
assertEquals(0, executor.remaining());
} finally {
executorService.shutdown();
}
@ -144,13 +148,13 @@ public class OrderedExecutorSanityTest {
latch.await();
try {
Assert.assertEquals(100, executor.shutdownNow());
assertEquals(100, executor.shutdownNow());
} finally {
secondlatch.await();
}
Assert.assertEquals(ProcessorBase.STATE_FORCED_SHUTDOWN, executor.status());
Assert.assertEquals(0, executor.remaining());
assertEquals(ProcessorBase.STATE_FORCED_SHUTDOWN, executor.status());
assertEquals(0, executor.remaining());
} finally {
executorService.shutdown();
}
@ -173,7 +177,7 @@ public class OrderedExecutorSanityTest {
for (int l = 0; l < MAX_LOOP; l++) {
executor.execute(executed::countDown);
}
Assert.assertTrue(executed.await(1, TimeUnit.MINUTES));
assertTrue(executed.await(1, TimeUnit.MINUTES));
long end = System.nanoTime();
long elapsed = (end - start);
@ -210,7 +214,7 @@ public class OrderedExecutorSanityTest {
}
});
Assert.assertTrue(latchDone1.await(10, TimeUnit.SECONDS));
assertTrue(latchDone1.await(10, TimeUnit.SECONDS));
executor.execute(() -> {
try {
@ -235,11 +239,11 @@ public class OrderedExecutorSanityTest {
});
latchBlock1.countDown();
Assert.assertTrue(latchDone3.await(10, TimeUnit.SECONDS));
Assert.assertFalse(latchDone2.await(1, TimeUnit.MILLISECONDS));
assertTrue(latchDone3.await(10, TimeUnit.SECONDS));
assertFalse(latchDone2.await(1, TimeUnit.MILLISECONDS));
latchBlock3.countDown();
Assert.assertTrue(latchDone2.await(10, TimeUnit.SECONDS));
Assert.assertEquals(0, errors.get());
assertTrue(latchDone2.await(10, TimeUnit.SECONDS));
assertEquals(0, errors.get());
} finally {
executorService.shutdownNow();
}

31
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/actors/ThresholdActorTest.java
View File

@ -16,6 +16,10 @@
*/
package org.apache.activemq.artemis.utils.actors;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@ -25,8 +29,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.activemq.artemis.utils.Wait;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class ThresholdActorTest {
@ -55,27 +58,27 @@ public class ThresholdActorTest {
for (int i = 0; i < 10; i++) {
actor.act(i);
}
Assert.assertTrue(open.get());
Assert.assertEquals(0, timesClose.get());
assertTrue(open.get());
assertEquals(0, timesClose.get());
actor.act(99);
Assert.assertEquals(1, timesClose.get());
Assert.assertEquals(0, timesOpen.get());
assertEquals(1, timesClose.get());
assertEquals(0, timesOpen.get());
Assert.assertFalse(open.get());
assertFalse(open.get());
actor.act(1000);
actor.flush(); // a flush here shuld not change anything, as it was already called once on the previous overflow
Assert.assertEquals(1, timesClose.get());
Assert.assertEquals(0, timesOpen.get());
Assert.assertFalse(open.get());
assertEquals(1, timesClose.get());
assertEquals(0, timesOpen.get());
assertFalse(open.get());
semaphore.release();
Wait.assertTrue(open::get);
Assert.assertEquals(1, timesClose.get());
Assert.assertEquals(1, timesOpen.get());
assertEquals(1, timesClose.get());
assertEquals(1, timesOpen.get());
Wait.assertEquals(1000, lastProcessed::get, 5000, 1);
actor.flush();
@ -174,10 +177,10 @@ public class ThresholdActorTest {
latchDone.countDown();
});
Assert.assertTrue(latchDone.await(10, TimeUnit.SECONDS));
assertTrue(latchDone.await(10, TimeUnit.SECONDS));
Wait.assertEquals(LAST_ELEMENT, lastProcessed::get);
Assert.assertEquals(0, errors.get());
assertEquals(0, errors.get());
} finally {
executorService.shutdown();
}

35
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/bean/MetaBeanTest.java
View File

@ -17,14 +17,19 @@
package org.apache.activemq.artemis.utils.bean;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.lang.invoke.MethodHandles;
import java.util.Objects;
import org.apache.activemq.artemis.api.core.SimpleString;
import org.apache.activemq.artemis.json.JsonObject;
import org.apache.activemq.artemis.utils.RandomUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -49,27 +54,27 @@ public class MetaBeanTest {
JsonObject jsonObject = MYClass.metaBean.toJSON(sourceObject, false);
Assert.assertFalse(jsonObject.containsKey("gated"));
assertFalse(jsonObject.containsKey("gated"));
logger.debug("Result::" + jsonObject.toString());
MYClass result = new MYClass();
MYClass.metaBean.fromJSON(result, jsonObject.toString());
Assert.assertEquals(sourceObject, result);
assertEquals(sourceObject, result);
Assert.assertEquals(null, result.getD());
Assert.assertNotNull(result.getIdCacheSize());
Assert.assertEquals(333, result.getIdCacheSize().intValue());
Assert.assertEquals(33.33f, result.getFloatValue().floatValue(), 0);
Assert.assertEquals(11.11, result.getDoubleValue().doubleValue(), 0);
Assert.assertEquals(MyEnum.TWO, result.getMyEnum());
Assert.assertTrue(result.getBoolValue());
assertNull(result.getD());
assertNotNull(result.getIdCacheSize());
assertEquals(333, result.getIdCacheSize().intValue());
assertEquals(33.33f, result.getFloatValue().floatValue(), 0);
assertEquals(11.11, result.getDoubleValue().doubleValue(), 0);
assertEquals(MyEnum.TWO, result.getMyEnum());
assertTrue(result.getBoolValue());
sourceObject.setGated(SimpleString.toSimpleString("gated-now-has-value"));
jsonObject = MYClass.metaBean.toJSON(sourceObject, false);
Assert.assertTrue(jsonObject.containsKey("gated"));
Assert.assertEquals("gated-now-has-value", jsonObject.getString("gated"));
assertTrue(jsonObject.containsKey("gated"));
assertEquals("gated-now-has-value", jsonObject.getString("gated"));
}
@Test
@ -79,10 +84,10 @@ public class MetaBeanTest {
String json = MYClass.metaBean.toJSON(randomObject, false).toString();
MYClass target = new MYClass();
MYClass.metaBean.fromJSON(target, json);
Assert.assertEquals(randomObject, target);
assertEquals(randomObject, target);
MYClass copy = new MYClass();
MYClass.metaBean.copy(randomObject, copy);
Assert.assertEquals(randomObject, copy);
assertEquals(randomObject, copy);
}
public enum MyEnum {

84
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/ConcurrentAppendOnlyChunkedListTest.java
View File

@ -16,10 +16,14 @@
*/
package org.apache.activemq.artemis.utils.collections;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.Arrays;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class ConcurrentAppendOnlyChunkedListTest {
@ -32,24 +36,28 @@ public class ConcurrentAppendOnlyChunkedListTest {
chunkedList = new ConcurrentAppendOnlyChunkedList<>(CHUNK_SIZE);
}
@Test(expected = IllegalArgumentException.class)
@Test
public void shouldFailToCreateNotPowerOf2ChunkSizeCollection() {
new ConcurrentAppendOnlyChunkedList<>(3);
assertThrows(IllegalArgumentException.class, () -> {
new ConcurrentAppendOnlyChunkedList<>(3);
});
}
@Test(expected = IllegalArgumentException.class)
@Test
public void shouldFailToCreateNegativeChunkSizeCollection() {
new ConcurrentAppendOnlyChunkedList<>(-1);
assertThrows(IllegalArgumentException.class, () -> {
new ConcurrentAppendOnlyChunkedList<>(-1);
});
}
@Test
public void shouldNumberOfElementsBeTheSameOfTheAddedElements() {
final int messages = ELEMENTS;
for (int i = 0; i < messages; i++) {
Assert.assertEquals(i, chunkedList.size());
assertEquals(i, chunkedList.size());
chunkedList.add(i);
}
Assert.assertEquals(messages, chunkedList.size());
assertEquals(messages, chunkedList.size());
}
@Test
@ -61,19 +69,19 @@ public class ConcurrentAppendOnlyChunkedListTest {
elements[i] = element;
}
chunkedList.addAll(elements);
Assert.assertEquals(messages, chunkedList.size());
assertEquals(messages, chunkedList.size());
}
@Test
public void shouldGetReturnNullIfEmpty() {
Assert.assertNull(chunkedList.get(0));
assertNull(chunkedList.get(0));
}
@Test
public void shouldNegativeIndexedGetReturnNull() {
Assert.assertNull(chunkedList.get(-1));
assertNull(chunkedList.get(-1));
chunkedList.add(0);
Assert.assertNull(chunkedList.get(-1));
assertNull(chunkedList.get(-1));
}
@Test
@ -82,7 +90,7 @@ public class ConcurrentAppendOnlyChunkedListTest {
for (int i = 0; i < messages; i++) {
final Integer element = i;
chunkedList.add(element);
Assert.assertNull(chunkedList.get(i + 1));
assertNull(chunkedList.get(i + 1));
}
}
@ -99,12 +107,12 @@ public class ConcurrentAppendOnlyChunkedListTest {
for (int i = 0; i < messages; i++) {
cachedElements[i] = chunkedList.get(i);
}
Assert.assertArrayEquals(elements, cachedElements);
assertArrayEquals(elements, cachedElements);
Arrays.fill(cachedElements, null);
for (int i = messages - 1; i >= 0; i--) {
cachedElements[i] = chunkedList.get(i);
}
Assert.assertArrayEquals(elements, cachedElements);
assertArrayEquals(elements, cachedElements);
}
@Test
@ -120,7 +128,7 @@ public class ConcurrentAppendOnlyChunkedListTest {
for (int i = 0; i < messages; i++) {
cachedElements[i] = chunkedList.get(i);
}
Assert.assertArrayEquals(elements, cachedElements);
assertArrayEquals(elements, cachedElements);
}
@Test
@ -133,7 +141,7 @@ public class ConcurrentAppendOnlyChunkedListTest {
chunkedList.add(element);
}
final Integer[] cachedElements = chunkedList.toArray(Integer[]::new);
Assert.assertArrayEquals(elements, cachedElements);
assertArrayEquals(elements, cachedElements);
}
@Test
@ -147,31 +155,37 @@ public class ConcurrentAppendOnlyChunkedListTest {
}
final int offset = 10;
final Integer[] cachedElements = chunkedList.toArray(size -> new Integer[offset + size], offset);
Assert.assertArrayEquals(elements, Arrays.copyOfRange(cachedElements, offset, cachedElements.length));
Assert.assertArrayEquals(new Integer[offset], Arrays.copyOfRange(cachedElements, 0, offset));
assertArrayEquals(elements, Arrays.copyOfRange(cachedElements, offset, cachedElements.length));
assertArrayEquals(new Integer[offset], Arrays.copyOfRange(cachedElements, 0, offset));
}
@Test(expected = ArrayIndexOutOfBoundsException.class)
@Test
public void shouldFailToArrayWithInsufficientArrayCapacity() {
final int messages = ELEMENTS;
final Integer[] elements = new Integer[messages];
for (int i = 0; i < messages; i++) {
final Integer element = i;
elements[i] = element;
chunkedList.add(element);
}
final int offset = 10;
chunkedList.toArray(size -> new Integer[offset + size - 1], offset);
assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
final int messages = ELEMENTS;
final Integer[] elements = new Integer[messages];
for (int i = 0;i < messages;i++) {
final Integer element = i;
elements[i] = element;
chunkedList.add(element);
}
final int offset = 10;
chunkedList.toArray(size -> new Integer[offset + size - 1], offset);
});
}
@Test(expected = ArrayIndexOutOfBoundsException.class)
@Test
public void shouldFailToArrayWithNegativeStartIndex() {
chunkedList.toArray(Integer[]::new, -1);
assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
chunkedList.toArray(Integer[]::new, -1);
});
}
@Test(expected = NullPointerException.class)
@Test
public void shouldFailToArrayWithNullArray() {
chunkedList.toArray(size -> null);
assertThrows(NullPointerException.class, () -> {
chunkedList.toArray(size -> null);
});
}
@Test
@ -184,13 +198,13 @@ public class ConcurrentAppendOnlyChunkedListTest {
}
chunkedList.addAll(elements);
final Integer[] cachedElements = chunkedList.toArray(Integer[]::new);
Assert.assertArrayEquals(elements, cachedElements);
assertArrayEquals(elements, cachedElements);
}
@Test
public void shouldToArrayReturnEmptyArrayIfEmpty() {
final Integer[] array = chunkedList.toArray(Integer[]::new);
Assert.assertArrayEquals(new Integer[0], array);
assertArrayEquals(new Integer[0], array);
}
}

12
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/ConcurrentLongHashMapTest.java
View File

@ -16,6 +16,11 @@
*/
package org.apache.activemq.artemis.utils.collections;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@ -30,12 +35,7 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.LongFunction;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertNull;
import org.junit.jupiter.api.Test;
public class ConcurrentLongHashMapTest {

10
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/ConcurrentLongHashSetTest.java
View File

@ -16,6 +16,10 @@
*/
package org.apache.activemq.artemis.utils.collections;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@ -26,11 +30,7 @@ import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadLocalRandom;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.Test;
public class ConcurrentLongHashSetTest {

294
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/LongHashSetTest.java
View File

@ -16,6 +16,13 @@
*/
package org.apache.activemq.artemis.utils.collections;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
@ -24,8 +31,7 @@ import java.util.NoSuchElementException;
import java.util.Random;
import java.util.Set;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
/**
* These tests are based on <a href="https://github.com/real-logic/agrona/blob/master/agrona/src/test/java/org/agrona/collections/IntHashSetTest.java">Agrona IntHashSetTest</a>
@ -40,64 +46,64 @@ public class LongHashSetTest {
@Test
public void initiallyContainsNoElements() {
for (long i = 0; i < 10_000; i++) {
Assert.assertFalse(testSet.contains(i));
assertFalse(testSet.contains(i));
}
}
@Test
public void initiallyContainsNoBoxedElements() {
for (long i = 0; i < 10_000; i++) {
Assert.assertFalse(testSet.contains(Long.valueOf(i)));
assertFalse(testSet.contains(Long.valueOf(i)));
}
}
@Test
public void containsAddedElement() {
Assert.assertTrue(testSet.add(1L));
assertTrue(testSet.add(1L));
Assert.assertTrue(testSet.contains(1L));
assertTrue(testSet.contains(1L));
}
@Test
public void addingAnElementTwiceDoesNothing() {
Assert.assertTrue(testSet.add(1L));
assertTrue(testSet.add(1L));
Assert.assertFalse(testSet.add(1L));
assertFalse(testSet.add(1L));
}
@Test
public void containsAddedBoxedElements() {
Assert.assertTrue(testSet.add(1L));
Assert.assertTrue(testSet.add(Long.valueOf(2L)));
assertTrue(testSet.add(1L));
assertTrue(testSet.add(Long.valueOf(2L)));
Assert.assertTrue(testSet.contains(Long.valueOf(1L)));
Assert.assertTrue(testSet.contains(2L));
assertTrue(testSet.contains(Long.valueOf(1L)));
assertTrue(testSet.contains(2L));
}
@Test
public void removingAnElementFromAnEmptyListDoesNothing() {
Assert.assertFalse(testSet.remove(0L));
assertFalse(testSet.remove(0L));
}
@Test
public void removingAPresentElementRemovesIt() {
Assert.assertTrue(testSet.add(1L));
assertTrue(testSet.add(1L));
Assert.assertTrue(testSet.remove(1L));
assertTrue(testSet.remove(1L));
Assert.assertFalse(testSet.contains(1L));
assertFalse(testSet.contains(1L));
}
@Test
public void sizeIsInitiallyZero() {
Assert.assertEquals(0, testSet.size());
assertEquals(0, testSet.size());
}
@Test
public void sizeIncrementsWithNumberOfAddedElements() {
addTwoElements(testSet);
Assert.assertEquals(2, testSet.size());
assertEquals(2, testSet.size());
}
@Test
@ -105,7 +111,7 @@ public class LongHashSetTest {
testSet.add(1L);
testSet.add(1L);
Assert.assertEquals(1, testSet.size());
assertEquals(1, testSet.size());
}
@Test
@ -136,33 +142,39 @@ public class LongHashSetTest {
assertIteratorHasElementsWithoutHasNext();
}
@Test(expected = NoSuchElementException.class)
@Test
public void iteratorsThrowNoSuchElementException() {
addTwoElements(testSet);
assertThrows(NoSuchElementException.class, () -> {
addTwoElements(testSet);
exhaustIterator();
exhaustIterator();
});
}
@Test(expected = NoSuchElementException.class)
@Test
public void iteratorsThrowNoSuchElementExceptionFromTheBeginningEveryTime() {
addTwoElements(testSet);
assertThrows(NoSuchElementException.class, () -> {
addTwoElements(testSet);
try {
exhaustIterator();
} catch (final NoSuchElementException ignore) {
}
try {
exhaustIterator();
} catch (final NoSuchElementException ignore) {
}
exhaustIterator();
});
}
@Test
public void iteratorHasNoElements() {
Assert.assertFalse(testSet.iterator().hasNext());
assertFalse(testSet.iterator().hasNext());
}
@Test(expected = NoSuchElementException.class)
@Test
public void iteratorThrowExceptionForEmptySet() {
testSet.iterator().next();
assertThrows(NoSuchElementException.class, () -> {
testSet.iterator().next();
});
}
@Test
@ -171,15 +183,15 @@ public class LongHashSetTest {
testSet.clear();
Assert.assertEquals(0, testSet.size());
Assert.assertFalse(testSet.contains(1L));
Assert.assertFalse(testSet.contains(1001L));
assertEquals(0, testSet.size());
assertFalse(testSet.contains(1L));
assertFalse(testSet.contains(1001L));
}
@Test
public void twoEmptySetsAreEqual() {
final LongHashSet other = new LongHashSet(100);
Assert.assertEquals(testSet, other);
assertEquals(testSet, other);
}
@Test
@ -189,7 +201,7 @@ public class LongHashSetTest {
addTwoElements(testSet);
addTwoElements(other);
Assert.assertEquals(testSet, other);
assertEquals(testSet, other);
}
@Test
@ -200,7 +212,7 @@ public class LongHashSetTest {
other.add(1001L);
Assert.assertNotEquals(testSet, other);
assertNotEquals(testSet, other);
}
@Test
@ -212,12 +224,12 @@ public class LongHashSetTest {
other.add(2L);
other.add(1001L);
Assert.assertNotEquals(testSet, other);
assertNotEquals(testSet, other);
}
@Test
public void twoEmptySetsHaveTheSameHashcode() {
Assert.assertEquals(testSet.hashCode(), new LongHashSet(100).hashCode());
assertEquals(testSet.hashCode(), new LongHashSet(100).hashCode());
}
@Test
@ -228,7 +240,7 @@ public class LongHashSetTest {
addTwoElements(other);
Assert.assertEquals(testSet.hashCode(), other.hashCode());
assertEquals(testSet.hashCode(), other.hashCode());
}
@Test
@ -237,19 +249,23 @@ public class LongHashSetTest {
testSet.remove(1001L);
Assert.assertEquals(1, testSet.size());
assertEquals(1, testSet.size());
}
@SuppressWarnings("CollectionToArraySafeParameter")
@Test(expected = ArrayStoreException.class)
@Test
public void toArrayThrowsArrayStoreExceptionForWrongType() {
testSet.toArray(new String[1]);
assertThrows(ArrayStoreException.class, () -> {
testSet.toArray(new String[1]);
});
}
@Test(expected = NullPointerException.class)
@Test
public void toArrayThrowsNullPointerExceptionForNullArgument() {
final Long[] into = null;
testSet.toArray(into);
assertThrows(NullPointerException.class, () -> {
final Long[] into = null;
testSet.toArray(into);
});
}
@Test
@ -274,7 +290,7 @@ public class LongHashSetTest {
public void toArraySupportsEmptyCollection() {
final Long[] result = testSet.toArray(new Long[testSet.size()]);
Assert.assertArrayEquals(result, new Long[]{});
assertArrayEquals(result, new Long[]{});
}
// Test case from usage bug.
@ -288,21 +304,21 @@ public class LongHashSetTest {
requiredFields.add(49L);
requiredFields.add(56L);
Assert.assertTrue("Failed to remove 8", requiredFields.remove(8L));
Assert.assertTrue("Failed to remove 9", requiredFields.remove(9L));
Assert.assertTrue("requiredFields does not contain " + 35, requiredFields.contains(35L));
Assert.assertTrue("requiredFields does not contain " + 49, requiredFields.contains(49L));
Assert.assertTrue("requiredFields does not contain " + 56, requiredFields.contains(56L));
assertTrue(requiredFields.remove(8L), "Failed to remove 8");
assertTrue(requiredFields.remove(9L), "Failed to remove 9");
assertTrue(requiredFields.contains(35L), "requiredFields does not contain " + 35);
assertTrue(requiredFields.contains(49L), "requiredFields does not contain " + 49);
assertTrue(requiredFields.contains(56L), "requiredFields does not contain " + 56);
}
@Test
public void shouldResizeWhenItHitsCapacity() {
for (long i = 0; i < 2 * INITIAL_CAPACITY; i++) {
Assert.assertTrue(testSet.add(i));
assertTrue(testSet.add(i));
}
for (long i = 0; i < 2 * INITIAL_CAPACITY; i++) {
Assert.assertTrue(testSet.contains(i));
assertTrue(testSet.contains(i));
}
}
@ -310,8 +326,8 @@ public class LongHashSetTest {
public void containsEmptySet() {
final LongHashSet other = new LongHashSet(100);
Assert.assertTrue(testSet.containsAll(other));
Assert.assertTrue(testSet.containsAll((Collection<?>) other));
assertTrue(testSet.containsAll(other));
assertTrue(testSet.containsAll((Collection<?>) other));
}
@Test
@ -322,8 +338,8 @@ public class LongHashSetTest {
subset.add(1L);
Assert.assertTrue(testSet.containsAll(subset));
Assert.assertTrue(testSet.containsAll((Collection<?>) subset));
assertTrue(testSet.containsAll(subset));
assertTrue(testSet.containsAll((Collection<?>) subset));
}
@Test
@ -335,8 +351,8 @@ public class LongHashSetTest {
other.add(1L);
other.add(1002L);
Assert.assertFalse(testSet.containsAll(other));
Assert.assertFalse(testSet.containsAll((Collection<?>) other));
assertFalse(testSet.containsAll(other));
assertFalse(testSet.containsAll((Collection<?>) other));
}
@Test
@ -348,16 +364,16 @@ public class LongHashSetTest {
addTwoElements(superset);
superset.add(15L);
Assert.assertFalse(testSet.containsAll(superset));
Assert.assertFalse(testSet.containsAll((Collection<?>) superset));
assertFalse(testSet.containsAll(superset));
assertFalse(testSet.containsAll((Collection<?>) superset));
}
@Test
public void addingEmptySetDoesNothing() {
addTwoElements(testSet);
Assert.assertFalse(testSet.addAll(new LongHashSet(100)));
Assert.assertFalse(testSet.addAll(new HashSet<>()));
assertFalse(testSet.addAll(new LongHashSet(100)));
assertFalse(testSet.addAll(new HashSet<>()));
assertContainsElements(testSet);
}
@ -371,8 +387,8 @@ public class LongHashSetTest {
final HashSet<Long> subSetCollection = new HashSet<>(subset);
Assert.assertFalse(testSet.addAll(subset));
Assert.assertFalse(testSet.addAll(subSetCollection));
assertFalse(testSet.addAll(subset));
assertFalse(testSet.addAll(subSetCollection));
assertContainsElements(testSet);
}
@ -386,8 +402,8 @@ public class LongHashSetTest {
final HashSet<Long> equalCollection = new HashSet<>(equal);
Assert.assertFalse(testSet.addAll(equal));
Assert.assertFalse(testSet.addAll(equalCollection));
assertFalse(testSet.addAll(equal));
assertFalse(testSet.addAll(equalCollection));
assertContainsElements(testSet);
}
@ -400,10 +416,10 @@ public class LongHashSetTest {
disjoint.add(2L);
disjoint.add(1002L);
Assert.assertTrue(testSet.addAll(disjoint));
Assert.assertTrue(testSet.contains(1L));
Assert.assertTrue(testSet.contains(1001L));
Assert.assertTrue(testSet.containsAll(disjoint));
assertTrue(testSet.addAll(disjoint));
assertTrue(testSet.contains(1L));
assertTrue(testSet.contains(1001L));
assertTrue(testSet.containsAll(disjoint));
}
@Test
@ -415,10 +431,10 @@ public class LongHashSetTest {
disjoint.add(2L);
disjoint.add(1002L);
Assert.assertTrue(testSet.addAll(disjoint));
Assert.assertTrue(testSet.contains(1L));
Assert.assertTrue(testSet.contains(1001L));
Assert.assertTrue(testSet.containsAll(disjoint));
assertTrue(testSet.addAll(disjoint));
assertTrue(testSet.contains(1L));
assertTrue(testSet.contains(1001L));
assertTrue(testSet.containsAll(disjoint));
}
@Test
@ -430,10 +446,10 @@ public class LongHashSetTest {
intersecting.add(1L);
intersecting.add(1002L);
Assert.assertTrue(testSet.addAll(intersecting));
Assert.assertTrue(testSet.contains(1L));
Assert.assertTrue(testSet.contains(1001L));
Assert.assertTrue(testSet.containsAll(intersecting));
assertTrue(testSet.addAll(intersecting));
assertTrue(testSet.contains(1L));
assertTrue(testSet.contains(1001L));
assertTrue(testSet.containsAll(intersecting));
}
@Test
@ -445,18 +461,18 @@ public class LongHashSetTest {
intersecting.add(1L);
intersecting.add(1002L);
Assert.assertTrue(testSet.addAll(intersecting));
Assert.assertTrue(testSet.contains(1L));
Assert.assertTrue(testSet.contains(1001L));
Assert.assertTrue(testSet.containsAll(intersecting));
assertTrue(testSet.addAll(intersecting));
assertTrue(testSet.contains(1L));
assertTrue(testSet.contains(1001L));
assertTrue(testSet.containsAll(intersecting));
}
@Test
public void removingEmptySetDoesNothing() {
addTwoElements(testSet);
Assert.assertFalse(testSet.removeAll(new LongHashSet(100)));
Assert.assertFalse(testSet.removeAll(new HashSet<Long>()));
assertFalse(testSet.removeAll(new LongHashSet(100)));
assertFalse(testSet.removeAll(new HashSet<Long>()));
assertContainsElements(testSet);
}
@ -469,8 +485,8 @@ public class LongHashSetTest {
disjoint.add(2L);
disjoint.add(1002L);
Assert.assertFalse(testSet.removeAll(disjoint));
Assert.assertFalse(testSet.removeAll(new HashSet<Long>()));
assertFalse(testSet.removeAll(disjoint));
assertFalse(testSet.removeAll(new HashSet<Long>()));
assertContainsElements(testSet);
}
@ -483,9 +499,9 @@ public class LongHashSetTest {
intersecting.add(1L);
intersecting.add(1002L);
Assert.assertTrue(testSet.removeAll(intersecting));
Assert.assertTrue(testSet.contains(1001L));
Assert.assertFalse(testSet.containsAll(intersecting));
assertTrue(testSet.removeAll(intersecting));
assertTrue(testSet.contains(1001L));
assertFalse(testSet.containsAll(intersecting));
}
@Test
@ -497,9 +513,9 @@ public class LongHashSetTest {
intersecting.add(1L);
intersecting.add(1002L);
Assert.assertTrue(testSet.removeAll(intersecting));
Assert.assertTrue(testSet.contains(1001L));
Assert.assertFalse(testSet.containsAll(intersecting));
assertTrue(testSet.removeAll(intersecting));
assertTrue(testSet.contains(1001L));
assertFalse(testSet.containsAll(intersecting));
}
@Test
@ -510,8 +526,8 @@ public class LongHashSetTest {
addTwoElements(equal);
Assert.assertTrue(testSet.removeAll(equal));
Assert.assertTrue(testSet.isEmpty());
assertTrue(testSet.removeAll(equal));
assertTrue(testSet.isEmpty());
}
@Test
@ -522,8 +538,8 @@ public class LongHashSetTest {
addTwoElements(equal);
Assert.assertTrue(testSet.removeAll(equal));
Assert.assertTrue(testSet.isEmpty());
assertTrue(testSet.removeAll(equal));
assertTrue(testSet.isEmpty());
}
@Test
@ -537,33 +553,33 @@ public class LongHashSetTest {
}
}
Assert.assertTrue("testSet does not contain 1001", testSet.contains(1001L));
Assert.assertEquals(1, testSet.size());
assertTrue(testSet.contains(1001L), "testSet does not contain 1001");
assertEquals(1, testSet.size());
}
@Test
public void shouldNotContainMissingValueInitially() {
Assert.assertFalse(testSet.contains(LongHashSet.MISSING_VALUE));
assertFalse(testSet.contains(LongHashSet.MISSING_VALUE));
}
@Test
public void shouldAllowMissingValue() {
Assert.assertTrue(testSet.add(LongHashSet.MISSING_VALUE));
assertTrue(testSet.add(LongHashSet.MISSING_VALUE));
Assert.assertTrue(testSet.contains(LongHashSet.MISSING_VALUE));
assertTrue(testSet.contains(LongHashSet.MISSING_VALUE));
Assert.assertFalse(testSet.add(LongHashSet.MISSING_VALUE));
assertFalse(testSet.add(LongHashSet.MISSING_VALUE));
}
@Test
public void shouldAllowRemovalOfMissingValue() {
Assert.assertTrue(testSet.add(LongHashSet.MISSING_VALUE));
assertTrue(testSet.add(LongHashSet.MISSING_VALUE));
Assert.assertTrue(testSet.remove(LongHashSet.MISSING_VALUE));
assertTrue(testSet.remove(LongHashSet.MISSING_VALUE));
Assert.assertFalse(testSet.contains(LongHashSet.MISSING_VALUE));
assertFalse(testSet.contains(LongHashSet.MISSING_VALUE));
Assert.assertFalse(testSet.remove(LongHashSet.MISSING_VALUE));
assertFalse(testSet.remove(LongHashSet.MISSING_VALUE));
}
@Test
@ -571,7 +587,7 @@ public class LongHashSetTest {
testSet.add(1L);
testSet.add(LongHashSet.MISSING_VALUE);
Assert.assertEquals(2, testSet.size());
assertEquals(2, testSet.size());
}
@Test
@ -582,9 +598,9 @@ public class LongHashSetTest {
final Long[] result = testSet.toArray(new Long[testSet.size()]);
Assert.assertTrue(Arrays.asList(result).contains(1L));
Assert.assertTrue(Arrays.asList(result).contains(1001L));
Assert.assertTrue(Arrays.asList(result).contains(LongHashSet.MISSING_VALUE));
assertTrue(Arrays.asList(result).contains(1L));
assertTrue(Arrays.asList(result).contains(1001L));
assertTrue(Arrays.asList(result).contains(LongHashSet.MISSING_VALUE));
}
@Test
@ -595,9 +611,9 @@ public class LongHashSetTest {
final Object[] result = testSet.toArray();
Assert.assertTrue(Arrays.asList(result).contains(1L));
Assert.assertTrue(Arrays.asList(result).contains(1001L));
Assert.assertTrue(Arrays.asList(result).contains(LongHashSet.MISSING_VALUE));
assertTrue(Arrays.asList(result).contains(1L));
assertTrue(Arrays.asList(result).contains(1001L));
assertTrue(Arrays.asList(result).contains(LongHashSet.MISSING_VALUE));
}
@Test
@ -608,14 +624,14 @@ public class LongHashSetTest {
final LongHashSet other = new LongHashSet(100);
addTwoElements(other);
Assert.assertNotEquals(testSet, other);
assertNotEquals(testSet, other);
other.add(LongHashSet.MISSING_VALUE);
Assert.assertEquals(testSet, other);
assertEquals(testSet, other);
testSet.remove(LongHashSet.MISSING_VALUE);
Assert.assertNotEquals(testSet, other);
assertNotEquals(testSet, other);
}
@Test
@ -624,14 +640,14 @@ public class LongHashSetTest {
testSet.add(i);
}
Assert.assertEquals(10_000, testSet.size());
assertEquals(10_000, testSet.size());
int distinctElements = 0;
for (final long ignore : testSet) {
distinctElements++;
}
Assert.assertEquals(10_000, distinctElements);
assertEquals(10_000, distinctElements);
}
@Test
@ -642,14 +658,14 @@ public class LongHashSetTest {
final LongHashSet other = new LongHashSet(100);
addTwoElements(other);
Assert.assertNotEquals(testSet.hashCode(), other.hashCode());
assertNotEquals(testSet.hashCode(), other.hashCode());
other.add(LongHashSet.MISSING_VALUE);
Assert.assertEquals(testSet.hashCode(), other.hashCode());
assertEquals(testSet.hashCode(), other.hashCode());
testSet.remove(LongHashSet.MISSING_VALUE);
Assert.assertNotEquals(testSet.hashCode(), other.hashCode());
assertNotEquals(testSet.hashCode(), other.hashCode());
}
@Test
@ -665,7 +681,7 @@ public class LongHashSetTest {
}
}
Assert.assertEquals(1, missingValueCount);
assertEquals(1, missingValueCount);
}
@Test
@ -680,7 +696,7 @@ public class LongHashSetTest {
}
}
Assert.assertFalse(testSet.contains(LongHashSet.MISSING_VALUE));
assertFalse(testSet.contains(LongHashSet.MISSING_VALUE));
}
@Test
@ -692,16 +708,16 @@ public class LongHashSetTest {
}
final String mapAsAString = "{1, 19, 11, 7, 3, 12, -2}";
Assert.assertEquals(testSet.toString(), mapAsAString);
assertEquals(testSet.toString(), mapAsAString);
}
@Test
public void shouldRemoveMissingValueWhenCleared() {
Assert.assertTrue(testSet.add(LongHashSet.MISSING_VALUE));
assertTrue(testSet.add(LongHashSet.MISSING_VALUE));
testSet.clear();
Assert.assertFalse(testSet.contains(LongHashSet.MISSING_VALUE));
assertFalse(testSet.contains(LongHashSet.MISSING_VALUE));
}
@Test
@ -720,9 +736,9 @@ public class LongHashSetTest {
testSet.add(LongHashSet.MISSING_VALUE);
}
Assert.assertEquals("Fail with seed:" + seed, testSet, compatibleSet);
Assert.assertEquals("Fail with seed:" + seed, compatibleSet, testSet);
Assert.assertEquals("Fail with seed:" + seed, compatibleSet.hashCode(), testSet.hashCode());
assertEquals(testSet, compatibleSet, "Fail with seed:" + seed);
assertEquals(compatibleSet, testSet, "Fail with seed:" + seed);
assertEquals(compatibleSet.hashCode(), testSet.hashCode(), "Fail with seed:" + seed);
}
private static void addTwoElements(final LongHashSet obj) {
@ -740,11 +756,11 @@ public class LongHashSetTest {
final Set<Long> values = new HashSet<>();
Assert.assertTrue(iter.hasNext());
assertTrue(iter.hasNext());
values.add(iter.next());
Assert.assertTrue(iter.hasNext());
assertTrue(iter.hasNext());
values.add(iter.next());
Assert.assertFalse(iter.hasNext());
assertFalse(iter.hasNext());
assertContainsElements(values);
}
@ -761,13 +777,13 @@ public class LongHashSetTest {
}
private static void assertArrayContainingElements(final Long[] result) {
Assert.assertTrue(Arrays.asList(result).contains(1L));
Assert.assertTrue(Arrays.asList(result).contains(1001L));
assertTrue(Arrays.asList(result).contains(1L));
assertTrue(Arrays.asList(result).contains(1001L));
}
private static void assertContainsElements(final Set<Long> other) {
Assert.assertTrue(other.contains(1L));
Assert.assertTrue(other.contains(1001L));
assertTrue(other.contains(1L));
assertTrue(other.contains(1001L));
}
private void exhaustIterator() {

8
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/MultiIteratorTest.java
View File

@ -16,14 +16,14 @@
*/
package org.apache.activemq.artemis.utils.collections;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.Iterator;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.Test;
public class MultiIteratorTest {

10
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/MultiResettableIteratorTest.java
View File

@ -16,14 +16,14 @@
*/
package org.apache.activemq.artemis.utils.collections;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.Test;
public class MultiResettableIteratorTest {

12
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/NoOpMapTest.java
View File

@ -16,14 +16,16 @@
*/
package org.apache.activemq.artemis.utils.collections;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class NoOpMapTest {

10
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/PriorityCollectionTest.java
View File

@ -16,8 +16,12 @@
*/
package org.apache.activemq.artemis.utils.collections;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.core.PriorityAware;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Iterator;
@ -29,10 +33,6 @@ import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadLocalRandom;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class PriorityCollectionTest {
@Test

96
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/SparseArrayLinkedListTest.java
View File

@ -16,11 +16,13 @@
*/
package org.apache.activemq.artemis.utils.collections;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.ArrayList;
import java.util.List;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class SparseArrayLinkedListTest {
@ -33,35 +35,41 @@ public class SparseArrayLinkedListTest {
list = new SparseArrayLinkedList<>(SPARSE_ARRAY_CAPACITY);
}
@Test(expected = IllegalArgumentException.class)
@Test
public void shouldFailToCreateZeroArrayCapacityCollection() {
new SparseArrayLinkedList<>(0);
assertThrows(IllegalArgumentException.class, () -> {
new SparseArrayLinkedList<>(0);
});
}
@Test(expected = IllegalArgumentException.class)
@Test
public void shouldFailToCreateNegativeArrayCapacityCollection() {
new SparseArrayLinkedList<>(-1);
assertThrows(IllegalArgumentException.class, () -> {
new SparseArrayLinkedList<>(-1);
});
}
@Test(expected = NullPointerException.class)
@Test
public void shouldFailToAddNull() {
list.add(null);
assertThrows(NullPointerException.class, () -> {
list.add(null);
});
}
@Test
public void shouldNumberOfElementsBeTheSameOfTheAddedElements() {
final int elements = ELEMENTS;
for (int i = 0; i < elements; i++) {
Assert.assertEquals(i, list.size());
assertEquals(i, list.size());
list.add(i);
}
Assert.assertEquals(elements, list.size());
assertEquals(elements, list.size());
}
@Test
public void shouldClearConsumeElementsInOrder() {
final int elements = ELEMENTS;
Assert.assertEquals(0, list.clear(null));
assertEquals(0, list.clear(null));
final ArrayList<Integer> expected = new ArrayList<>(elements);
for (int i = 0; i < elements; i++) {
final Integer added = i;
@ -69,10 +77,10 @@ public class SparseArrayLinkedListTest {
expected.add(added);
}
final List<Integer> removed = new ArrayList<>(elements);
Assert.assertEquals(elements, list.clear(removed::add));
Assert.assertEquals(1, list.sparseArraysCount());
Assert.assertEquals(0, list.size());
Assert.assertEquals(expected, removed);
assertEquals(elements, list.clear(removed::add));
assertEquals(1, list.sparseArraysCount());
assertEquals(0, list.size());
assertEquals(expected, removed);
}
@Test
@ -81,15 +89,15 @@ public class SparseArrayLinkedListTest {
for (int i = 0; i < elements; i++) {
list.add(i);
}
Assert.assertEquals(1, list.remove(e -> e.intValue() == 0));
Assert.assertEquals(elements - 1, list.size());
Assert.assertEquals(0, list.remove(e -> e.intValue() == 0));
Assert.assertEquals(elements - 1, list.size());
Assert.assertEquals(elements - 1, list.remove(e -> true));
Assert.assertEquals(0, list.size());
Assert.assertEquals(1, list.sparseArraysCount());
Assert.assertEquals(0, list.remove(e -> true));
Assert.assertEquals(1, list.sparseArraysCount());
assertEquals(1, list.remove(e -> e.intValue() == 0));
assertEquals(elements - 1, list.size());
assertEquals(0, list.remove(e -> e.intValue() == 0));
assertEquals(elements - 1, list.size());
assertEquals(elements - 1, list.remove(e -> true));
assertEquals(0, list.size());
assertEquals(1, list.sparseArraysCount());
assertEquals(0, list.remove(e -> true));
assertEquals(1, list.sparseArraysCount());
}
@Test
@ -101,21 +109,21 @@ public class SparseArrayLinkedListTest {
// remove elements in the middle
final int startInclusiveMiddle = list.sparseArrayCapacity();
final int endNotInclusiveMiddle = startInclusiveMiddle + list.sparseArrayCapacity();
Assert.assertEquals(list.sparseArrayCapacity(),
assertEquals(list.sparseArrayCapacity(),
list.remove(e -> e.intValue() >= startInclusiveMiddle && e.intValue() < endNotInclusiveMiddle));
Assert.assertEquals(2, list.sparseArraysCount());
assertEquals(2, list.sparseArraysCount());
// remove elements at the beginning
final int startInclusiveFirst = 0;
final int endNotInclusiveFirst = startInclusiveMiddle;
Assert.assertEquals(list.sparseArrayCapacity(),
assertEquals(list.sparseArrayCapacity(),
list.remove(e -> e.intValue() >= startInclusiveFirst && e.intValue() < endNotInclusiveFirst));
Assert.assertEquals(1, list.sparseArraysCount());
assertEquals(1, list.sparseArraysCount());
// remove all elements at the end
final int startInclusiveLast = endNotInclusiveMiddle;
final int endNotInclusiveLast = elements;
Assert.assertEquals(list.sparseArrayCapacity(),
assertEquals(list.sparseArrayCapacity(),
list.remove(e -> e.intValue() >= startInclusiveLast && e.intValue() < endNotInclusiveLast));
Assert.assertEquals(1, list.sparseArraysCount());
assertEquals(1, list.sparseArraysCount());
}
@Test
@ -124,14 +132,14 @@ public class SparseArrayLinkedListTest {
for (int i = 0; i < elements; i++) {
list.add(i);
}
Assert.assertEquals(1, list.sparseArraysCount());
assertEquals(1, list.sparseArraysCount());
// removing last element
Assert.assertEquals(1, list.remove(e -> e.intValue() == elements - 1));
assertEquals(1, list.remove(e -> e.intValue() == elements - 1));
list.add(elements - 1);
Assert.assertEquals(1, list.sparseArraysCount());
Assert.assertEquals(1, list.remove(e -> e.intValue() == 0));
assertEquals(1, list.sparseArraysCount());
assertEquals(1, list.remove(e -> e.intValue() == 0));
list.add(elements);
Assert.assertEquals(2, list.sparseArraysCount());
assertEquals(2, list.sparseArraysCount());
}
@Test
@ -140,14 +148,14 @@ public class SparseArrayLinkedListTest {
for (int i = 0; i < elements; i++) {
list.add(i);
}
Assert.assertEquals(1, list.sparseArraysCount());
assertEquals(1, list.sparseArraysCount());
// removing all elements
Assert.assertEquals(elements, list.remove(e -> true));
Assert.assertEquals(1, list.sparseArraysCount());
assertEquals(elements, list.remove(e -> true));
assertEquals(1, list.sparseArraysCount());
for (int i = 0; i < elements; i++) {
list.add(i);
}
Assert.assertEquals(1, list.sparseArraysCount());
assertEquals(1, list.sparseArraysCount());
}
@Test
@ -158,12 +166,12 @@ public class SparseArrayLinkedListTest {
for (int i = 1; i < elements; i++) {
list.add(i);
}
Assert.assertEquals(elements - 1, list.remove(e -> !zero.equals(e)));
assertEquals(elements - 1, list.remove(e -> !zero.equals(e)));
final ArrayList<Integer> remaining = new ArrayList<>();
Assert.assertEquals(1, list.clear(remaining::add));
Assert.assertEquals(0, list.size());
Assert.assertEquals(1, remaining.size());
Assert.assertEquals(zero, remaining.get(0));
assertEquals(1, list.clear(remaining::add));
assertEquals(0, list.size());
assertEquals(1, remaining.size());
assertEquals(zero, remaining.get(0));
}
}

8
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/collections/UpdatableIteratorTest.java
View File

@ -16,13 +16,13 @@
*/
package org.apache.activemq.artemis.utils.collections;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.Test;
public class UpdatableIteratorTest {

47
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/critical/CriticalAnalyzerTest.java
View File

@ -16,26 +16,25 @@
*/
package org.apache.activemq.artemis.utils.critical;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.activemq.artemis.tests.util.ArtemisTestCase;
import org.apache.activemq.artemis.utils.ArtemisCloseable;
import org.apache.activemq.artemis.utils.ReusableLatch;
import org.apache.activemq.artemis.utils.ThreadLeakCheckRule;
import org.junit.After;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
public class CriticalAnalyzerTest {
@Rule
public ThreadLeakCheckRule rule = new ThreadLeakCheckRule();
public class CriticalAnalyzerTest extends ArtemisTestCase {
private CriticalAnalyzer analyzer;
@After
@AfterEach
public void tearDown() throws Exception {
if (analyzer != null) {
analyzer.stop();
@ -51,17 +50,17 @@ public class CriticalAnalyzerTest {
CriticalCloseable closeable1 = component.measureCritical(0);
Assert.assertFalse(CriticalMeasure.isDummy(closeable1));
assertFalse(CriticalMeasure.isDummy(closeable1));
ArtemisCloseable closeable2 = component.measureCritical(0);
Assert.assertTrue(CriticalMeasure.isDummy(closeable2));
assertTrue(CriticalMeasure.isDummy(closeable2));
closeable1.close();
closeable2 = component.measureCritical(0);
Assert.assertFalse(CriticalMeasure.isDummy(closeable2));
assertFalse(CriticalMeasure.isDummy(closeable2));
}
@Test
@ -72,7 +71,7 @@ public class CriticalAnalyzerTest {
analyzer.add(component);
CriticalCloseable closeable = component.measureCritical(0);
Assert.assertFalse(CriticalMeasure.isDummy(closeable));
assertFalse(CriticalMeasure.isDummy(closeable));
CriticalCloseable dummy = component.measureCritical(0);
@ -83,17 +82,17 @@ public class CriticalAnalyzerTest {
exception = true;
}
Assert.assertTrue(exception);
assertTrue(exception);
AtomicInteger value = new AtomicInteger(0);
closeable.beforeClose(() -> value.set(1000));
Assert.assertEquals(0, value.get());
assertEquals(0, value.get());
closeable.close();
Assert.assertEquals(1000, value.get());
assertEquals(1000, value.get());
}
@ -125,7 +124,7 @@ public class CriticalAnalyzerTest {
latch.countDown();
});
Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));
assertTrue(latch.await(10, TimeUnit.SECONDS));
analyzer.stop();
}
@ -149,7 +148,7 @@ public class CriticalAnalyzerTest {
analyzer.start();
Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));
assertTrue(latch.await(10, TimeUnit.SECONDS));
analyzer.stop();
}
@ -159,7 +158,7 @@ public class CriticalAnalyzerTest {
analyzer = new CriticalAnalyzerImpl().setTimeout(10, TimeUnit.MILLISECONDS).setCheckTime(5, TimeUnit.MILLISECONDS);
CriticalComponent component = new CriticalComponentImpl(analyzer, 2);
component.measureCritical(0);
Assert.assertFalse(component.checkExpiration(TimeUnit.MINUTES.toNanos(1), false));
assertFalse(component.checkExpiration(TimeUnit.MINUTES.toNanos(1), false));
analyzer.stop();
}
@ -170,7 +169,7 @@ public class CriticalAnalyzerTest {
CriticalComponent component = new CriticalComponentImpl(analyzer, 2);
component.measureCritical(0);
Thread.sleep(50);
Assert.assertTrue(component.checkExpiration(0, false));
assertTrue(component.checkExpiration(0, false));
analyzer.stop();
}
@ -192,7 +191,7 @@ public class CriticalAnalyzerTest {
analyzer.start();
Assert.assertFalse(latch.await(100, TimeUnit.MILLISECONDS));
assertFalse(latch.await(100, TimeUnit.MILLISECONDS));
analyzer.stop();
}
@ -215,13 +214,13 @@ public class CriticalAnalyzerTest {
analyzer.start();
Assert.assertTrue(latch.await(100, TimeUnit.MILLISECONDS));
assertTrue(latch.await(100, TimeUnit.MILLISECONDS));
measure.close();
latch.setCount(1);
Assert.assertFalse(latch.await(100, TimeUnit.MILLISECONDS));
assertFalse(latch.await(100, TimeUnit.MILLISECONDS));
analyzer.stop();
}

25
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/critical/CriticalMeasureTest.java
View File

@ -17,13 +17,16 @@
package org.apache.activemq.artemis.utils.critical;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class CriticalMeasureTest {
@ -32,7 +35,7 @@ public class CriticalMeasureTest {
CriticalMeasure measure = new CriticalMeasure(null, 1);
long time = System.nanoTime();
measure.timeEnter = time - TimeUnit.SECONDS.toNanos(5);
Assert.assertFalse(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), false));
assertFalse(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), false));
}
@Test
@ -44,7 +47,7 @@ public class CriticalMeasureTest {
measure.enterCritical();
measure.timeEnter = time - TimeUnit.MINUTES.toNanos(30);
measure.leaveCritical();
Assert.assertFalse(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), false));
assertFalse(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), false));
}
@Test
@ -55,11 +58,11 @@ public class CriticalMeasureTest {
long time = System.nanoTime();
AutoCloseable closeable = measure.measure();
measure.timeEnter = time - TimeUnit.MINUTES.toNanos(5);
Assert.assertTrue(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), false)); // on this call we should had a reset before
assertTrue(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), false)); // on this call we should had a reset before
// subsequent call without reset should still fail
Assert.assertTrue(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), true));
assertTrue(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), true));
// previous reset should have cleared it
Assert.assertFalse(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), false));
assertFalse(measure.checkExpiration(TimeUnit.SECONDS.toNanos(30), false));
closeable.close();
}
@ -69,9 +72,9 @@ public class CriticalMeasureTest {
CriticalComponent component = new CriticalComponentImpl(analyzer, 5);
try (AutoCloseable theMeasure = component.measureCritical(0)) {
LockSupport.parkNanos(1000);
Assert.assertTrue(component.checkExpiration(100, false));
assertTrue(component.checkExpiration(100, false));
}
Assert.assertFalse(component.checkExpiration(100, false));
assertFalse(component.checkExpiration(100, false));
}
@Test
@ -101,7 +104,7 @@ public class CriticalMeasureTest {
running.set(false);
}
t.join(1000);
Assert.assertFalse(t.isAlive());
Assert.assertEquals(0, errors.get());
assertFalse(t.isAlive());
assertEquals(0, errors.get());
}
}

15
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/critical/MultiThreadCriticalMeasureTest.java
View File

@ -17,6 +17,11 @@
package org.apache.activemq.artemis.utils.critical;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.lang.invoke.MethodHandles;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@ -27,11 +32,9 @@ import java.util.concurrent.locks.LockSupport;
import org.apache.activemq.artemis.utils.ReusableLatch;
import org.apache.activemq.artemis.utils.Wait;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;
import org.junit.Assert;
import org.junit.Test;
public class MultiThreadCriticalMeasureTest {
@ -92,7 +95,7 @@ public class MultiThreadCriticalMeasureTest {
// waiting a few milliseconds as the bug was about measuring load after a no load
LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(20));
Assert.assertFalse(measure.checkExpiration(TimeUnit.MILLISECONDS.toNanos(10), false));
assertFalse(measure.checkExpiration(TimeUnit.MILLISECONDS.toNanos(10), false));
logger.debug("Count down");
// letting load to happen again
@ -102,14 +105,14 @@ public class MultiThreadCriticalMeasureTest {
}
latchOnMeasure.countUp();
Assert.assertTrue(Wait.waitFor(() -> measure.checkExpiration(TimeUnit.MILLISECONDS.toNanos(100), false), 1_000, 1));
assertTrue(Wait.waitFor(() -> measure.checkExpiration(TimeUnit.MILLISECONDS.toNanos(100), false), 1_000, 1));
} finally {
load.set(true);
running.set(false);
latchOnMeasure.countDown();
Assert.assertEquals(0, errors.get());
assertEquals(0, errors.get());
executorService.shutdown();
Wait.assertTrue(executorService::isShutdown);
Wait.assertTrue(executorService::isTerminated, 5000, 1);

37
artemis-commons/src/test/java/org/apache/activemq/artemis/utils/runnables/RunnableListTest.java
View File

@ -17,12 +17,13 @@
package org.apache.activemq.artemis.utils.runnables;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class RunnableListTest {
@ -50,16 +51,16 @@ public class RunnableListTest {
}
}
Assert.assertEquals(30, masterList.size());
assertEquals(30, masterList.size());
runList(listA);
Assert.assertEquals(10, result.get());
assertEquals(10, result.get());
Assert.assertEquals(20, masterList.size());
Assert.assertEquals(0, listA.size());
Assert.assertEquals(10, listB.size());
Assert.assertEquals(10, listC.size());
assertEquals(20, masterList.size());
assertEquals(0, listA.size());
assertEquals(10, listB.size());
assertEquals(10, listC.size());
HashSet<AtomicRunnable> copyList = new HashSet<>();
copyList.addAll(masterList);
@ -67,10 +68,10 @@ public class RunnableListTest {
copyList.forEach(r -> r.run());
for (RunnableList l : lists) {
Assert.assertEquals(0, l.size());
assertEquals(0, l.size());
}
Assert.assertEquals(30, result.get());
assertEquals(30, result.get());
}
@Test
@ -95,25 +96,25 @@ public class RunnableListTest {
}
}
Assert.assertEquals(30, masterList.size());
assertEquals(30, masterList.size());
listA.cancel();
Assert.assertEquals(0, result.get());
assertEquals(0, result.get());
Assert.assertEquals(20, masterList.size());
Assert.assertEquals(0, listA.size());
Assert.assertEquals(10, listB.size());
Assert.assertEquals(10, listC.size());
assertEquals(20, masterList.size());
assertEquals(0, listA.size());
assertEquals(10, listB.size());
assertEquals(10, listC.size());
listB.cancel();
listC.cancel();
for (RunnableList l : lists) {
Assert.assertEquals(0, l.size());
assertEquals(0, l.size());
}
Assert.assertEquals(0, masterList.size());
assertEquals(0, masterList.size());
}
// runs all AtomicRunnables inside the list

9
artemis-core-client/pom.xml
View File

@ -62,8 +62,13 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>

38
artemis-core-client/src/test/java/org/apache/activemq/artemis/ClientThreadPoolsTest.java
View File

@ -16,6 +16,9 @@
*/
package org.apache.activemq.artemis;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;
@ -32,30 +35,27 @@ import org.apache.activemq.artemis.api.core.client.ActiveMQClient;
import org.apache.activemq.artemis.api.core.client.ServerLocator;
import org.apache.activemq.artemis.core.client.impl.ServerLocatorImpl;
import org.apache.activemq.artemis.utils.ActiveMQThreadFactory;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
public class ClientThreadPoolsTest {
private static Properties systemProperties;
@BeforeClass
@BeforeAll
public static void setup() {
systemProperties = System.getProperties();
}
@AfterClass
@AfterAll
public static void tearDown() {
System.clearProperty(ActiveMQClient.THREAD_POOL_MAX_SIZE_PROPERTY_KEY);
System.clearProperty(ActiveMQClient.SCHEDULED_THREAD_POOL_SIZE_PROPERTY_KEY);
ActiveMQClient.initializeGlobalThreadPoolProperties();
ActiveMQClient.clearThreadPools();
Assert.assertEquals(ActiveMQClient.DEFAULT_GLOBAL_THREAD_POOL_MAX_SIZE, ActiveMQClient.getGlobalThreadPoolSize());
assertEquals(ActiveMQClient.DEFAULT_GLOBAL_THREAD_POOL_MAX_SIZE, ActiveMQClient.getGlobalThreadPoolSize());
}
@Test
@ -94,9 +94,9 @@ public class ClientThreadPoolsTest {
}
});
Assert.assertTrue(inUse.await(10, TimeUnit.SECONDS));
assertTrue(inUse.await(10, TimeUnit.SECONDS));
ActiveMQClient.clearThreadPools(100, TimeUnit.MILLISECONDS);
Assert.assertTrue(neverLeave.await(10, TimeUnit.SECONDS));
assertTrue(neverLeave.await(10, TimeUnit.SECONDS));
}
@Test
@ -127,14 +127,14 @@ public class ClientThreadPoolsTest {
}
});
Assert.assertTrue(inUse.await(10, TimeUnit.SECONDS));
assertTrue(inUse.await(10, TimeUnit.SECONDS));
poolExecutor.shutdownNow();
scheduledThreadPoolExecutor.shutdownNow();
flowControlPoolExecutor.shutdownNow();
Assert.assertTrue(neverLeave.await(10, TimeUnit.SECONDS));
assertTrue(neverLeave.await(10, TimeUnit.SECONDS));
Assert.assertTrue(inUse.await(10, TimeUnit.SECONDS));
Assert.assertTrue(neverLeave.await(10, TimeUnit.SECONDS));
assertTrue(inUse.await(10, TimeUnit.SECONDS));
assertTrue(neverLeave.await(10, TimeUnit.SECONDS));
ActiveMQClient.clearThreadPools(100, TimeUnit.MILLISECONDS);
}
@ -214,9 +214,9 @@ public class ClientThreadPoolsTest {
});
}
Assert.assertTrue(doneMax.await(5, TimeUnit.SECONDS));
assertTrue(doneMax.await(5, TimeUnit.SECONDS));
latch.countDown();
Assert.assertTrue(latchTotal.await(5, TimeUnit.SECONDS));
assertTrue(latchTotal.await(5, TimeUnit.SECONDS));
ScheduledThreadPoolExecutor scheduledThreadPool = (ScheduledThreadPoolExecutor) scheduledThreadPoolField.get(serverLocator);
ThreadPoolExecutor flowControlThreadPool = (ThreadPoolExecutor) flowControlThreadPoolField.get(serverLocator);
@ -255,7 +255,7 @@ public class ClientThreadPoolsTest {
assertEquals(flowControlThreadPool, fctpe);
}
@After
@AfterEach
public void cleanup() {
// Resets the global thread pool properties back to default.
System.setProperties(systemProperties);

46
artemis-core-client/src/test/java/org/apache/activemq/artemis/api/core/JsonUtilTest.java
View File

@ -16,14 +16,16 @@
*/
package org.apache.activemq.artemis.api.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.json.JsonArray;
import org.apache.activemq.artemis.json.JsonArrayBuilder;
import org.apache.activemq.artemis.json.JsonObject;
import org.apache.activemq.artemis.json.JsonObjectBuilder;
import org.apache.activemq.artemis.utils.JsonLoader;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class JsonUtilTest {
@ -36,9 +38,9 @@ public class JsonUtilTest {
JsonObject jsonObject = jsonObjectBuilder.build();
Assert.assertTrue(jsonObject.containsKey("not-null"));
Assert.assertTrue(jsonObject.containsKey("null"));
Assert.assertEquals(2, jsonObject.size());
assertTrue(jsonObject.containsKey("not-null"));
assertTrue(jsonObject.containsKey("null"));
assertEquals(2, jsonObject.size());
}
@Test
@ -50,7 +52,7 @@ public class JsonUtilTest {
JsonArray jsonArray = jsonArrayBuilder.build();
Assert.assertEquals(2, jsonArray.size());
assertEquals(2, jsonArray.size());
}
@Test
@ -64,8 +66,8 @@ public class JsonUtilTest {
JsonObject jsonObject = jsonObjectBuilder.build();
Assert.assertTrue(jsonObject.containsKey("byteArray"));
Assert.assertEquals(6, jsonObject.getJsonArray("byteArray").size());
assertTrue(jsonObject.containsKey("byteArray"));
assertEquals(6, jsonObject.getJsonArray("byteArray").size());
}
@Test
@ -77,7 +79,7 @@ public class JsonUtilTest {
JsonArray jsonArray = jsonArrayBuilder.build();
Assert.assertEquals(1, jsonArray.size());
assertEquals(1, jsonArray.size());
}
@Test
@ -89,7 +91,7 @@ public class JsonUtilTest {
String truncated = (String) JsonUtil.truncate(prefix + remaining, valueSizeLimit);
String expected = prefix + ", + " + String.valueOf(remaining.length()) + " more";
Assert.assertEquals(expected, truncated);
assertEquals(expected, truncated);
}
@Test
@ -97,14 +99,14 @@ public class JsonUtilTest {
String input = "testTruncateUsingStringWithoutValueSizeLimit";
String notTruncated = (String) JsonUtil.truncate(input, -1);
Assert.assertEquals(input, notTruncated);
assertEquals(input, notTruncated);
}
@Test
public void testTruncateWithoutNullValue() {
Object result = JsonUtil.truncate(null, -1);
Assert.assertEquals("", result);
assertEquals("", result);
}
@Test
@ -116,7 +118,7 @@ public class JsonUtilTest {
String truncated = JsonUtil.truncateString(prefix + remaining, valueSizeLimit);
String expected = prefix + ", + " + String.valueOf(remaining.length()) + " more";
Assert.assertEquals(expected, truncated);
assertEquals(expected, truncated);
}
@Test
@ -124,7 +126,7 @@ public class JsonUtilTest {
String input = "testTruncateStringWithoutValueSizeLimit";
String notTruncated = JsonUtil.truncateString(input, -1);
Assert.assertEquals(input, notTruncated);
assertEquals(input, notTruncated);
}
@Test
@ -156,7 +158,7 @@ public class JsonUtilTest {
JsonObject mergedExpected = jsonMergedObjectBuilder.build();
Assert.assertEquals(mergedExpected, JsonUtil.mergeAndUpdate(sourceOne, sourceTwo));
assertEquals(mergedExpected, JsonUtil.mergeAndUpdate(sourceOne, sourceTwo));
}
@Test
@ -180,7 +182,7 @@ public class JsonUtilTest {
JsonObject mergedExpected = jsonMergedObjectBuilder.build();
Assert.assertEquals(mergedExpected, JsonUtil.mergeAndUpdate(sourceOne, sourceTwo));
assertEquals(mergedExpected, JsonUtil.mergeAndUpdate(sourceOne, sourceTwo));
}
@ -196,7 +198,7 @@ public class JsonUtilTest {
JsonUtil.addToObject("dup", "b", jsonTargetObjectBuilder);
JsonObject sourceTwo = jsonTargetObjectBuilder.build();
Assert.assertEquals(sourceTwo, JsonUtil.mergeAndUpdate(sourceOne, sourceTwo));
assertEquals(sourceTwo, JsonUtil.mergeAndUpdate(sourceOne, sourceTwo));
}
@Test
@ -209,7 +211,7 @@ public class JsonUtilTest {
JsonUtil.addToObject("dup", "b", jsonTargetObjectBuilder);
JsonObject sourceTwo = jsonTargetObjectBuilder.build();
Assert.assertEquals(sourceTwo, JsonUtil.mergeAndUpdate(sourceOne, sourceTwo));
assertEquals(sourceTwo, JsonUtil.mergeAndUpdate(sourceOne, sourceTwo));
}
@Test
@ -221,13 +223,13 @@ public class JsonUtilTest {
JsonObjectBuilder nested = JsonUtil.objectBuilderWithValueAtPath("a/b/c", target);
JsonObject inserted = nested.build();
Assert.assertTrue(inserted.containsKey("a"));
assertTrue(inserted.containsKey("a"));
Assert.assertEquals(target, inserted.getJsonObject("a").getJsonObject("b").getJsonObject("c"));
assertEquals(target, inserted.getJsonObject("a").getJsonObject("b").getJsonObject("c"));
nested = JsonUtil.objectBuilderWithValueAtPath("c", target);
inserted = nested.build();
Assert.assertTrue(inserted.containsKey("c"));
Assert.assertEquals(target, inserted.getJsonObject("c"));
assertTrue(inserted.containsKey("c"));
assertEquals(target, inserted.getJsonObject("c"));
}
}

56
artemis-core-client/src/test/java/org/apache/activemq/artemis/api/core/TransportConfigurationTest.java
View File

@ -16,6 +16,11 @@
*/
package org.apache.activemq.artemis.api.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
@ -23,8 +28,7 @@ import java.util.Map;
import io.netty.buffer.Unpooled;
import org.apache.activemq.artemis.core.buffers.impl.ChannelBufferWrapper;
import org.apache.activemq.artemis.core.remoting.impl.netty.TransportConstants;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class TransportConfigurationTest {
@ -33,8 +37,8 @@ public class TransportConfigurationTest {
TransportConfiguration configuration = new TransportConfiguration("SomeClass", new HashMap<String, Object>(), null);
TransportConfiguration configuration2 = new TransportConfiguration("SomeClass", new HashMap<String, Object>(), null);
Assert.assertEquals(configuration, configuration2);
Assert.assertEquals(configuration.hashCode(), configuration2.hashCode());
assertEquals(configuration, configuration2);
assertEquals(configuration.hashCode(), configuration2.hashCode());
HashMap<String, Object> configMap1 = new HashMap<>();
configMap1.put("host", "localhost");
@ -43,14 +47,14 @@ public class TransportConfigurationTest {
configuration = new TransportConfiguration("SomeClass", configMap1, null);
configuration2 = new TransportConfiguration("SomeClass", configMap2, null);
Assert.assertEquals(configuration, configuration2);
Assert.assertEquals(configuration.hashCode(), configuration2.hashCode());
assertEquals(configuration, configuration2);
assertEquals(configuration.hashCode(), configuration2.hashCode());
configuration = new TransportConfiguration("SomeClass", configMap1, "name1");
configuration2 = new TransportConfiguration("SomeClass", configMap2, "name2");
Assert.assertNotEquals(configuration, configuration2);
Assert.assertNotEquals(configuration.hashCode(), configuration2.hashCode());
Assert.assertTrue(configuration.isEquivalent(configuration2));
assertNotEquals(configuration, configuration2);
assertNotEquals(configuration.hashCode(), configuration2.hashCode());
assertTrue(configuration.isEquivalent(configuration2));
configMap1 = new HashMap<>();
configMap1.put("host", "localhost");
@ -58,8 +62,8 @@ public class TransportConfigurationTest {
configMap2.put("host", "localhost3");
configuration = new TransportConfiguration("SomeClass", configMap1, null);
configuration2 = new TransportConfiguration("SomeClass", configMap2, null);
Assert.assertNotEquals(configuration, configuration2);
Assert.assertNotEquals(configuration.hashCode(), configuration2.hashCode());
assertNotEquals(configuration, configuration2);
assertNotEquals(configuration.hashCode(), configuration2.hashCode());
}
@ -70,17 +74,17 @@ public class TransportConfigurationTest {
final Map<String, Object> params = Collections.emptyMap();
final Map<String, Object> extraParams = Collections.singletonMap("key", "foo");
Assert.assertEquals(new TransportConfiguration(className, params, name, null), new TransportConfiguration(className, params, name, null));
Assert.assertEquals(new TransportConfiguration(className, params, name, null), new TransportConfiguration(className, params, name, Collections.emptyMap()));
Assert.assertEquals(new TransportConfiguration(className, params, name, Collections.emptyMap()), new TransportConfiguration(className, params, name, null));
Assert.assertEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, extraParams));
Assert.assertEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, new HashMap<>(extraParams)));
assertEquals(new TransportConfiguration(className, params, name, null), new TransportConfiguration(className, params, name, null));
assertEquals(new TransportConfiguration(className, params, name, null), new TransportConfiguration(className, params, name, Collections.emptyMap()));
assertEquals(new TransportConfiguration(className, params, name, Collections.emptyMap()), new TransportConfiguration(className, params, name, null));
assertEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, extraParams));
assertEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, new HashMap<>(extraParams)));
Assert.assertNotEquals(new TransportConfiguration(className, params, name, null), new TransportConfiguration(className, params, name, extraParams));
Assert.assertNotEquals(new TransportConfiguration(className, params, name, Collections.emptyMap()), new TransportConfiguration(className, params, name, extraParams));
Assert.assertNotEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, Collections.singletonMap("key", "other")));
Assert.assertNotEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, null));
Assert.assertNotEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, Collections.emptyMap()));
assertNotEquals(new TransportConfiguration(className, params, name, null), new TransportConfiguration(className, params, name, extraParams));
assertNotEquals(new TransportConfiguration(className, params, name, Collections.emptyMap()), new TransportConfiguration(className, params, name, extraParams));
assertNotEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, Collections.singletonMap("key", "other")));
assertNotEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, null));
assertNotEquals(new TransportConfiguration(className, params, name, extraParams), new TransportConfiguration(className, params, name, Collections.emptyMap()));
}
@Test
@ -91,7 +95,7 @@ public class TransportConfigurationTest {
TransportConfiguration configuration = new TransportConfiguration("SomeClass", params, null);
Assert.assertFalse("configuration contains secret_password", configuration.toString().contains("secret_password"));
assertFalse(configuration.toString().contains("secret_password"), "configuration contains secret_password");
}
@Test
@ -129,14 +133,14 @@ public class TransportConfigurationTest {
TransportConfiguration decodedTransportConfiguration = new TransportConfiguration();
decodedTransportConfiguration.decode(buffer);
Assert.assertFalse(buffer.readable());
assertFalse(buffer.readable());
Assert.assertEquals(transportConfiguration.getParams(), decodedTransportConfiguration.getParams());
assertEquals(transportConfiguration.getParams(), decodedTransportConfiguration.getParams());
Assert.assertTrue((transportConfiguration.getExtraParams() == null && (decodedTransportConfiguration.getExtraParams() == null || decodedTransportConfiguration.getExtraParams().isEmpty())) ||
assertTrue((transportConfiguration.getExtraParams() == null && (decodedTransportConfiguration.getExtraParams() == null || decodedTransportConfiguration.getExtraParams().isEmpty())) ||
(decodedTransportConfiguration.getExtraParams() == null && (transportConfiguration.getExtraParams() == null || transportConfiguration.getExtraParams().isEmpty())) ||
(transportConfiguration.getExtraParams() != null && decodedTransportConfiguration.getExtraParams() != null && transportConfiguration.getExtraParams().equals(decodedTransportConfiguration.getExtraParams())));
Assert.assertEquals(transportConfiguration, decodedTransportConfiguration);
assertEquals(transportConfiguration, decodedTransportConfiguration);
}
}

12
artemis-core-client/src/test/java/org/apache/activemq/artemis/api/core/management/AddressSettingsInfoTest.java
View File

@ -19,12 +19,12 @@
package org.apache.activemq.artemis.api.core.management;
import org.apache.activemq.artemis.api.core.RoutingType;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.apache.activemq.artemis.api.core.RoutingType;
import org.junit.jupiter.api.Test;
public class AddressSettingsInfoTest {
@ -146,7 +146,7 @@ public class AddressSettingsInfoTest {
assertEquals(404, addressSettingsInfo.getExpiryDelay());
assertEquals(40, addressSettingsInfo.getMinExpiryDelay());
assertEquals(4004, addressSettingsInfo.getMaxExpiryDelay());
assertEquals(false, addressSettingsInfo.isEnableMetrics());
assertFalse(addressSettingsInfo.isEnableMetrics());
}
}

17
artemis-core-client/src/test/java/org/apache/activemq/artemis/api/core/management/OperationAnnotationTest.java
View File

@ -19,21 +19,22 @@
package org.apache.activemq.artemis.api.core.management;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collection;
import static org.junit.Assert.assertTrue;
import org.apache.activemq.artemis.tests.extensions.parameterized.ParameterizedTestExtension;
import org.apache.activemq.artemis.tests.extensions.parameterized.Parameters;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
@RunWith(Parameterized.class)
@ExtendWith(ParameterizedTestExtension.class)
public class OperationAnnotationTest {
@Parameterized.Parameters(name = "class=({0})")
@Parameters(name = "class=({0})")
public static Collection<Object[]> getTestParameters() {
return Arrays.asList(new Object[][]{{ActiveMQServerControl.class},
{AddressControl.class},
@ -52,7 +53,7 @@ public class OperationAnnotationTest {
this.managementClass = managementClass;
}
@Test
@TestTemplate
public void testEachParameterAnnotated() throws Exception {
checkControlInterface(managementClass);
}
@ -76,7 +77,7 @@ public class OperationAnnotationTest {
break;
}
}
assertTrue("method " + m + " has parameters with no Parameter annotation", hasParameterAnnotation);
assertTrue(hasParameterAnnotation, "method " + m + " has parameters with no Parameter annotation");
}
}
}

27
artemis-core-client/src/test/java/org/apache/activemq/artemis/api/core/management/ResourceNamesTest.java
View File

@ -16,6 +16,9 @@
*/
package org.apache.activemq.artemis.api.core.management;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Arrays;
import java.util.Collection;
import java.util.UUID;
@ -23,13 +26,13 @@ import java.util.UUID;
import org.apache.activemq.artemis.api.config.ActiveMQDefaultConfiguration;
import org.apache.activemq.artemis.api.core.RoutingType;
import org.apache.activemq.artemis.api.core.SimpleString;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.apache.activemq.artemis.tests.extensions.parameterized.ParameterizedTestExtension;
import org.apache.activemq.artemis.tests.extensions.parameterized.Parameters;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
@RunWith(value = Parameterized.class)
public class ResourceNamesTest extends Assert {
@ExtendWith(ParameterizedTestExtension.class)
public class ResourceNamesTest {
char delimiterChar;
final String delimiter;
@ -42,7 +45,7 @@ public class ResourceNamesTest extends Assert {
final String testResourceDivertName;
@Parameterized.Parameters(name = "delimiterChar={0}")
@Parameters(name = "delimiterChar={0}")
public static Collection<Object[]> getParams() {
return Arrays.asList(new Object[][] {{'/'}, {'.'}});
}
@ -60,28 +63,28 @@ public class ResourceNamesTest extends Assert {
testResourceDivertName = baseName + ResourceNames.DIVERT.replace('.', delimiterChar) + ResourceNames.RETROACTIVE_SUFFIX;
}
@Test
@TestTemplate
public void testGetRetroactiveResourceAddressName() {
assertEquals(testResourceAddressName, ResourceNames.getRetroactiveResourceAddressName(prefix, delimiter, testAddress).toString());
}
@Test
@TestTemplate
public void testGetRetroactiveResourceQueueName() {
assertEquals(testResourceMulticastQueueName, ResourceNames.getRetroactiveResourceQueueName(prefix, delimiter, testAddress, RoutingType.MULTICAST).toString());
assertEquals(testResourceAnycastQueueName, ResourceNames.getRetroactiveResourceQueueName(prefix, delimiter, testAddress, RoutingType.ANYCAST).toString());
}
@Test
@TestTemplate
public void testGetRetroactiveResourceDivertName() {
assertEquals(testResourceDivertName, ResourceNames.getRetroactiveResourceDivertName(prefix, delimiter, testAddress).toString());
}
@Test
@TestTemplate
public void testDecomposeRetroactiveResourceAddressName() {
assertEquals(testAddress.toString(), ResourceNames.decomposeRetroactiveResourceAddressName(prefix, delimiter, testResourceAddressName));
}
@Test
@TestTemplate
public void testIsRetroactiveResource() {
assertTrue(ResourceNames.isRetroactiveResource(prefix, SimpleString.toSimpleString(testResourceAddressName)));
assertTrue(ResourceNames.isRetroactiveResource(prefix, SimpleString.toSimpleString(testResourceMulticastQueueName)));

18
artemis-core-client/src/test/java/org/apache/activemq/artemis/core/client/CoreClientLogBundlesTest.java
View File

@ -16,27 +16,27 @@
*/
package org.apache.activemq.artemis.core.client;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.apache.activemq.artemis.api.core.ActiveMQIllegalStateException;
import org.apache.activemq.artemis.logs.AssertionLoggerHandler;
import org.apache.activemq.artemis.logs.AssertionLoggerHandler.LogLevel;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
public class CoreClientLogBundlesTest {
private static final String LOGGER_NAME = ActiveMQClientLogger.class.getPackage().getName();
private static LogLevel origLevel;
@BeforeClass
@BeforeAll
public static void setLogLevel() {
origLevel = AssertionLoggerHandler.setLevel(LOGGER_NAME, LogLevel.INFO);
}
@AfterClass
@AfterAll
public static void restoreLogLevel() throws Exception {
AssertionLoggerHandler.setLevel(LOGGER_NAME, origLevel);
}
@ -57,7 +57,7 @@ public class CoreClientLogBundlesTest {
String message = e.getMessage();
assertNotNull(message);
assertTrue("unexpected message: " + message, message.startsWith("AMQ219022"));
assertTrue("unexpected message: " + message, message.contains(String.valueOf(headerSize)));
assertTrue(message.startsWith("AMQ219022"), "unexpected message: " + message);
assertTrue(message.contains(String.valueOf(headerSize)), "unexpected message: " + message);
}
}

19
artemis-core-client/src/test/java/org/apache/activemq/artemis/core/client/impl/LargeMessageControllerImplTest.java
View File

@ -17,15 +17,19 @@
package org.apache.activemq.artemis.core.client.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.invoke.MethodHandles;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.activemq.artemis.api.core.ActiveMQException;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.mockito.Mockito;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -34,7 +38,8 @@ public class LargeMessageControllerImplTest {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@Test(timeout = 10_000)
@Test
@Timeout(value = 10_000, unit = TimeUnit.MILLISECONDS)
public void testControllerTimeout() throws Exception {
ClientConsumerInternal consumerMock = Mockito.mock(ClientConsumerInternal.class);
@ -64,13 +69,13 @@ public class LargeMessageControllerImplTest {
exceptionCounter++;
}
Assert.assertEquals(1, exceptionCounter);
assertEquals(1, exceptionCounter);
largeMessageController.addPacket(createBytes(900, filling), 1000, false);
Assert.assertTrue(largeMessageController.waitCompletion(0));
Assert.assertEquals(1000, bytesWritten.get());
Assert.assertEquals(0, errors.get());
assertTrue(largeMessageController.waitCompletion(0));
assertEquals(1000, bytesWritten.get());
assertEquals(0, errors.get());
}
byte[] createBytes(int size, byte fill) {

10
artemis-core-client/src/test/java/org/apache/activemq/artemis/core/protocol/core/impl/ChannelImplTest.java
View File

@ -16,6 +16,8 @@
*/
package org.apache.activemq.artemis.core.protocol.core.impl;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.concurrent.atomic.AtomicInteger;
import io.netty.buffer.Unpooled;
@ -26,17 +28,15 @@ import org.apache.activemq.artemis.core.protocol.core.Packet;
import org.apache.activemq.artemis.core.protocol.core.ResponseHandler;
import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.PacketsConfirmedMessage;
import org.apache.activemq.artemis.spi.core.remoting.Connection;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.junit.Assert.assertEquals;
public class ChannelImplTest {
ChannelImpl channel;
@Before
@BeforeEach
public void setUp() {
CoreRemotingConnection coreRC = Mockito.mock(CoreRemotingConnection.class);
Mockito.when(coreRC.createTransportBuffer(Packet.INITIAL_PACKET_SIZE)).thenReturn(new ChannelBufferWrapper(Unpooled.buffer(Packet.INITIAL_PACKET_SIZE)));

8
artemis-core-client/src/test/java/org/apache/activemq/artemis/core/remoting/impl/netty/SharedEventLoopGroupTest.java
View File

@ -16,16 +16,16 @@
*/
package org.apache.activemq.artemis.core.remoting.impl.netty;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicReference;
import io.netty.channel.EventLoop;
import io.netty.channel.nio.NioEventLoopGroup;
import org.junit.Test;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.Test;
public class SharedEventLoopGroupTest {
@Test

9
artemis-core-client/src/test/java/org/apache/activemq/artemis/core/remoting/impl/netty/TransportConstantTest.java
View File

@ -17,8 +17,9 @@
package org.apache.activemq.artemis.core.remoting.impl.netty;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class TransportConstantTest {
@ -26,7 +27,7 @@ public class TransportConstantTest {
* This is just validating the pom still works */
@Test
public void testDefaultOnPom() {
Assert.assertEquals("It is expected to have the default at 0 on the testsuite", 0, TransportConstants.DEFAULT_QUIET_PERIOD);
Assert.assertEquals("It is expected to have the default at 0 on the testsuite", 0, TransportConstants.DEFAULT_SHUTDOWN_TIMEOUT);
assertEquals(0, TransportConstants.DEFAULT_QUIET_PERIOD, "It is expected to have the default at 0 on the testsuite");
assertEquals(0, TransportConstants.DEFAULT_SHUTDOWN_TIMEOUT, "It is expected to have the default at 0 on the testsuite");
}
}

19
artemis-core-client/src/test/java/org/apache/activemq/artemis/message/CoreMTMessageTest.java
View File

@ -16,6 +16,10 @@
*/
package org.apache.activemq.artemis.message;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
@ -30,8 +34,7 @@ import org.apache.activemq.artemis.core.persistence.CoreMessageObjectPools;
import org.apache.activemq.artemis.reader.TextMessageUtil;
import org.apache.activemq.artemis.utils.UUID;
import org.apache.activemq.artemis.utils.UUIDGenerator;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class CoreMTMessageTest {
@ -86,14 +89,14 @@ public class CoreMTMessageTest {
try {
ActiveMQBuffer buffer = ActiveMQBuffers.dynamicBuffer(10 * 1024);
aligned.countDown();
Assert.assertTrue(startFlag.await(5, TimeUnit.SECONDS));
assertTrue(startFlag.await(5, TimeUnit.SECONDS));
coreMessage.messageChanged();
coreMessage.sendBuffer(buffer.byteBuf(), 0);
CoreMessage recMessage = new CoreMessage();
recMessage.receiveBuffer(buffer.byteBuf());
Assert.assertEquals(ADDRESS2, recMessage.getAddressSimpleString());
Assert.assertEquals(33, recMessage.getMessageID());
Assert.assertEquals(propValue, recMessage.getSimpleStringProperty(SimpleString.toSimpleString("str-prop")));
assertEquals(ADDRESS2, recMessage.getAddressSimpleString());
assertEquals(33, recMessage.getMessageID());
assertEquals(propValue, recMessage.getSimpleStringProperty(SimpleString.toSimpleString("str-prop")));
} catch (Throwable e) {
e.printStackTrace();
errors.incrementAndGet();
@ -113,10 +116,10 @@ public class CoreMTMessageTest {
for (Thread t : threads) {
t.join(10000);
Assert.assertFalse(t.isAlive());
assertFalse(t.isAlive());
}
Assert.assertEquals(0, errors.get());
assertEquals(0, errors.get());
}

99
artemis-core-client/src/test/java/org/apache/activemq/artemis/message/CoreMessageTest.java
View File

@ -16,6 +16,12 @@
*/
package org.apache.activemq.artemis.message;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import java.nio.charset.StandardCharsets;
import java.util.LinkedList;
@ -32,10 +38,9 @@ import org.apache.activemq.artemis.core.protocol.core.impl.wireformat.SessionSen
import org.apache.activemq.artemis.reader.TextMessageUtil;
import org.apache.activemq.artemis.utils.Base64;
import org.apache.activemq.artemis.utils.UUID;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
public class CoreMessageTest {
@ -65,11 +70,11 @@ public class CoreMessageTest {
private ByteBuf BYTE_ENCODE;
@Before
@BeforeEach
public void before() {
BYTE_ENCODE = Unpooled.wrappedBuffer(Base64.decode(STRING_ENCODE, Base64.DONT_BREAK_LINES | Base64.URL_SAFE));
// some extra caution here, nothing else, to make sure we would get the same encoding back
Assert.assertEquals(STRING_ENCODE, encodeString(BYTE_ENCODE.array()));
assertEquals(STRING_ENCODE, encodeString(BYTE_ENCODE.array()));
BYTE_ENCODE.readerIndex(0).writerIndex(BYTE_ENCODE.capacity());
}
@ -78,7 +83,7 @@ public class CoreMessageTest {
public void testPassThrough() {
CoreMessage decodedMessage = decodeMessage();
Assert.assertEquals(TEXT, TextMessageUtil.readBodyText(decodedMessage.getReadOnlyBodyBuffer()).toString());
assertEquals(TEXT, TextMessageUtil.readBodyText(decodedMessage.getReadOnlyBodyBuffer()).toString());
}
@Test
@ -86,7 +91,7 @@ public class CoreMessageTest {
final CoreMessage decodedMessage = decodeMessage();
final int bodyBufferSize = decodedMessage.getBodyBufferSize();
final int readonlyBodyBufferReadableBytes = decodedMessage.getReadOnlyBodyBuffer().readableBytes();
Assert.assertEquals(bodyBufferSize, readonlyBodyBufferReadableBytes);
assertEquals(bodyBufferSize, readonlyBodyBufferReadableBytes);
}
/** The message is received, then sent to the other side untouched */
@ -95,7 +100,7 @@ public class CoreMessageTest {
CoreMessage decodedMessage = decodeMessage();
int encodeSize = decodedMessage.getEncodeSize();
Assert.assertEquals(BYTE_ENCODE.capacity(), encodeSize);
assertEquals(BYTE_ENCODE.capacity(), encodeSize);
SessionSendMessage sendMessage = new SessionSendMessage(decodedMessage, true, null);
sendMessage.setChannelID(777);
@ -111,11 +116,11 @@ public class CoreMessageTest {
sendMessageReceivedSent.decode(buffer);
Assert.assertEquals(encodeSize, sendMessageReceivedSent.getMessage().getEncodeSize());
assertEquals(encodeSize, sendMessageReceivedSent.getMessage().getEncodeSize());
Assert.assertTrue(sendMessageReceivedSent.isRequiresResponse());
assertTrue(sendMessageReceivedSent.isRequiresResponse());
Assert.assertEquals(TEXT, TextMessageUtil.readBodyText(sendMessageReceivedSent.getMessage().getReadOnlyBodyBuffer()).toString());
assertEquals(TEXT, TextMessageUtil.readBodyText(sendMessageReceivedSent.getMessage().getReadOnlyBodyBuffer()).toString());
}
/** The message is received, then sent to the other side untouched */
@ -124,7 +129,7 @@ public class CoreMessageTest {
CoreMessage decodedMessage = decodeMessage();
int encodeSize = decodedMessage.getEncodeSize();
Assert.assertEquals(BYTE_ENCODE.capacity(), encodeSize);
assertEquals(BYTE_ENCODE.capacity(), encodeSize);
SessionReceiveMessage sendMessage = new SessionReceiveMessage(33, decodedMessage, 7);
sendMessage.setChannelID(777);
@ -137,13 +142,13 @@ public class CoreMessageTest {
sendMessageReceivedSent.decode(buffer);
Assert.assertEquals(33, sendMessageReceivedSent.getConsumerID());
assertEquals(33, sendMessageReceivedSent.getConsumerID());
Assert.assertEquals(7, sendMessageReceivedSent.getDeliveryCount());
assertEquals(7, sendMessageReceivedSent.getDeliveryCount());
Assert.assertEquals(encodeSize, sendMessageReceivedSent.getMessage().getEncodeSize());
assertEquals(encodeSize, sendMessageReceivedSent.getMessage().getEncodeSize());
Assert.assertEquals(TEXT, TextMessageUtil.readBodyText(sendMessageReceivedSent.getMessage().getReadOnlyBodyBuffer()).toString());
assertEquals(TEXT, TextMessageUtil.readBodyText(sendMessageReceivedSent.getMessage().getReadOnlyBodyBuffer()).toString());
}
private CoreMessage decodeMessage() {
@ -155,11 +160,11 @@ public class CoreMessageTest {
int encodeSize = coreMessage.getEncodeSize();
Assert.assertEquals(newBuffer.capacity(), encodeSize);
assertEquals(newBuffer.capacity(), encodeSize);
Assert.assertEquals(ADDRESS, coreMessage.getAddressSimpleString());
assertEquals(ADDRESS, coreMessage.getAddressSimpleString());
Assert.assertEquals(PROP1_VALUE.toString(), coreMessage.getStringProperty(PROP1_NAME));
assertEquals(PROP1_VALUE.toString(), coreMessage.getStringProperty(PROP1_NAME));
ByteBuf destinedBuffer = Unpooled.buffer(BYTE_ENCODE.array().length);
coreMessage.sendBuffer(destinedBuffer, 0);
@ -169,9 +174,9 @@ public class CoreMessageTest {
CoreMessage newDecoded = internalDecode(Unpooled.wrappedBuffer(destinedArray));
Assert.assertEquals(encodeSize, newDecoded.getEncodeSize());
assertEquals(encodeSize, newDecoded.getEncodeSize());
Assert.assertArrayEquals(sourceArray, destinedArray);
assertArrayEquals(sourceArray, destinedArray);
return coreMessage;
}
@ -205,7 +210,7 @@ public class CoreMessageTest {
try {
empty2.getBodyBuffer().readLong();
Assert.fail("should throw exception");
fail("should throw exception");
} catch (Exception expected) {
}
@ -218,23 +223,23 @@ public class CoreMessageTest {
coreMessage.putStringProperty("prop", BIGGER_TEXT);
coreMessage.putBytesProperty("bytesProp", BIGGER_TEXT.getBytes(StandardCharsets.UTF_8));
Assert.assertEquals(BIGGER_TEXT.length(), ((String)coreMessage.toMap().get("prop")).length());
Assert.assertEquals(BIGGER_TEXT.getBytes(StandardCharsets.UTF_8).length, ((byte[])coreMessage.toMap().get("bytesProp")).length);
assertEquals(BIGGER_TEXT.length(), ((String)coreMessage.toMap().get("prop")).length());
assertEquals(BIGGER_TEXT.getBytes(StandardCharsets.UTF_8).length, ((byte[])coreMessage.toMap().get("bytesProp")).length);
// limit the values
Assert.assertNotEquals(BIGGER_TEXT.getBytes(StandardCharsets.UTF_8).length, ((byte[])coreMessage.toMap(40).get("bytesProp")).length);
assertNotEquals(BIGGER_TEXT.getBytes(StandardCharsets.UTF_8).length, ((byte[])coreMessage.toMap(40).get("bytesProp")).length);
String mapVal = ((String)coreMessage.toMap(40).get("prop"));
Assert.assertNotEquals(BIGGER_TEXT.length(), mapVal.length());
Assert.assertTrue(mapVal.contains("more"));
assertNotEquals(BIGGER_TEXT.length(), mapVal.length());
assertTrue(mapVal.contains("more"));
mapVal = ((String)coreMessage.toMap(0).get("prop"));
Assert.assertNotEquals(BIGGER_TEXT.length(), mapVal.length());
Assert.assertTrue(mapVal.contains("more"));
assertNotEquals(BIGGER_TEXT.length(), mapVal.length());
assertTrue(mapVal.contains("more"));
Assert.assertEquals(BIGGER_TEXT.length(), Integer.parseInt(mapVal.substring(mapVal.lastIndexOf('+') + 1, mapVal.lastIndexOf('m')).trim()));
assertEquals(BIGGER_TEXT.length(), Integer.parseInt(mapVal.substring(mapVal.lastIndexOf('+') + 1, mapVal.lastIndexOf('m')).trim()));
Assert.assertEquals(BIGGER_TEXT.getBytes(StandardCharsets.UTF_8).length, ((byte[])coreMessage.toPropertyMap().get("bytesProp")).length);
Assert.assertNotEquals(BIGGER_TEXT.getBytes(StandardCharsets.UTF_8).length, ((byte[])coreMessage.toPropertyMap(40).get("bytesProp")).length);
assertEquals(BIGGER_TEXT.getBytes(StandardCharsets.UTF_8).length, ((byte[])coreMessage.toPropertyMap().get("bytesProp")).length);
assertNotEquals(BIGGER_TEXT.getBytes(StandardCharsets.UTF_8).length, ((byte[])coreMessage.toPropertyMap(40).get("bytesProp")).length);
}
@Test
@ -248,11 +253,11 @@ public class CoreMessageTest {
CoreMessage empty2 = new CoreMessage();
empty2.receiveBuffer(buffer);
Assert.assertEquals((byte)7, empty2.getBodyBuffer().readByte());
assertEquals((byte)7, empty2.getBodyBuffer().readByte());
try {
empty2.getBodyBuffer().readByte();
Assert.fail("should throw exception");
fail("should throw exception");
} catch (Exception expected) {
}
@ -284,7 +289,7 @@ public class CoreMessageTest {
SimpleString newText = TextMessageUtil.readBodyText(newCoreMessage.getReadOnlyBodyBuffer());
Assert.assertEquals(newString, newText.toString());
assertEquals(newString, newText.toString());
// coreMessage.putStringProperty()
}
@ -301,8 +306,8 @@ public class CoreMessageTest {
threads[i] = new Thread(() -> {
try {
for (int j = 0; j < 50; j++) {
Assert.assertEquals(ADDRESS, coreMessage.getAddressSimpleString());
Assert.assertEquals(PROP1_VALUE.toString(), coreMessage.getStringProperty(PROP1_NAME));
assertEquals(ADDRESS, coreMessage.getAddressSimpleString());
assertEquals(PROP1_VALUE.toString(), coreMessage.getStringProperty(PROP1_NAME));
ByteBuf destinedBuffer = Unpooled.buffer(BYTE_ENCODE.array().length);
coreMessage.sendBuffer(destinedBuffer, 0);
@ -310,9 +315,9 @@ public class CoreMessageTest {
byte[] destinedArray = destinedBuffer.array();
byte[] sourceArray = BYTE_ENCODE.array();
Assert.assertArrayEquals(sourceArray, destinedArray);
assertArrayEquals(sourceArray, destinedArray);
Assert.assertEquals(TEXT, TextMessageUtil.readBodyText(coreMessage.getReadOnlyBodyBuffer()).toString());
assertEquals(TEXT, TextMessageUtil.readBodyText(coreMessage.getReadOnlyBodyBuffer()).toString());
}
} catch (Throwable e) {
e.printStackTrace();
@ -340,15 +345,15 @@ public class CoreMessageTest {
public void compareOriginal() throws Exception {
String generated = generate(TEXT);
Assert.assertEquals(STRING_ENCODE, generated);
assertEquals(STRING_ENCODE, generated);
for (int i = 0; i < generated.length(); i++) {
Assert.assertEquals("Chart at " + i + " was " + generated.charAt(i) + " instead of " + STRING_ENCODE.charAt(i), generated.charAt(i), STRING_ENCODE.charAt(i));
assertEquals(generated.charAt(i), STRING_ENCODE.charAt(i), "Chart at " + i + " was " + generated.charAt(i) + " instead of " + STRING_ENCODE.charAt(i));
}
}
/** Use this method to update the encode for the known message */
@Ignore
@Disabled
@Test
public void generate() throws Exception {
@ -368,8 +373,8 @@ public class CoreMessageTest {
copy.putBytesProperty(Message.HDR_ROUTE_TO_IDS, new byte[Long.BYTES]);
final int increasedMemoryFootprint = copy.getMemoryEstimate() - memoryEstimate;
final int increasedPropertyFootprint = copy.getProperties().getMemoryOffset() - msg.getProperties().getMemoryOffset();
Assert.assertTrue("memory estimation isn't accounting for the additional encoded property",
increasedMemoryFootprint > increasedPropertyFootprint);
assertTrue(increasedMemoryFootprint > increasedPropertyFootprint,
"memory estimation isn't accounting for the additional encoded property");
}
@Test
@ -378,12 +383,12 @@ public class CoreMessageTest {
msg.setAddress("a");
msg.putBytesProperty("_", new byte[4096]);
final CoreMessage copy = (CoreMessage) msg.copy(2);
Assert.assertEquals(msg.getEncodeSize(), copy.getBuffer().capacity());
assertEquals(msg.getEncodeSize(), copy.getBuffer().capacity());
copy.setAddress("b");
copy.setBrokerProperty(Message.HDR_ORIGINAL_QUEUE, "a");
copy.setBrokerProperty(Message.HDR_ORIGINAL_ADDRESS, msg.getAddressSimpleString());
copy.setBrokerProperty(Message.HDR_ORIG_MESSAGE_ID, msg.getMessageID());
Assert.assertEquals(copy.getEncodeSize(), copy.getBuffer().capacity());
assertEquals(copy.getEncodeSize(), copy.getBuffer().capacity());
}
private void printVariable(String body, String encode) {

4
artemis-core-client/src/test/java/org/apache/activemq/artemis/spi/core/remoting/ssl/OpenSSLContextFactoryProviderTest.java
View File

@ -16,9 +16,9 @@
*/
package org.apache.activemq.artemis.spi.core.remoting.ssl;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class OpenSSLContextFactoryProviderTest {

41
artemis-core-client/src/test/java/org/apache/activemq/artemis/tests/uri/ConnectorTransportConfigurationParserURITest.java
View File

@ -16,16 +16,17 @@
*/
package org.apache.activemq.artemis.tests.uri;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.lang.invoke.MethodHandles;
import java.net.URI;
import java.util.List;
import org.apache.activemq.artemis.api.core.TransportConfiguration;
import org.apache.activemq.artemis.uri.ConnectorTransportConfigurationParser;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;
import org.junit.Assert;
import org.junit.Test;
public class ConnectorTransportConfigurationParserURITest {
@ -42,13 +43,13 @@ public class ConnectorTransportConfigurationParserURITest {
objects.forEach(t -> logger.info("transportConfig: {}", t));
}
Assert.assertEquals(3, objects.size());
Assert.assertEquals("live", objects.get(0).getParams().get("host"));
Assert.assertEquals("1", objects.get(0).getParams().get("port"));
Assert.assertEquals("backupA", objects.get(1).getParams().get("host"));
Assert.assertEquals("2", objects.get(1).getParams().get("port"));
Assert.assertEquals("backupB", objects.get(2).getParams().get("host"));
Assert.assertEquals("3", objects.get(2).getParams().get("port"));
assertEquals(3, objects.size());
assertEquals("live", objects.get(0).getParams().get("host"));
assertEquals("1", objects.get(0).getParams().get("port"));
assertEquals("backupA", objects.get(1).getParams().get("host"));
assertEquals("2", objects.get(1).getParams().get("port"));
assertEquals("backupB", objects.get(2).getParams().get("host"));
assertEquals("3", objects.get(2).getParams().get("port"));
}
@Test
@ -62,15 +63,15 @@ public class ConnectorTransportConfigurationParserURITest {
objects.forEach(t -> logger.info("transportConfig: {}", t));
}
Assert.assertEquals(3, objects.size());
Assert.assertEquals("live1", objects.get(0).getName());
Assert.assertEquals("live", objects.get(0).getParams().get("host"));
Assert.assertEquals("1", objects.get(0).getParams().get("port"));
Assert.assertEquals("backupA2", objects.get(1).getName());
Assert.assertEquals("backupA", objects.get(1).getParams().get("host"));
Assert.assertEquals("2", objects.get(1).getParams().get("port"));
Assert.assertEquals("backupB3", objects.get(2).getName());
Assert.assertEquals("backupB", objects.get(2).getParams().get("host"));
Assert.assertEquals("3", objects.get(2).getParams().get("port"));
assertEquals(3, objects.size());
assertEquals("live1", objects.get(0).getName());
assertEquals("live", objects.get(0).getParams().get("host"));
assertEquals("1", objects.get(0).getParams().get("port"));
assertEquals("backupA2", objects.get(1).getName());
assertEquals("backupA", objects.get(1).getParams().get("host"));
assertEquals("2", objects.get(1).getParams().get("port"));
assertEquals("backupB3", objects.get(2).getName());
assertEquals("backupB", objects.get(2).getParams().get("host"));
assertEquals("3", objects.get(2).getParams().get("port"));
}
}

9
artemis-core-client/src/test/java/org/apache/activemq/artemis/util/BufferHelperTest.java
View File

@ -16,11 +16,12 @@
*/
package org.apache.activemq.artemis.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.apache.activemq.artemis.api.core.ActiveMQBuffer;
import org.apache.activemq.artemis.api.core.ActiveMQBuffers;
import org.apache.activemq.artemis.utils.BufferHelper;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class BufferHelperTest {
@Test
@ -33,9 +34,9 @@ public class BufferHelperTest {
buffer.writeNullableString(s);
int size = BufferHelper.sizeOfNullableString(s);
int written = buffer.writerIndex();
Assert.assertEquals(written, size);
assertEquals(written, size);
String readString = buffer.readNullableString();
Assert.assertEquals(s, readString);
assertEquals(s, readString);
}
}
}

7
artemis-core-client/src/test/java/org/apache/activemq/artemis/util/CompressionUtilTest.java
View File

@ -16,6 +16,8 @@
*/
package org.apache.activemq.artemis.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
@ -26,10 +28,9 @@ import java.util.zip.Deflater;
import org.apache.activemq.artemis.utils.DeflaterReader;
import org.apache.activemq.artemis.utils.InflaterReader;
import org.apache.activemq.artemis.utils.InflaterWriter;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class CompressionUtilTest extends Assert {
public class CompressionUtilTest {
@Test
public void testDeflaterReader() throws Exception {

9
artemis-core-client/src/test/java/org/apache/activemq/artemis/util/ConfigurationHelperTest.java
View File

@ -16,12 +16,13 @@
*/
package org.apache.activemq.artemis.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.HashMap;
import java.util.Map;
import org.apache.activemq.artemis.utils.ConfigurationHelper;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class ConfigurationHelperTest {
@ -29,13 +30,13 @@ public class ConfigurationHelperTest {
public void testDefaultInt() {
Map<String, Object> values = new HashMap<>();
values.put("test", "zzz");
Assert.assertEquals(3, ConfigurationHelper.getIntProperty("test", 3, values));
assertEquals(3, ConfigurationHelper.getIntProperty("test", 3, values));
}
@Test
public void testDefaultLong() {
Map<String, Object> values = new HashMap<>();
values.put("test", "zzz");
Assert.assertEquals(3L, ConfigurationHelper.getLongProperty("test", 3L, values));
assertEquals(3L, ConfigurationHelper.getLongProperty("test", 3L, values));
}
}

7
artemis-core-client/src/test/java/org/apache/activemq/artemis/util/StringUtilTest.java
View File

@ -16,14 +16,15 @@
*/
package org.apache.activemq.artemis.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.ArrayList;
import java.util.List;
import org.apache.activemq.artemis.utils.StringUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class StringUtilTest extends Assert {
public class StringUtilTest {
@Test
public void testJoinStringList() throws Exception {

35
artemis-core-client/src/test/java/org/apache/activemq/artemis/util/TimeAndCounterIDGeneratorTest.java
View File

@ -16,15 +16,18 @@
*/
package org.apache.activemq.artemis.util;
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.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.apache.activemq.artemis.utils.TimeAndCounterIDGenerator;
import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class TimeAndCounterIDGeneratorTest extends Assert {
public class TimeAndCounterIDGeneratorTest {
@Test
public void testCalculation() {
@ -36,7 +39,7 @@ public class TimeAndCounterIDGeneratorTest extends Assert {
for (long i = 0; i < max; i++) {
long seqNr = seq.generateID();
Assert.assertTrue("The sequence generator should aways generate crescent numbers", seqNr > lastNr);
assertTrue(seqNr > lastNr, "The sequence generator should aways generate crescent numbers");
lastNr = seqNr;
}
@ -48,16 +51,16 @@ public class TimeAndCounterIDGeneratorTest extends Assert {
TimeAndCounterIDGenerator seq = new TimeAndCounterIDGenerator();
long id1 = seq.generateID();
Assert.assertEquals(1, id1 & 0xffff);
Assert.assertEquals(2, seq.generateID() & 0xffff);
assertEquals(1, id1 & 0xffff);
assertEquals(2, seq.generateID() & 0xffff);
seq.refresh();
long id2 = seq.generateID();
Assert.assertTrue(id2 > id1);
assertTrue(id2 > id1);
Assert.assertEquals(1, id2 & 0xffff);
assertEquals(1, id2 & 0xffff);
}
@ -83,15 +86,15 @@ public class TimeAndCounterIDGeneratorTest extends Assert {
public void run() {
try {
latchAlign.countDown();
assertTrue("Latch has got to return within a minute", latchStart.await(1, TimeUnit.MINUTES));
assertTrue(latchStart.await(1, TimeUnit.MINUTES), "Latch has got to return within a minute");
long lastValue = 0L;
for (int i = 0; i < NUMBER_OF_IDS; i++) {
long value = seq.generateID();
Assert.assertTrue(TimeAndCounterIDGeneratorTest.hex(value) + " should be greater than " +
assertTrue(value > lastValue, TimeAndCounterIDGeneratorTest.hex(value) + " should be greater than " +
TimeAndCounterIDGeneratorTest.hex(lastValue) +
" on seq " +
seq.toString(), value > lastValue);
seq.toString());
lastValue = value;
hashSet.add(value);
@ -110,7 +113,7 @@ public class TimeAndCounterIDGeneratorTest extends Assert {
arrays[i].start();
}
assertTrue("Latch has got to return within a minute", latchAlign.await(1, TimeUnit.MINUTES));
assertTrue(latchAlign.await(1, TimeUnit.MINUTES), "Latch has got to return within a minute");
latchStart.countDown();
@ -121,7 +124,7 @@ public class TimeAndCounterIDGeneratorTest extends Assert {
}
}
Assert.assertEquals(NUMBER_OF_THREADS * NUMBER_OF_IDS, hashSet.size());
assertEquals(NUMBER_OF_THREADS * NUMBER_OF_IDS, hashSet.size());
hashSet.clear();
@ -138,7 +141,7 @@ public class TimeAndCounterIDGeneratorTest extends Assert {
try {
// This is simulating a situation where we generated more than 268 million messages on the same time interval
seq.generateID();
Assert.fail("It was supposed to throw an exception, as the counter was set to explode on this test");
fail("It was supposed to throw an exception, as the counter was set to explode on this test");
} catch (Exception e) {
}
@ -153,8 +156,8 @@ public class TimeAndCounterIDGeneratorTest extends Assert {
// This is ok... the time portion would be added to the next one generated 10 seconds ago
seq.generateID();
Assert.assertTrue(TimeAndCounterIDGeneratorTest.hex(timeMark) + " < " +
TimeAndCounterIDGeneratorTest.hex(seq.getInternalTimeMark()), timeMark < seq.getInternalTimeMark());
assertTrue(timeMark < seq.getInternalTimeMark(), TimeAndCounterIDGeneratorTest.hex(timeMark) + " < " +
TimeAndCounterIDGeneratorTest.hex(seq.getInternalTimeMark()));
}
private static String hex(final long value) {

31
artemis-core-client/src/test/java/org/apache/activemq/artemis/util/XMLUtilTest.java
View File

@ -16,10 +16,13 @@
*/
package org.apache.activemq.artemis.util;
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 org.apache.activemq.artemis.utils.SilentTestCase;
import org.apache.activemq.artemis.utils.XMLUtil;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
@ -33,7 +36,7 @@ public class XMLUtilTest extends SilentTestCase {
Element e = XMLUtil.stringToElement(document);
Assert.assertEquals("foo", XMLUtil.getTextContent(e));
assertEquals("foo", XMLUtil.getTextContent(e));
}
@Test
@ -42,7 +45,7 @@ public class XMLUtilTest extends SilentTestCase {
Element e = XMLUtil.stringToElement(document);
Assert.assertEquals("foo", XMLUtil.getTextContent(e));
assertEquals("foo", XMLUtil.getTextContent(e));
}
@Test
@ -55,7 +58,7 @@ public class XMLUtilTest extends SilentTestCase {
Element subelement = XMLUtil.stringToElement(s);
Assert.assertEquals("a", subelement.getNodeName());
assertEquals("a", subelement.getNodeName());
}
@Test
@ -68,7 +71,7 @@ public class XMLUtilTest extends SilentTestCase {
Element subelement = XMLUtil.stringToElement(s);
Assert.assertEquals("a", subelement.getNodeName());
assertEquals("a", subelement.getNodeName());
}
@Test
@ -81,7 +84,7 @@ public class XMLUtilTest extends SilentTestCase {
Element subelement = XMLUtil.stringToElement(s);
Assert.assertEquals("a", subelement.getNodeName());
assertEquals("a", subelement.getNodeName());
NodeList nl = subelement.getChildNodes();
// try to find <b>
@ -92,7 +95,7 @@ public class XMLUtilTest extends SilentTestCase {
found = true;
}
}
Assert.assertTrue(found);
assertTrue(found);
}
@Test
@ -118,7 +121,7 @@ public class XMLUtilTest extends SilentTestCase {
try {
XMLUtil.assertEquivalent(XMLUtil.stringToElement(s), XMLUtil.stringToElement(s2));
Assert.fail("this should throw exception");
fail("this should throw exception");
} catch (IllegalArgumentException e) {
// expected
}
@ -155,7 +158,7 @@ public class XMLUtilTest extends SilentTestCase {
try {
XMLUtil.assertEquivalent(XMLUtil.stringToElement(s), XMLUtil.stringToElement(s2));
Assert.fail("this should throw exception");
fail("this should throw exception");
} catch (IllegalArgumentException e) {
// OK
e.printStackTrace();
@ -213,7 +216,7 @@ public class XMLUtilTest extends SilentTestCase {
System.setProperty("sysprop1", "test1");
System.setProperty("sysprop2", "content4");
String replaced = XMLUtil.replaceSystemPropsInString(before);
Assert.assertEquals(after, replaced);
assertEquals(after, replaced);
}
@Test
@ -223,7 +226,7 @@ public class XMLUtilTest extends SilentTestCase {
System.setProperty("sysprop1", "test1");
System.setProperty("sysprop2", "content4");
String replaced = XMLUtil.replaceSystemPropsInString(before);
Assert.assertEquals(after, replaced);
assertEquals(after, replaced);
}
@Test
@ -233,7 +236,7 @@ public class XMLUtilTest extends SilentTestCase {
System.setProperty("sysprop1", "test1");
System.setProperty("sysprop2", "content4");
String replaced = XMLUtil.replaceSystemPropsInString(before);
Assert.assertEquals(after, replaced);
assertEquals(after, replaced);
}
@Test
@ -241,7 +244,7 @@ public class XMLUtilTest extends SilentTestCase {
String xml = "<![CDATA[somedata]]>";
String stripped = XMLUtil.stripCDATA(xml);
Assert.assertEquals("somedata", stripped);
assertEquals("somedata", stripped);
}
}

27
artemis-core-client/src/test/java/org/apache/activemq/artemis/util/XidCodecSupportTest.java
View File

@ -17,19 +17,20 @@
package org.apache.activemq.artemis.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.fail;
import org.apache.activemq.artemis.api.core.ActiveMQBuffer;
import org.apache.activemq.artemis.api.core.ActiveMQBuffers;
import org.apache.activemq.artemis.core.transaction.impl.XidImpl;
import org.apache.activemq.artemis.utils.UUIDGenerator;
import org.apache.activemq.artemis.utils.XidCodecSupport;
import org.apache.activemq.artemis.api.core.ActiveMQInvalidBufferException;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import javax.transaction.xa.Xid;
import static org.junit.Assert.fail;
public class XidCodecSupportTest {
private static final Xid VALID_XID =
@ -40,11 +41,11 @@ public class XidCodecSupportTest {
final ActiveMQBuffer buffer = ActiveMQBuffers.dynamicBuffer(0);
XidCodecSupport.encodeXid(VALID_XID, buffer);
Assert.assertEquals(51, buffer.readableBytes()); // formatId(4) + branchQualLength(4) + branchQual(3) +
assertEquals(51, buffer.readableBytes()); // formatId(4) + branchQualLength(4) + branchQual(3) +
// globalTxIdLength(4) + globalTx(36)
final Xid readXid = XidCodecSupport.decodeXid(buffer);
Assert.assertEquals(VALID_XID, readXid);
assertEquals(VALID_XID, readXid);
}
@Test
@ -63,13 +64,15 @@ public class XidCodecSupportTest {
fail("should have thrown exception");
}
@Test(expected = ActiveMQInvalidBufferException.class)
@Test
public void testOverflowLength() {
final ActiveMQBuffer buffer = ActiveMQBuffers.dynamicBuffer(0);
XidCodecSupport.encodeXid(VALID_XID, buffer);
// Alter globalTxIdLength to be too big
buffer.setByte(11, (byte) 0x0C);
assertThrows(ActiveMQInvalidBufferException.class, () -> {
final ActiveMQBuffer buffer = ActiveMQBuffers.dynamicBuffer(0);
XidCodecSupport.encodeXid(VALID_XID, buffer);
// Alter globalTxIdLength to be too big
buffer.setByte(11, (byte) 0x0C);
XidCodecSupport.decodeXid(buffer);
XidCodecSupport.decodeXid(buffer);
});
}
}

9
artemis-dto/pom.xml
View File

@ -61,8 +61,13 @@
<version>${jakarta.activation-api.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>

42
artemis-dto/src/test/java/org/apache/activemq/artemis/dto/test/BindingDTOTest.java
View File

@ -16,20 +16,22 @@
*/
package org.apache.activemq.artemis.dto.test;
import org.apache.activemq.artemis.dto.BindingDTO;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
public class BindingDTOTest extends Assert {
import org.apache.activemq.artemis.dto.BindingDTO;
import org.junit.jupiter.api.Test;
public class BindingDTOTest {
@Test
public void testDefault() {
BindingDTO binding = new BindingDTO();
Assert.assertNull(binding.getIncludedTLSProtocols());
Assert.assertNull(binding.getExcludedTLSProtocols());
Assert.assertNull(binding.getIncludedCipherSuites());
Assert.assertNull(binding.getExcludedCipherSuites());
assertNull(binding.getIncludedTLSProtocols());
assertNull(binding.getExcludedTLSProtocols());
assertNull(binding.getIncludedCipherSuites());
assertNull(binding.getExcludedCipherSuites());
}
@Test
@ -37,16 +39,16 @@ public class BindingDTOTest extends Assert {
BindingDTO binding = new BindingDTO();
binding.setIncludedTLSProtocols("TLSv1.2");
Assert.assertArrayEquals(new String[] {"TLSv1.2"}, binding.getIncludedTLSProtocols());
assertArrayEquals(new String[] {"TLSv1.2"}, binding.getIncludedTLSProtocols());
binding.setExcludedTLSProtocols("TLSv1,TLSv1.1");
Assert.assertArrayEquals(new String[] {"TLSv1", "TLSv1.1"}, binding.getExcludedTLSProtocols());
assertArrayEquals(new String[] {"TLSv1", "TLSv1.1"}, binding.getExcludedTLSProtocols());
binding.setIncludedCipherSuites( "^SSL_.*$");
Assert.assertArrayEquals(new String[] {"^SSL_.*$"}, binding.getIncludedCipherSuites());
assertArrayEquals(new String[] {"^SSL_.*$"}, binding.getIncludedCipherSuites());
binding.setExcludedCipherSuites( "^.*_(MD5|SHA|SHA1)$,^TLS_RSA_.*$,^.*_NULL_.*$,^.*_anon_.*$");
Assert.assertArrayEquals(new String[] {"^.*_(MD5|SHA|SHA1)$", "^TLS_RSA_.*$", "^.*_NULL_.*$", "^.*_anon_.*$"}, binding.getExcludedCipherSuites());
assertArrayEquals(new String[] {"^.*_(MD5|SHA|SHA1)$", "^TLS_RSA_.*$", "^.*_NULL_.*$", "^.*_anon_.*$"}, binding.getExcludedCipherSuites());
}
@Test
@ -54,16 +56,16 @@ public class BindingDTOTest extends Assert {
BindingDTO binding = new BindingDTO();
binding.setIncludedTLSProtocols("");
Assert.assertArrayEquals(new String[] {""}, binding.getIncludedTLSProtocols());
assertArrayEquals(new String[] {""}, binding.getIncludedTLSProtocols());
binding.setExcludedTLSProtocols("");
Assert.assertArrayEquals(new String[] {""}, binding.getExcludedTLSProtocols());
assertArrayEquals(new String[] {""}, binding.getExcludedTLSProtocols());
binding.setIncludedCipherSuites("");
Assert.assertArrayEquals(new String[] {""}, binding.getIncludedCipherSuites());
assertArrayEquals(new String[] {""}, binding.getIncludedCipherSuites());
binding.setExcludedCipherSuites("");
Assert.assertArrayEquals(new String[] {""}, binding.getExcludedCipherSuites());
assertArrayEquals(new String[] {""}, binding.getExcludedCipherSuites());
}
@Test
@ -71,15 +73,15 @@ public class BindingDTOTest extends Assert {
BindingDTO binding = new BindingDTO();
binding.setIncludedTLSProtocols(null);
Assert.assertNull(binding.getIncludedTLSProtocols());
assertNull(binding.getIncludedTLSProtocols());
binding.setExcludedTLSProtocols(null);
Assert.assertNull(binding.getExcludedTLSProtocols());
assertNull(binding.getExcludedTLSProtocols());
binding.setIncludedCipherSuites(null);
Assert.assertNull(binding.getIncludedCipherSuites());
assertNull(binding.getIncludedCipherSuites());
binding.setExcludedCipherSuites(null);
Assert.assertNull(binding.getExcludedCipherSuites());
assertNull(binding.getExcludedCipherSuites());
}
}

79
artemis-dto/src/test/java/org/apache/activemq/artemis/dto/test/WebServerDTOTest.java
View File

@ -16,10 +16,13 @@
*/
package org.apache.activemq.artemis.dto.test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import org.apache.activemq.artemis.dto.BindingDTO;
import org.apache.activemq.artemis.dto.WebServerDTO;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.util.Collections;
import java.util.List;
@ -30,26 +33,26 @@ public class WebServerDTOTest {
public void testDefault() throws Exception {
WebServerDTO webServer = new WebServerDTO();
Assert.assertNotNull(webServer.getAllBindings());
Assert.assertEquals(1, webServer.getAllBindings().size());
Assert.assertNotNull(webServer.getDefaultBinding());
assertNotNull(webServer.getAllBindings());
assertEquals(1, webServer.getAllBindings().size());
assertNotNull(webServer.getDefaultBinding());
BindingDTO defaultBinding = webServer.getDefaultBinding();
Assert.assertNull(defaultBinding.uri);
Assert.assertNull(defaultBinding.apps);
Assert.assertNull(defaultBinding.clientAuth);
Assert.assertNull(defaultBinding.passwordCodec);
Assert.assertNull(defaultBinding.keyStorePath);
Assert.assertNull(defaultBinding.trustStorePath);
Assert.assertNull(defaultBinding.getIncludedTLSProtocols());
Assert.assertNull(defaultBinding.getExcludedTLSProtocols());
Assert.assertNull(defaultBinding.getIncludedCipherSuites());
Assert.assertNull(defaultBinding.getExcludedCipherSuites());
Assert.assertNull(defaultBinding.getKeyStorePassword());
Assert.assertNull(defaultBinding.getTrustStorePassword());
Assert.assertNull(defaultBinding.getSniHostCheck());
Assert.assertNull(defaultBinding.getSniRequired());
Assert.assertNull(defaultBinding.getSslAutoReload());
assertNull(defaultBinding.uri);
assertNull(defaultBinding.apps);
assertNull(defaultBinding.clientAuth);
assertNull(defaultBinding.passwordCodec);
assertNull(defaultBinding.keyStorePath);
assertNull(defaultBinding.trustStorePath);
assertNull(defaultBinding.getIncludedTLSProtocols());
assertNull(defaultBinding.getExcludedTLSProtocols());
assertNull(defaultBinding.getIncludedCipherSuites());
assertNull(defaultBinding.getExcludedCipherSuites());
assertNull(defaultBinding.getKeyStorePassword());
assertNull(defaultBinding.getTrustStorePassword());
assertNull(defaultBinding.getSniHostCheck());
assertNull(defaultBinding.getSniRequired());
assertNull(defaultBinding.getSslAutoReload());
}
@Test
@ -57,10 +60,10 @@ public class WebServerDTOTest {
WebServerDTO webServer = new WebServerDTO();
webServer.bind = "http://localhost:0";
Assert.assertNotNull(webServer.getAllBindings());
Assert.assertEquals(1, webServer.getAllBindings().size());
Assert.assertNotNull(webServer.getDefaultBinding());
Assert.assertEquals("http://localhost:0", webServer.getDefaultBinding().uri);
assertNotNull(webServer.getAllBindings());
assertEquals(1, webServer.getAllBindings().size());
assertNotNull(webServer.getDefaultBinding());
assertEquals("http://localhost:0", webServer.getDefaultBinding().uri);
}
@Test
@ -71,10 +74,10 @@ public class WebServerDTOTest {
WebServerDTO webServer = new WebServerDTO();
webServer.setBindings(Collections.singletonList(binding));
Assert.assertNotNull(webServer.getAllBindings());
Assert.assertEquals(1, webServer.getAllBindings().size());
Assert.assertNotNull(webServer.getDefaultBinding());
Assert.assertEquals("http://localhost:0", webServer.getDefaultBinding().uri);
assertNotNull(webServer.getAllBindings());
assertEquals(1, webServer.getAllBindings().size());
assertNotNull(webServer.getDefaultBinding());
assertEquals("http://localhost:0", webServer.getDefaultBinding().uri);
}
@Test
@ -87,12 +90,12 @@ public class WebServerDTOTest {
WebServerDTO webServer = new WebServerDTO();
webServer.setBindings(List.of(binding1, binding2));
Assert.assertNotNull(webServer.getAllBindings());
Assert.assertEquals(2, webServer.getAllBindings().size());
Assert.assertNotNull(webServer.getDefaultBinding());
Assert.assertEquals("http://localhost:0", webServer.getDefaultBinding().uri);
Assert.assertEquals("http://localhost:0", webServer.getAllBindings().get(0).uri);
Assert.assertEquals("http://localhost:1", webServer.getAllBindings().get(1).uri);
assertNotNull(webServer.getAllBindings());
assertEquals(2, webServer.getAllBindings().size());
assertNotNull(webServer.getDefaultBinding());
assertEquals("http://localhost:0", webServer.getDefaultBinding().uri);
assertEquals("http://localhost:0", webServer.getAllBindings().get(0).uri);
assertEquals("http://localhost:1", webServer.getAllBindings().get(1).uri);
}
@Test
@ -104,10 +107,10 @@ public class WebServerDTOTest {
webServer.bind = "http://localhost:1";
webServer.setBindings(Collections.singletonList(binding));
Assert.assertNotNull(webServer.getAllBindings());
Assert.assertEquals(1, webServer.getAllBindings().size());
Assert.assertNotNull(webServer.getDefaultBinding());
Assert.assertEquals("http://localhost:0", webServer.getDefaultBinding().uri);
assertNotNull(webServer.getAllBindings());
assertEquals(1, webServer.getAllBindings().size());
assertNotNull(webServer.getDefaultBinding());
assertEquals("http://localhost:0", webServer.getDefaultBinding().uri);
}
}

10
artemis-image/pom.xml
View File

@ -47,9 +47,13 @@
<type>pom</type>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<!-- The johnzon-core and json-api contents are repackaged in -commons,

2
artemis-image/src/test/java/org/apache/activemq/artemis/ActiveMQImageExamplesTest.java
View File

@ -25,7 +25,7 @@ import org.apache.activemq.artemis.core.config.impl.ConfigurationImpl;
import org.apache.activemq.artemis.core.server.ActiveMQServer;
import org.apache.activemq.artemis.core.server.embedded.EmbeddedActiveMQ;
import org.apache.activemq.artemis.core.server.embedded.Main;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

9
artemis-jakarta-client/pom.xml
View File

@ -73,8 +73,13 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

9
artemis-jakarta-ra/pom.xml
View File

@ -97,8 +97,13 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

9
artemis-jakarta-server/pom.xml
View File

@ -90,8 +90,13 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

9
artemis-jakarta-service-extensions/pom.xml
View File

@ -72,8 +72,13 @@
<scope>provided</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>

9
artemis-jdbc-store/pom.xml
View File

@ -80,8 +80,13 @@
<scope>provided</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<scope>test</scope>
</dependency>
<dependency>

83
artemis-jdbc-store/src/test/java/org/apache/activemq/artemis/jdbc/store/file/JDBCSequentialFileFactoryTest.java
View File

@ -16,6 +16,11 @@
*/
package org.apache.activemq.artemis.jdbc.store.file;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
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.nio.ByteBuffer;
import java.sql.DriverManager;
import java.sql.SQLException;
@ -44,27 +49,19 @@ import org.apache.activemq.artemis.jdbc.store.drivers.JDBCConnectionProvider;
import org.apache.activemq.artemis.jdbc.store.drivers.JDBCDataSourceUtils;
import org.apache.activemq.artemis.jdbc.store.drivers.JDBCUtils;
import org.apache.activemq.artemis.jdbc.store.sql.SQLProvider;
import org.apache.activemq.artemis.tests.extensions.parameterized.ParameterizedTestExtension;
import org.apache.activemq.artemis.tests.extensions.parameterized.Parameter;
import org.apache.activemq.artemis.tests.extensions.parameterized.Parameters;
import org.apache.activemq.artemis.tests.util.ArtemisTestCase;
import org.apache.activemq.artemis.utils.ActiveMQThreadFactory;
import org.apache.activemq.artemis.utils.ThreadLeakCheckRule;
import org.apache.derby.jdbc.EmbeddedDriver;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@RunWith(Parameterized.class)
public class JDBCSequentialFileFactoryTest {
@Rule
public ThreadLeakCheckRule leakCheckRule = new ThreadLeakCheckRule();
@ExtendWith(ParameterizedTestExtension.class)
public class JDBCSequentialFileFactoryTest extends ArtemisTestCase {
private static String className = EmbeddedDriver.class.getCanonicalName();
@ -74,17 +71,18 @@ public class JDBCSequentialFileFactoryTest {
private ScheduledExecutorService scheduledExecutorService;
@Parameterized.Parameter
@Parameter(index = 0)
public boolean useAuthentication;
private String user = null;
private String password = null;
@Parameterized.Parameters(name = "authentication = {0}")
@Parameters(name = "authentication = {0}")
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][]{{false}, {true}});
}
@Before
@BeforeEach
public void setup() throws Exception {
executor = Executors.newSingleThreadExecutor(ActiveMQThreadFactory.defaultThreadFactory(getClass().getName()));
scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(ActiveMQThreadFactory.defaultThreadFactory(getClass().getName()));
@ -109,15 +107,18 @@ public class JDBCSequentialFileFactoryTest {
factory.start();
}
@After
@AfterEach
public void tearDown() throws Exception {
executor.shutdown();
scheduledExecutorService.shutdown();
factory.destroy();
try {
executor.shutdown();
scheduledExecutorService.shutdown();
factory.destroy();
} finally {
shutdownDerby();
}
}
@After
public void shutdownDerby() {
private void shutdownDerby() {
try {
if (useAuthentication) {
DriverManager.getConnection("jdbc:derby:;shutdown=true", user, password);
@ -132,12 +133,12 @@ public class JDBCSequentialFileFactoryTest {
}
}
@Test
@TestTemplate
public void testJDBCFileFactoryStarted() throws Exception {
assertTrue(factory.isStarted());
}
@Test
@TestTemplate
public void testReadZeroBytesOnEmptyFile() throws Exception {
JDBCSequentialFile file = (JDBCSequentialFile) factory.createSequentialFile("test.txt");
file.open();
@ -150,7 +151,7 @@ public class JDBCSequentialFileFactoryTest {
}
}
@Test
@TestTemplate
public void testReadZeroBytesOnNotEmptyFile() throws Exception {
final int fileLength = 8;
JDBCSequentialFile file = (JDBCSequentialFile) factory.createSequentialFile("test.txt");
@ -166,7 +167,7 @@ public class JDBCSequentialFileFactoryTest {
}
}
@Test
@TestTemplate
public void testReadOutOfBoundsOnEmptyFile() throws Exception {
JDBCSequentialFile file = (JDBCSequentialFile) factory.createSequentialFile("test.txt");
file.open();
@ -174,13 +175,13 @@ public class JDBCSequentialFileFactoryTest {
final ByteBuffer readBuffer = ByteBuffer.allocate(1);
file.position(1);
final int bytes = file.read(readBuffer);
assertTrue("bytes read should be < 0", bytes < 0);
assertTrue(bytes < 0, "bytes read should be < 0");
} finally {
file.close();
}
}
@Test
@TestTemplate
public void testReadOutOfBoundsOnNotEmptyFile() throws Exception {
final int fileLength = 8;
JDBCSequentialFile file = (JDBCSequentialFile) factory.createSequentialFile("test.txt");
@ -191,13 +192,13 @@ public class JDBCSequentialFileFactoryTest {
file.position(fileLength + 1);
final ByteBuffer readBuffer = ByteBuffer.allocate(fileLength);
final int bytes = file.read(readBuffer);
assertTrue("bytes read should be < 0", bytes < 0);
assertTrue(bytes < 0, "bytes read should be < 0");
} finally {
file.close();
}
}
@Test
@TestTemplate
public void testCreateFiles() throws Exception {
int noFiles = 100;
List<SequentialFile> files = new LinkedList<>();
@ -219,10 +220,10 @@ public class JDBCSequentialFileFactoryTest {
file.close();
}
Assert.assertEquals(0, factory.getNumberOfOpenFiles());
assertEquals(0, factory.getNumberOfOpenFiles());
}
@Test
@TestTemplate
public void testAsyncAppendToFile() throws Exception {
JDBCSequentialFile file = (JDBCSequentialFile) factory.createSequentialFile("test.txt");
@ -242,7 +243,7 @@ public class JDBCSequentialFileFactoryTest {
checkData(file, src);
}
@Test
@TestTemplate
public void testWriteToFile() throws Exception {
JDBCSequentialFile file = (JDBCSequentialFile) factory.createSequentialFile("test.txt");
file.open();
@ -268,7 +269,7 @@ public class JDBCSequentialFileFactoryTest {
assertEquals(bufferSize, file.size());
}
@Test
@TestTemplate
public void testCopyFile() throws Exception {
JDBCSequentialFile file = (JDBCSequentialFile) factory.createSequentialFile("test.txt");
file.open();
@ -293,7 +294,7 @@ public class JDBCSequentialFileFactoryTest {
assertEquals(bufferSize, file.size());
}
@Test
@TestTemplate
public void testCloneFile() throws Exception {
JDBCSequentialFile file = (JDBCSequentialFile) factory.createSequentialFile("test.txt");
file.open();
@ -324,7 +325,7 @@ public class JDBCSequentialFileFactoryTest {
*
* @throws Exception
*/
@Test
@TestTemplate
public void testGetFileSizeWorksWhenNotOpen() throws Exception {
// Create test file with some data.
int testFileSize = 1024;

8
artemis-jdbc-store/src/test/java/org/apache/activemq/artemis/jdbc/store/file/PostgresLargeObjectManagerTest.java
View File

@ -16,6 +16,9 @@
*/
package org.apache.activemq.artemis.jdbc.store.file;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.net.URLClassLoader;
@ -37,9 +40,8 @@ import java.sql.Struct;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import org.junit.Test;
import org.junit.jupiter.api.Test;
public class PostgresLargeObjectManagerTest {

Some files were not shown because too many files have changed in this diff Show More