Skip to content

feat: Migrate cat.ddk.typesystem.test to Junit5 #1203

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
markdomeng merged 1 commit into from
Oct 28, 2025
Merged

feat: Migrate cat.ddk.typesystem.test to Junit5 #1203

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions com.avaloq.tools.ddk.typesystem.test/META-INF/MANIFEST.MF
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,9 +9,9 @@ Bundle-ActivationPolicy: lazy
Fragment-Host: com.avaloq.tools.ddk.typesystem
Require-Bundle: com.google.inject,
com.google.guava,
org.junit,
junit-jupiter-api,
junit-jupiter-engine,
junit-vintage-engine
junit-vintage-engine,
junit-platform-suite-api
Export-Package: com.avaloq.tools.ddk.typesystem.test
Automatic-Module-Name: com.avaloq.tools.ddk.typesystem.test
114 changes: 57 additions & 57 deletions ...ols.ddk.typesystem.test/src/com/avaloq/tools/ddk/typesystem/AbstractTypeProviderTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,9 +10,9 @@
*******************************************************************************/
package com.avaloq.tools.ddk.typesystem;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
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 java.util.Arrays;

Expand All @@ -23,8 +23,8 @@
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.impl.EObjectImpl;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import com.avaloq.tools.ddk.typesystem.typemodel.IExpression;
import com.avaloq.tools.ddk.typesystem.typemodel.INamedElement;
Expand All @@ -34,7 +34,7 @@


@SuppressWarnings("nls")
public class AbstractTypeProviderTest {
class AbstractTypeProviderTest {

protected class TypeImpl extends EObjectImpl implements IType {
}
Expand Down Expand Up @@ -70,8 +70,8 @@ private EClass createEClass(final String name, final EClass... superTypes) {
return clazz;
}

@Before
public void init() {
@BeforeEach
void init() {
EcoreFactory modelFactory = EcoreFactory.eINSTANCE;
testModelPackage = modelFactory.createEPackage();
testModelPackage.setName("TypeProviderTestEPackage");
Expand All @@ -93,82 +93,82 @@ public void init() {
}

private void testPlainProvider(final ITypeProvider plainProvider) {
assertEquals("type for expression1 not type1", type1, plainProvider.getType(expression1));
assertEquals("type for expression2 not type2", type2, plainProvider.getType(expression2));
assertNull("type for expression3 not null", plainProvider.getType(expression3));
assertNull("type for null not null", plainProvider.getType(null));
assertEquals("expected type for container1 not type1", type1, plainProvider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)));
assertEquals("expected type for container2 not type2", type2, plainProvider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)));
assertNull("expected type for container3 not null", plainProvider.getExpectedType((IExpression) expression3Container.eGet(expressionContainerReference)));
assertNull("expected type for null not null", plainProvider.getExpectedType(null));
assertEquals("type for namedElement1 not type1", type1, plainProvider.getTypeForNamedElement(namedElement1));
assertEquals("type for namedElement2 not type2", type2, plainProvider.getTypeForNamedElement(namedElement2));
assertNull("type for namedElement3 not null", plainProvider.getTypeForNamedElement(namedElement3));
assertNull("type for named element null not null", plainProvider.getTypeForNamedElement(null));
assertEquals(type1, plainProvider.getType(expression1), "type for expression1 not type1");
assertEquals(type2, plainProvider.getType(expression2), "type for expression2 not type2");
assertNull(plainProvider.getType(expression3), "type for expression3 not null");
assertNull(plainProvider.getType(null), "type for null not null");
assertEquals(type1, plainProvider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)), "expected type for container1 not type1");
assertEquals(type2, plainProvider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)), "expected type for container2 not type2");
assertNull(plainProvider.getExpectedType((IExpression) expression3Container.eGet(expressionContainerReference)), "expected type for container3 not null");
assertNull(plainProvider.getExpectedType(null), "expected type for null not null");
assertEquals(type1, plainProvider.getTypeForNamedElement(namedElement1), "type for namedElement1 not type1");
assertEquals(type2, plainProvider.getTypeForNamedElement(namedElement2), "type for namedElement2 not type2");
assertNull(plainProvider.getTypeForNamedElement(namedElement3), "type for namedElement3 not null");
assertNull(plainProvider.getTypeForNamedElement(null), "type for named element null not null");

}

@Test
public void testTypeProviderPlain() {
void testTypeProviderPlain() {
ITypeProvider provider = new PlainTypeProvider();
testPlainProvider(provider);
}

@Test
public void testTypeProviderCyclicDefault() {
void testTypeProviderCyclicDefault() {
ITypeProvider provider = new CyclicDefaultTypeProvider();
assertNull("cylic type for expression1 not null", provider.getType(expression1));
assertNull("cylic type for expression2 not null", provider.getType(expression2));
assertNull("cyclic expected type for container1 not null", provider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)));
assertNull("cyclic expected type for container2 not null", provider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)));
assertNull("cyclic type for namedElement1 not null", provider.getTypeForNamedElement(namedElement1));
assertNull("cyclic type for namedElement2 not null", provider.getTypeForNamedElement(namedElement2));
assertNull(provider.getType(expression1), "cylic type for expression1 not null");
assertNull(provider.getType(expression2), "cylic type for expression2 not null");
assertNull(provider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)), "cyclic expected type for container1 not null");
assertNull(provider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)), "cyclic expected type for container2 not null");
assertNull(provider.getTypeForNamedElement(namedElement1), "cyclic type for namedElement1 not null");
assertNull(provider.getTypeForNamedElement(namedElement2), "cyclic type for namedElement2 not null");
}

