| /******************************************************************************* |
| * Copyright (C) 2021 the Eclipse BaSyx Authors |
| * |
| * This program and the accompanying materials are made |
| * available under the terms of the Eclipse Public License 2.0 |
| * which is available at https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| ******************************************************************************/ |
| package org.eclipse.basyx.testsuite.regression.submodel.metamodel.map.submodelelement; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertTrue; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.basyx.submodel.metamodel.api.identifier.IdentifierType; |
| import org.eclipse.basyx.submodel.metamodel.api.qualifier.haskind.ModelingKind; |
| import org.eclipse.basyx.submodel.metamodel.api.reference.IReference; |
| import org.eclipse.basyx.submodel.metamodel.api.reference.enums.KeyElements; |
| import org.eclipse.basyx.submodel.metamodel.api.reference.enums.KeyType; |
| import org.eclipse.basyx.submodel.metamodel.api.submodelelement.ISubmodelElement; |
| import org.eclipse.basyx.submodel.metamodel.api.submodelelement.dataelement.IDataElement; |
| import org.eclipse.basyx.submodel.metamodel.api.submodelelement.operation.IOperation; |
| import org.eclipse.basyx.submodel.metamodel.map.identifier.Identifier; |
| import org.eclipse.basyx.submodel.metamodel.map.qualifier.LangStrings; |
| import org.eclipse.basyx.submodel.metamodel.map.qualifier.Referable; |
| import org.eclipse.basyx.submodel.metamodel.map.qualifier.qualifiable.Formula; |
| import org.eclipse.basyx.submodel.metamodel.map.qualifier.qualifiable.Qualifiable; |
| import org.eclipse.basyx.submodel.metamodel.map.reference.Key; |
| import org.eclipse.basyx.submodel.metamodel.map.reference.Reference; |
| import org.eclipse.basyx.submodel.metamodel.map.submodelelement.SubmodelElementCollection; |
| import org.eclipse.basyx.submodel.metamodel.map.submodelelement.dataelement.property.Property; |
| import org.eclipse.basyx.submodel.metamodel.map.submodelelement.operation.Operation; |
| import org.eclipse.basyx.submodel.metamodel.map.submodelelement.operation.OperationVariable; |
| import org.eclipse.basyx.vab.exception.provider.ResourceNotFoundException; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| /** |
| * Tests constructor and getter of {@link SubmodelElementCollection} for their |
| * correctness |
| * |
| * @author haque |
| * |
| */ |
| public class TestSubmodelElementCollection { |
| private static final Reference REFERENCE = new Reference(new Identifier(IdentifierType.CUSTOM, "testValue"), KeyElements.ACCESSPERMISSIONRULE, false); |
| private static final String OPERATION_ID = "testOpID"; |
| private static final String PROPERTY_ID = "testPropID"; |
| |
| private Collection<ISubmodelElement> elements1; |
| private Collection<ISubmodelElement> elements2; |
| private SubmodelElementCollection elementCollection; |
| |
| @Before |
| public void buildSubmodelElementCollection() { |
| elements1 = new ArrayList<>(); |
| elements1.add(getProperty()); |
| elements1.add(getOperation()); |
| |
| elements2 = new ArrayList<ISubmodelElement>(); |
| elements2.add(new Property("idShort1", "testId1")); |
| elements2.add(new Property("idShort2","testId2")); |
| elementCollection = new SubmodelElementCollection(elements2, false, false); |
| elementCollection.setIdShort("testCollectionId"); |
| } |
| |
| @Test |
| public void testConstructor() { |
| SubmodelElementCollection elementCollection = new SubmodelElementCollection(elements1, true, true); |
| assertTrue(elementCollection.isAllowDuplicates()); |
| assertTrue(elementCollection.isOrdered()); |
| |
| ISubmodelElement checkOperation = elementCollection.getSubmodelElements().get(OPERATION_ID); |
| assertEquals(OPERATION_ID, checkOperation.getIdShort()); |
| } |
| |
| @Test |
| public void testAddValue() { |
| Property element = new Property("testProperty"); |
| element.setIdShort("propId"); |
| elementCollection.addSubModelElement(element); |
| elements2.add(element); |
| |
| ISubmodelElement checkProperty = elementCollection.getSubmodelElements().get("propId"); |
| assertEquals(element.getIdShort(), checkProperty.getIdShort()); |
| } |
| |
| @Test |
| public void testSetDataSpecificationReferences() { |
| Collection<IReference> refs = Collections.singleton(REFERENCE); |
| elementCollection.setDataSpecificationReferences(refs); |
| assertEquals(refs, elementCollection.getDataSpecificationReferences()); |
| } |
| |
| @Test |
| public void testSetValue() { |
| Collection<ISubmodelElement> elements = new ArrayList<ISubmodelElement>(); |
| Property element = new Property("testProperty"); |
| element.setIdShort("propId"); |
| elements.add(element); |
| elementCollection.setValue(elements); |
| |
| ISubmodelElement checkProperty = elementCollection.getSubmodelElements().get("propId"); |
| assertEquals(element.getIdShort(), checkProperty.getIdShort()); |
| } |
| |
| @Test |
| public void testSetOrdered() { |
| elementCollection.setOrdered(false); |
| assertTrue(!elementCollection.isOrdered()); |
| } |
| |
| @Test |
| public void testSetAllowDuplicates() { |
| elementCollection.setAllowDuplicates(false); |
| assertTrue(!elementCollection.isAllowDuplicates()); |
| } |
| |
| @Test |
| public void testSetElements() { |
| String idShort = "testIdShort"; |
| Key key = new Key(KeyElements.BLOB, true, "TestValue", IdentifierType.IRI); |
| Reference reference = new Reference(key); |
| Formula formula = new Formula(Collections.singleton(reference)); |
| Qualifiable qualifiable = new Qualifiable(formula); |
| ISubmodelElement element = new Property("testId1", new Referable(idShort, "Category", new LangStrings("DE", "Test")), REFERENCE, qualifiable); |
| Map<String, ISubmodelElement> elementsMap = new HashMap<String, ISubmodelElement>(); |
| elementsMap.put(idShort, element); |
| elementCollection.setElements(elementsMap); |
| assertEquals(elementsMap, elementCollection.getSubmodelElements()); |
| } |
| |
| |
| @Test |
| public void testConstructor1() { |
| SubmodelElementCollection collection = new SubmodelElementCollection(elements1, false, false); |
| |
| Map<String, IDataElement> dataElements = new HashMap<String, IDataElement>(); |
| Map<String, IOperation> operations = new HashMap<String, IOperation>(); |
| Map<String, ISubmodelElement> submodels = new HashMap<String, ISubmodelElement>(); |
| dataElements.put(PROPERTY_ID, getProperty()); |
| operations.put(OPERATION_ID, getOperation()); |
| submodels.putAll(operations); |
| submodels.putAll(dataElements); |
| assertEquals(dataElements, collection.getProperties()); |
| assertEquals(operations, collection.getOperations()); |
| assertEquals(submodels, collection.getSubmodelElements()); |
| } |
| |
| @Test |
| public void testAddSubModelElement() { |
| SubmodelElementCollection collection = new SubmodelElementCollection(elements1, false, false); |
| String smCollIdShort = "coll1"; |
| collection.setIdShort(smCollIdShort); |
| Property property = new Property("testValue"); |
| String newIdShort = "newIdShort"; |
| property.put(Referable.IDSHORT, newIdShort); |
| collection.addSubModelElement(property); |
| assertEquals(new Reference(new Key(KeyElements.SUBMODELELEMENTCOLLECTION, true, smCollIdShort, KeyType.IDSHORT)), property.getParent()); |
| Map<String, ISubmodelElement> submodelElements = new HashMap<String, ISubmodelElement>(); |
| submodelElements.put(PROPERTY_ID, getProperty()); |
| submodelElements.put(OPERATION_ID, getOperation()); |
| submodelElements.put(newIdShort, property); |
| assertEquals(submodelElements, collection.getSubmodelElements()); |
| } |
| |
| @Test |
| public void testGetSubModelElement() { |
| SubmodelElementCollection collection = new SubmodelElementCollection(elements1, false, false); |
| ISubmodelElement retrievedElement = collection.getSubmodelElement(PROPERTY_ID); |
| assertEquals(getProperty(), retrievedElement); |
| } |
| |
| @Test(expected = ResourceNotFoundException.class) |
| public void testGetSubModelElementNotExist() { |
| SubmodelElementCollection collection = new SubmodelElementCollection(elements1, false, false); |
| collection.getSubmodelElement("Id_Which_Does_Not_Exist"); |
| } |
| |
| @Test(expected = ResourceNotFoundException.class) |
| public void testDeleteSubModelElement() { |
| SubmodelElementCollection collection = new SubmodelElementCollection(elements1, false, false); |
| collection.deleteSubmodelElement(PROPERTY_ID); |
| collection.getSubmodelElement(PROPERTY_ID); |
| } |
| |
| @Test(expected = ResourceNotFoundException.class) |
| public void testDeleteSubModelElementNotExist() { |
| SubmodelElementCollection collection = new SubmodelElementCollection(elements1, false, false); |
| collection.deleteSubmodelElement("Id_Which_Does_Not_Exist"); |
| } |
| |
| /** |
| * Get a dummy property |
| * |
| * @return property |
| */ |
| private Property getProperty() { |
| Referable referable = new Referable(PROPERTY_ID, "testCategory", new LangStrings("DE", "test")); |
| Reference semanticId = new Reference(new Key(KeyElements.ASSET, true, "testValue", IdentifierType.IRI)); |
| Qualifiable qualifiable = new Qualifiable(new Formula(Collections |
| .singleton(new Reference(new Key(KeyElements.BLOB, true, "TestValue", IdentifierType.IRI))))); |
| Property property = new Property("testValue", referable, semanticId, qualifiable); |
| return property; |
| } |
| |
| /** |
| * Get a dummy operation |
| * |
| * @return operation |
| */ |
| private Operation getOperation() { |
| Property property = new Property("testOpVariableId"); |
| property.setModelingKind(ModelingKind.TEMPLATE); |
| List<OperationVariable> variable = Collections |
| .singletonList(new OperationVariable(property)); |
| Operation operation = new Operation(variable, variable, variable, null); |
| operation.put(Referable.IDSHORT, OPERATION_ID); |
| return operation; |
| } |
| } |