@Test
public void testTypeProviderCyclicOverride() {
void testTypeProviderCyclicOverride() {
ITypeProvider provider = new CyclicOverrideTypeProvider();
assertEquals("cyclic override type for expression1 not type1", type1, provider.getType(expression1));
assertEquals("cyclic override type for expression2 not type1", type1, provider.getType(expression2));
assertEquals("cyclic override expected type for container1 not type2", type2, provider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)));
assertEquals("cyclic override expected type for container2 not type2", type2, provider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)));
assertEquals("cyclic override type for namedElement1 not type3", type3, provider.getTypeForNamedElement(namedElement1));
assertEquals("cyclic override type for namedElement2 not type3", type3, provider.getTypeForNamedElement(namedElement2));
assertEquals(type1, provider.getType(expression1), "cyclic override type for expression1 not type1");
assertEquals(type1, provider.getType(expression2), "cyclic override type for expression2 not type1");
assertEquals(type2, provider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)), "cyclic override expected type for container1 not type2");
assertEquals(type2, provider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)), "cyclic override expected type for container2 not type2");
assertEquals(type3, provider.getTypeForNamedElement(namedElement1), "cyclic override type for namedElement1 not type3");
assertEquals(type3, provider.getTypeForNamedElement(namedElement2), "cyclic override type for namedElement2 not type3");
}

@Test
public void testTypeProviderCyclicOverrideMixed() {
void testTypeProviderCyclicOverrideMixed() {
ITypeProvider provider = new CyclicOverrideMixedTypeProvider();
assertEquals("cyclic mixed type for expression1 not type1", type1, provider.getType(expression1));
assertEquals("cyclic mixed type for expression2 not type1", type1, provider.getType(expression2));
assertEquals("cyclic mixed expected type for container1 not type2", type2, provider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)));
assertEquals("cyclic mixed expected type for container2 not type2", type2, provider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)));
assertEquals("cyclic mixed type for namedElement1 not type1", type1, provider.getTypeForNamedElement(namedElement1));
assertEquals("cyclic mixed type for namedElement2 not type1", type1, provider.getTypeForNamedElement(namedElement2));
assertEquals(type1, provider.getType(expression1), "cyclic mixed type for expression1 not type1");
assertEquals(type1, provider.getType(expression2), "cyclic mixed type for expression2 not type1");
assertEquals(type2, provider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)), "cyclic mixed expected type for container1 not type2");
assertEquals(type2, provider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)), "cyclic mixed expected type for container2 not type2");
assertEquals(type1, provider.getTypeForNamedElement(namedElement1), "cyclic mixed type for namedElement1 not type1");
assertEquals(type1, provider.getTypeForNamedElement(namedElement2), "cyclic mixed type for namedElement2 not type1");
}

@Test
public void testDelegatingTypeProvider() {
void testDelegatingTypeProvider() {
delegateProvider = new PlainTypeProvider();
testPlainProvider(new DelegatingTypeProvider());
}

@Test
public void testDoNothingTypeProvider() {
void testDoNothingTypeProvider() {
// we are mainly testing that the AbstractTypeProvider does not crash when the subclass does nothing
ITypeProvider provider = new DoNothingTypeProvider();
assertNull("did something for type of expression1", provider.getType(expression1));
assertNull("did something for type of expression2", provider.getType(expression2));
assertNull("did something for type of expression3", provider.getType(expression3));
assertNull("did something for type of null", provider.getType(null));
assertNull("did something for expected type of expression1", provider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)));
assertNull("did something for expected type of expression2", provider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)));
assertNull("did something for expected type of expression3", provider.getExpectedType((IExpression) expression3Container.eGet(expressionContainerReference)));
assertNull("did something for expected type of null", provider.getExpectedType(null));
assertNull("did something for type of namedElement1", provider.getTypeForNamedElement(namedElement1));
assertNull("did something for type of namedElement2", provider.getTypeForNamedElement(namedElement2));
assertNull("did something for type of namedElement3", provider.getTypeForNamedElement(namedElement3));
assertNull("did something for type of namedElement null", provider.getTypeForNamedElement(null));
assertNull(provider.getType(expression1), "did something for type of expression1");
assertNull(provider.getType(expression2), "did something for type of expression2");
assertNull(provider.getType(expression3), "did something for type of expression3");
assertNull(provider.getType(null), "did something for type of null");
assertNull(provider.getExpectedType((IExpression) expression1Container.eGet(expressionContainerReference)), "did something for expected type of expression1");
assertNull(provider.getExpectedType((IExpression) expression2Container.eGet(expressionContainerReference)), "did something for expected type of expression2");
assertNull(provider.getExpectedType((IExpression) expression3Container.eGet(expressionContainerReference)), "did something for expected type of expression3");
assertNull(provider.getExpectedType(null), "did something for expected type of null");
assertNull(provider.getTypeForNamedElement(namedElement1), "did something for type of namedElement1");
assertNull(provider.getTypeForNamedElement(namedElement2), "did something for type of namedElement2");
assertNull(provider.getTypeForNamedElement(namedElement3), "did something for type of namedElement3");
assertNull(provider.getTypeForNamedElement(null), "did something for type of namedElement null");
}

protected class PlainTypeProvider extends AbstractTypeProvider {
Expand Down Expand Up @@ -348,7 +348,7 @@ protected boolean providesTypeForNamedElement(final INamedElement element) {

@Override
protected ITypeProvider getTypeProviderFor(final EObject eObject) {
assertNotNull("there is no delegate provider", delegateProvider);
assertNotNull(delegateProvider, "there is no delegate provider");
return delegateProvider;
}

Expand Down
40 changes: 20 additions & 20 deletions ...s.ddk.typesystem.test/src/com/avaloq/tools/ddk/typesystem/BuiltInTypeModelAccessTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,14 +10,14 @@
*******************************************************************************/
package com.avaloq.tools.ddk.typesystem;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
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.assertSame;

import org.eclipse.emf.common.util.EList;
import org.junit.Test;
import org.junit.jupiter.api.Test;

import com.avaloq.tools.ddk.typesystem.builtintypemodel.BuiltInTypeModel;
import com.avaloq.tools.ddk.typesystem.builtintypemodel.InternalType;
Expand All @@ -28,44 +28,44 @@
* Tests that the BuiltInType model instance is correct and complete.
*/
@SuppressWarnings("nls")
public class BuiltInTypeModelAccessTest {
class BuiltInTypeModelAccessTest {

@Test
public void testLoadModel() {
void testLoadModel() {
BuiltInTypeModelAccess typeModelInstance = BuiltInTypeModelAccess.getInstance();
BuiltInTypeModel model = typeModelInstance.getModel();
assertNotNull("Model was created", model);
assertNotNull(model, "Model was created");
EList<InternalType> types = model.getInternalTypes();
assertFalse("Model has built-in internal types", types.isEmpty());
assertFalse(types.isEmpty(), "Model has built-in internal types");
for (InternalType type : types) {
String typeName = type.getName();
assertFalse("Internal type has name", typeName == null || "".equals(typeName));
assertFalse(typeName == null || "".equals(typeName), "Internal type has name");
}
}

private void assertPresence(final String name) {
INamedType t = BuiltInTypeModelAccess.getInstance().getInternalType(name);
assertNotNull("Type \"" + name + "\" found", t);
assertEquals("Actual type name matches", name, t.getName());
assertNotNull(t, "Type \"" + name + "\" found");
assertEquals(name, t.getName(), "Actual type name matches");
}

@Test
public void testHasInternalTypes() {
void testHasInternalTypes() {
assertPresence(BuiltInTypeModelAccess.ANY_TYPE_NAME);
assertPresence(BuiltInTypeModelAccess.ERROR_TYPE_NAME);
assertPresence(BuiltInTypeModelAccess.UNDETERMINED_TYPE_NAME);
assertPresence(BuiltInTypeModelAccess.VOID_TYPE_NAME);
}

@Test
public void testInvalidInternalTypeNames() {
assertNull("Null name returns null", BuiltInTypeModelAccess.getInstance().getInternalType(null));
assertNull("Empty name returns null", BuiltInTypeModelAccess.getInstance().getInternalType(""));
assertNull("Non-existant name returns null", BuiltInTypeModelAccess.getInstance().getInternalType("xyz!!"));
void testInvalidInternalTypeNames() {
assertNull(BuiltInTypeModelAccess.getInstance().getInternalType(null), "Null name returns null");
assertNull(BuiltInTypeModelAccess.getInstance().getInternalType(""), "Empty name returns null");
assertNull(BuiltInTypeModelAccess.getInstance().getInternalType("xyz!!"), "Non-existant name returns null");
}

@Test
public void testUniqueInternalTypes() {
void testUniqueInternalTypes() {
assertUnique(BuiltInTypeModelAccess.ANY_TYPE_NAME);
assertUnique(BuiltInTypeModelAccess.ERROR_TYPE_NAME);
assertUnique(BuiltInTypeModelAccess.UNDETERMINED_TYPE_NAME);
Expand All @@ -74,6 +74,6 @@ public void testUniqueInternalTypes() {

private void assertUnique(final String typeName) {
BuiltInTypeModelAccess instance = BuiltInTypeModelAccess.getInstance();
assertSame("type " + typeName + " is unique", instance.getInternalType(typeName), instance.getInternalType(typeName));
assertSame(instance.getInternalType(typeName), instance.getInternalType(typeName), "type " + typeName + " is unique");
}
}
Loading