> elem = iter.next();
+ assertTrue(result.contains(elem));
+ ++num;
+ }
+
+ assertEquals(result.size(), num);
+ }
+}
diff --git a/use-core/src/test/java/org/tzi/use/util/ReportTest.java b/use-core/src/test/java/org/tzi/use/util/ReportTest.java
new file mode 100644
index 000000000..a9ce98103
--- /dev/null
+++ b/use-core/src/test/java/org/tzi/use/util/ReportTest.java
@@ -0,0 +1,70 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2004 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.util;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import junit.framework.TestCase;
+
+/**
+ * Test Report class.
+ *
+ * @author Mark Richters
+ */
+
+public class ReportTest extends TestCase {
+
+ public void test1() {
+ Report r = new Report(4, "[ $c = $r, $r, $l ]");
+ r.addRuler('-');
+ r.addRow();
+ r.addCell("foo");
+ r.addCell(Integer.valueOf(3));
+ r.addCell(Double.valueOf(1.2));
+ r.addCell(Boolean.FALSE);
+
+ r.addRow();
+ r.addCell("foobar");
+ r.addCell(Integer.valueOf(453453));
+ r.addCell(Double.valueOf(-1.245345345));
+ r.addCell(Boolean.TRUE);
+
+ r.addRow();
+ r.addCell("line");
+ r.addCell(Integer.valueOf(555));
+ r.addCell(Double.valueOf(999.0));
+ r.addCell(Boolean.TRUE);
+ r.addRuler('=');
+
+ StringWriter sw1 = new StringWriter();
+ PrintWriter p1 = new PrintWriter(sw1);
+ r.printOn(p1);
+ p1.flush();
+ StringWriter sw2 = new StringWriter();
+ PrintWriter p2 = new PrintWriter(sw2);
+ p2.println("----------------------------------------");
+ p2.println("[ foo = 3, 1.2, false ]");
+ p2.println("[ foobar = 453453, -1.245345345, true ]");
+ p2.println("[ line = 555, 999.0, true ]");
+ p2.println("========================================");
+ p2.flush();
+ assertEquals(sw1.toString(), sw2.toString());
+ }
+}
diff --git a/use-core/src/test/java/org/tzi/use/util/StringUtilTest.java b/use-core/src/test/java/org/tzi/use/util/StringUtilTest.java
new file mode 100644
index 000000000..0e3c65a8e
--- /dev/null
+++ b/use-core/src/test/java/org/tzi/use/util/StringUtilTest.java
@@ -0,0 +1,62 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2004 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.util;
+import junit.framework.TestCase;
+
+/**
+ * Test StringUtil class.
+ *
+ * @author Mark Richters
+ */
+
+public class StringUtilTest extends TestCase {
+
+ public StringUtilTest(String name) {
+ super(name);
+ }
+
+ public void testNthIndexOf() {
+ assertEquals(-1, StringUtil.nthIndexOf("abbbb", 0, "bb"));
+ assertEquals(1, StringUtil.nthIndexOf("abbbb", 1, "bb"));
+ assertEquals(3, StringUtil.nthIndexOf("abbbb", 2, "bb"));
+ assertEquals(-1, StringUtil.nthIndexOf("abbbb", 3, "bb"));
+ assertEquals(7, StringUtil.nthIndexOf("abbbbaabb", 3, "bb"));
+ assertEquals(-1, StringUtil.nthIndexOf("abbbb", 0, 'b'));
+ assertEquals(1, StringUtil.nthIndexOf("abbbb", 1, 'b'));
+ assertEquals(3, StringUtil.nthIndexOf("abbbb", 3, 'b'));
+ }
+
+ public void testPad() {
+ assertEquals("a", StringUtil.pad("a", 1));
+ assertEquals("a ", StringUtil.pad("a", 2));
+ }
+
+ public void testCenter() {
+ assertEquals(" a ", StringUtil.center("a", 3));
+ assertEquals(" a ", StringUtil.center("a", 3));
+ }
+
+ public void testEscapeChar() {
+ assertEquals("a", StringUtil.escapeChar('a', '"'));
+ assertEquals("\\344", StringUtil.escapeChar('\344', '"'));
+ assertEquals("\\u1234", StringUtil.escapeChar('\u1234', '"'));
+ assertEquals("\\t", StringUtil.escapeChar('\t', '"'));
+ }
+}
diff --git a/use-core/src/test/java/org/tzi/use/util/soil/AllTests.java b/use-core/src/test/java/org/tzi/use/util/soil/AllTests.java
new file mode 100644
index 000000000..695500e62
--- /dev/null
+++ b/use-core/src/test/java/org/tzi/use/util/soil/AllTests.java
@@ -0,0 +1,55 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2010 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.util.soil;
+
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+
+/**
+ * Collection of all soil utility tests
+ *
+ * @author Daniel Gent
+ */
+public class AllTests {
+
+ /**
+ * no instances required
+ */
+ private AllTests() {
+
+ }
+
+
+ /**
+ * builds the suite of all soil utility tests
+ *
+ * @return the suite of all soil utility tests
+ */
+ public static Test suite() {
+ final TestSuite testSuite = new TestSuite("All soil util tests");
+ testSuite.addTestSuite(VariableEnvironmentTest.class);
+ testSuite.addTestSuite(StateChangesTest.class);
+ testSuite.addTestSuite(VariableSetTest.class);
+ testSuite.addTestSuite(SymbolTableTest.class);
+ return testSuite;
+ }
+}
\ No newline at end of file
diff --git a/use-core/src/test/java/org/tzi/use/util/soil/StateChangesTest.java b/use-core/src/test/java/org/tzi/use/util/soil/StateChangesTest.java
new file mode 100644
index 000000000..7dedab553
--- /dev/null
+++ b/use-core/src/test/java/org/tzi/use/util/soil/StateChangesTest.java
@@ -0,0 +1,307 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2010 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.util.soil;
+
+
+import java.util.Arrays;
+
+import junit.framework.TestCase;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.tzi.use.uml.mm.MAssociation;
+import org.tzi.use.uml.mm.MAssociationClass;
+import org.tzi.use.uml.mm.MClass;
+import org.tzi.use.uml.mm.MModel;
+import org.tzi.use.uml.mm.TestModelUtil;
+import org.tzi.use.uml.sys.MLink;
+import org.tzi.use.uml.sys.MLinkObject;
+import org.tzi.use.uml.sys.MObject;
+import org.tzi.use.uml.sys.MSystem;
+import org.tzi.use.uml.sys.MSystemException;
+import org.tzi.use.uml.sys.MSystemState;
+
+
+/**
+ * Test cases for various methods of {@code StateChanges}
+ *
+ * @author Daniel Gent
+ * @see StateDifference
+ */
+public class StateChangesTest extends TestCase {
+ /** the test subject */
+ private StateDifference fSC;
+ /** an arbitrary object */
+ private MObject fObject;
+ /** an arbitrary link */
+ private MLink fLink;
+ /** an arbitrary link object */
+ private MLinkObject fLinkObject;
+
+
+ /**
+ * builds the fixture consisting of the {@code StateChanges} object
+ * + the objects to insert
+ */
+ @Override
+ @Before
+ public void setUp() {
+
+ fSC = new StateDifference();
+ MModel model = TestModelUtil.getInstance().createComplexModel();
+ MClass person = model.getClass("Person");
+ MClass company = model.getClass("Company");
+ MAssociation isBoss = model.getAssociation("isBoss");
+ MAssociationClass job = model.getAssociationClass("Job");
+
+ MSystem system = new MSystem(model);
+ MSystemState state = system.state();
+ try {
+ fObject = state.createObject(person, "P");
+ MObject c = state.createObject(company, "C");
+ fLink = state.createLink(isBoss, Arrays.asList(fObject, fObject), null);
+ fLinkObject = state.createLinkObject(job, "J", Arrays.asList(fObject, c), null);
+ } catch (MSystemException e) {
+ fail(e.getMessage());
+ }
+ }
+
+
+ /**
+ * tests clear, isEmpty
+ *
+ * - initially the object is empty
+ * - invoking any {@code add} method on an empty {@code StateChanges}
+ * results in it being not empty anymore
+ * - invoking {@code clear} results in the {@code StateChanges} being
+ * empty
+ */
+ @Test
+ public void testClearIsEmpty() {
+ assertTrue(fSC.isEmpty());
+ fSC.addNewObject(fObject);
+ assertFalse(fSC.isEmpty());
+ fSC.clear();
+ assertTrue(fSC.isEmpty());
+ fSC.addModifiedObject(fObject);
+ assertFalse(fSC.isEmpty());
+ fSC.clear();
+ assertTrue(fSC.isEmpty());
+ fSC.addDeletedObject(fObject);
+ assertFalse(fSC.isEmpty());
+ fSC.clear();
+ assertTrue(fSC.isEmpty());
+ fSC.addNewLink(fLink);
+ assertFalse(fSC.isEmpty());
+ fSC.clear();
+ assertTrue(fSC.isEmpty());
+ fSC.addDeletedLink(fLink);
+ assertFalse(fSC.isEmpty());
+ fSC.clear();
+ assertTrue(fSC.isEmpty());
+ }
+
+
+ /**
+ * tests addNewObject, addModifiedObject, addDeletedObject with a
+ * non-link-object object
+ *
+ * - after invoking any one method, the supplied object is either
+ * in exactly one or in none of the new-, modified- or deleted sets
+ * - two consecutive invocations of different {@code add...Object} methods
+ * with the same object lead to certain outcomes
+ */
+ @Test
+ public void testAddObject() {
+ // adding objects to an empty StateChanges object
+ fSC.addNewObject(fObject);
+ assertTrue(isOnlyNew(fObject));
+ fSC.clear();
+ fSC.addModifiedObject(fObject);
+ assertTrue(isOnlyModified(fObject));
+ fSC.clear();
+ fSC.addDeletedObject(fObject);
+ assertTrue(isOnlyDeleted(fObject));
+ fSC.clear();
+
+ // invocations of the add...Object methods in the context of
+ // previous add...Object calls
+
+ // new, modified = new
+ fSC.addNewObject(fObject);
+ fSC.addModifiedObject(fObject);
+ assertTrue(isOnlyNew(fObject));
+ fSC.clear();
+
+ // new, deleted = empty
+ fSC.addNewObject(fObject);
+ fSC.addDeletedObject(fObject);
+ assertTrue(fSC.isEmpty());
+ fSC.clear();
+
+ // modified, new = new
+ // hypothetical case, shouldn't be possible to achieve
+ fSC.addModifiedObject(fObject);
+ fSC.addNewObject(fObject);
+ assertTrue(isOnlyNew(fObject));
+ fSC.clear();
+
+ // modified, deleted = deleted
+ fSC.addModifiedObject(fObject);
+ fSC.addDeletedObject(fObject);
+ assertTrue(isOnlyDeleted(fObject));
+ fSC.clear();
+
+ // deleted, new = modified
+ fSC.addDeletedObject(fObject);
+ fSC.addNewObject(fObject);
+ assertTrue(isOnlyModified(fObject));
+ fSC.clear();
+
+ // deleted, modified = modified
+ // hypothetical case, shouldn't be possible to achieve
+ fSC.addDeletedObject(fObject);
+ fSC.addModifiedObject(fObject);
+ assertTrue(isOnlyModified(fObject));
+ fSC.clear();
+ }
+
+
+ /**
+ * tests addNewLink, addDeletedLink with a non-link-object link
+ *
+ * - after invoking one of the methods, the link is either in the set of
+ * new links or deleted links or in neither of those sets, but not in
+ * both
+ * - adding a new link which was previously deleted leads to that link
+ * being in neither the set of new links nor the set of deleted links
+ * - the same holds true for adding a deleted link which was previously
+ * new
+ */
+ @Test
+ public void testAddLink() {
+ fSC.addNewLink(fLink);
+ assertTrue(fSC.getNewLinks().contains(fLink));
+ fSC.clear();
+ fSC.addDeletedLink(fLink);
+ assertTrue(fSC.getDeletedLinks().contains(fLink));
+ fSC.clear();
+
+ // new, deleted = empty
+ fSC.addNewLink(fLink);
+ fSC.addDeletedLink(fLink);
+ assertFalse(fSC.getNewLinks().contains(fLink));
+ assertFalse(fSC.getDeletedLinks().contains(fLink));
+ fSC.clear();
+
+ // deleted, new = empty
+ fSC.addDeletedLink(fLink);
+ fSC.addNewLink(fLink);
+ assertFalse(fSC.getNewLinks().contains(fLink));
+ assertFalse(fSC.getDeletedLinks().contains(fLink));
+ fSC.clear();
+ }
+
+
+ /**
+ * tests addNew(Link)(Object), addDeleted(Link)(Object)
+ *
+ * - invoking any of the {@code addNew...} or {@code addDeleted...} methods
+ * with a link object results in the link object being treated as an
+ * object and a link, i.E. it doesn't matter which version is used
+ */
+ @Test
+ public void testAddLinkObject() {
+ fSC.addNewLinkObject(fLinkObject);
+ assertTrue(fSC.getNewObjects().contains(fLinkObject));
+ assertTrue(fSC.getNewLinks().contains(fLinkObject));
+ fSC.clear();
+
+ fSC.addDeletedLinkObject(fLinkObject);
+ assertTrue(fSC.getDeletedObjects().contains(fLinkObject));
+ assertTrue(fSC.getDeletedLinks().contains(fLinkObject));
+ fSC.clear();
+
+ fSC.addNewObject(fLinkObject);
+ assertTrue(fSC.getNewObjects().contains(fLinkObject));
+ assertTrue(fSC.getNewLinks().contains(fLinkObject));
+ fSC.clear();
+
+ fSC.addDeletedObject(fLinkObject);
+ assertTrue(fSC.getDeletedObjects().contains(fLinkObject));
+ assertTrue(fSC.getDeletedLinks().contains(fLinkObject));
+ fSC.clear();
+
+ fSC.addNewLink(fLinkObject);
+ assertTrue(fSC.getNewObjects().contains(fLinkObject));
+ assertTrue(fSC.getNewLinks().contains(fLinkObject));
+ fSC.clear();
+
+ fSC.addDeletedLink(fLinkObject);
+ assertTrue(fSC.getDeletedObjects().contains(fLinkObject));
+ assertTrue(fSC.getDeletedLinks().contains(fLinkObject));
+ fSC.clear();
+ }
+
+
+ /**
+ * returns true if object is a member of the newObjects set, and not member
+ * of the other sets
+ *
+ * @param object the object to test
+ * @return true if {@code object} is only in the set of new objects
+ */
+ private boolean isOnlyNew(MObject object) {
+ return
+ fSC.getNewObjects().contains(object)
+ && !fSC.getModifiedObjects().contains(object)
+ && !fSC.getDeletedObjects().contains(object);
+ }
+
+
+ /**
+ * returns true if object is a member of the modifiedObjects set, and not
+ * member of the other sets
+ *
+ * @param object the object to test
+ * @return true if {@code object} is only in the set of modified objects
+ */
+ private boolean isOnlyModified(MObject object) {
+ return
+ !fSC.getNewObjects().contains(object)
+ && fSC.getModifiedObjects().contains(object)
+ && !fSC.getDeletedObjects().contains(object);
+ }
+
+
+ /**
+ * returns true if object is a member of the deletedObjects set, and not
+ * member of the other sets
+ *
+ * @param object the object to test
+ * @return true if {@code object} is only in the set of deleted objects
+ */
+ private boolean isOnlyDeleted(MObject object) {
+ return
+ !fSC.getNewObjects().contains(object)
+ && !fSC.getModifiedObjects().contains(object)
+ && fSC.getDeletedObjects().contains(object);
+ }
+}
diff --git a/use-core/src/test/java/org/tzi/use/util/soil/SymbolTableTest.java b/use-core/src/test/java/org/tzi/use/util/soil/SymbolTableTest.java
new file mode 100644
index 000000000..6127a2d98
--- /dev/null
+++ b/use-core/src/test/java/org/tzi/use/util/soil/SymbolTableTest.java
@@ -0,0 +1,130 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2010 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.util.soil;
+
+import junit.framework.TestCase;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.tzi.use.parser.soil.ast.ASTEmptyStatement;
+import org.tzi.use.parser.soil.ast.ASTStatement;
+import org.tzi.use.uml.ocl.type.Type;
+import org.tzi.use.uml.ocl.type.TypeFactory;
+
+
+/**
+ * Test cases for various methods of {@code SymbolTable}s
+ *
+ * @author Daniel Gent
+ * @see SymbolTable
+ */
+public class SymbolTableTest extends TestCase {
+ /** the test subject */
+ private SymbolTable fST;
+ /** arbitrary name */
+ private String fVariableName;
+ /** the ocl Real type */
+ private Type fRealType;
+ /** the ocl Integer type */
+ private Type fIntegerType;
+ /** the ocl String type */
+ private Type fStringType;
+ /** arbitrary statement */
+ private ASTStatement fStatement;
+
+
+
+ /**
+ * constructs the fixture
+ */
+ @Override
+ @Before
+ public void setUp() {
+ fST = new SymbolTable();
+ fVariableName = "name";
+ fRealType = TypeFactory.mkReal();
+ fIntegerType = TypeFactory.mkInteger();
+ fStringType = TypeFactory.mkString();
+ fStatement = new ASTEmptyStatement();
+
+ assertTrue(fIntegerType.conformsTo(fRealType));
+ }
+
+
+ /**
+ * tests type setting and getting
+ *
+ * @see SymbolTable#getType(String)
+ * @see SymbolTable#setType(String, Type)
+ */
+ @Test
+ public void testGetSet() {
+ assertNull(fST.getType(fVariableName));
+ fST.setType(fVariableName, fIntegerType);
+ assertEquals(fST.getType(fVariableName), fIntegerType);
+ fST.setType(fVariableName, fRealType);
+ assertEquals(fST.getType(fVariableName), fRealType);
+ }
+
+
+ /**
+ * tests state storing and restoring
+ *
+ * @see SymbolTable#storeState()
+ * @see SymbolTable#restoreState(ASTStatement)
+ */
+ @Test
+ public void testStoreRestore() {
+ // check if the stack works correctly
+ fST.setType(fVariableName, fIntegerType);
+ assertEquals(fST.getType(fVariableName), fIntegerType);
+ fST.storeState();
+ fST.setType(fVariableName, fRealType);
+ assertEquals(fST.getType(fVariableName), fRealType);
+ fST.storeState();
+ fST.setType(fVariableName, fStringType);
+ assertEquals(fST.getType(fVariableName), fStringType);
+ fST.restoreState(fStatement);
+ assertEquals(fST.getType(fVariableName), fRealType);
+ fST.restoreState(fStatement);
+ assertEquals(fST.getType(fVariableName), fIntegerType);
+ fST.clear();
+
+ // test dirty-bit
+ fST.setType(fVariableName, fIntegerType);
+ fST.storeState();
+ fST.setType(fVariableName, fStringType);
+ fST.restoreState(fStatement);
+ // the type does not change
+ assertEquals(fST.getType(fVariableName), fIntegerType);
+ // but the variable is now dirty
+ assertTrue(fST.isDirty(fVariableName));
+ assertEquals(fST.getCause(fVariableName), fStatement);
+ fST.clear();
+
+ fST.setType(fVariableName, fRealType);
+ fST.storeState();
+ fST.setType(fVariableName, fIntegerType);
+ fST.restoreState(fStatement);
+ assertEquals(fST.getType(fVariableName), fRealType);
+ // not dirty, since Integer is a sub-type of Real
+ assertFalse(fST.isDirty(fVariableName));
+ }
+}
diff --git a/use-core/src/test/java/org/tzi/use/util/soil/VariableEnvironmentTest.java b/use-core/src/test/java/org/tzi/use/util/soil/VariableEnvironmentTest.java
new file mode 100644
index 000000000..f98cb91fd
--- /dev/null
+++ b/use-core/src/test/java/org/tzi/use/util/soil/VariableEnvironmentTest.java
@@ -0,0 +1,326 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2010 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.util.soil;
+
+
+import junit.framework.TestCase;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.tzi.use.TestSystem;
+import org.tzi.use.uml.mm.MClass;
+import org.tzi.use.uml.mm.MInvalidModelException;
+import org.tzi.use.uml.mm.MModel;
+import org.tzi.use.uml.mm.ModelFactory;
+import org.tzi.use.uml.ocl.value.IntegerValue;
+import org.tzi.use.uml.ocl.value.UndefinedValue;
+import org.tzi.use.uml.ocl.value.Value;
+import org.tzi.use.uml.ocl.value.VarBindings;
+import org.tzi.use.uml.sys.MObject;
+import org.tzi.use.uml.sys.MSystem;
+import org.tzi.use.uml.sys.MSystemException;
+
+
+/**
+ * Test cases for various methods of {@code VariableEnvironment}s
+ *
+ * @author Daniel Gent
+ * @see VariableEnvironment
+ */
+public class VariableEnvironmentTest extends TestCase {
+ private VariableEnvironment ve;
+ private String n1;
+ private String n2;
+ private String n3;
+ private Value v1;
+ private Value v2;
+ private Value v3;
+ private Value vUnassigned;
+
+
+ /**
+ * constructs fixture
+ */
+ @Override
+ @Before
+ public void setUp() throws Exception {
+ TestSystem testSystem = new TestSystem();
+ ve = new VariableEnvironment(testSystem.getState());
+ n1 = "n1";
+ n2 = "n2";
+ n3 = "n3";
+ v1 = IntegerValue.valueOf(1);
+ v2 = IntegerValue.valueOf(2);
+ v3 = IntegerValue.valueOf(3);
+ vUnassigned = null;
+ }
+
+ @Test
+ public void testIdentity() {
+ assertEquals(1,1);
+ }
+
+ /**
+ * tests clear, isEmpty
+ *
+ * - empty means one empty frame
+ * - calling clear results in the variable environment being empty
+ */
+ @Test
+ public void testClearIsEmpty() {
+ // [ ]
+ assertTrue(ve.isEmpty());
+ // [n1 -> v1]
+ ve.assign(n1, v1);
+ assertFalse(ve.isEmpty());
+ // [ ]
+ ve.clear();
+ assertTrue(ve.isEmpty());
+ // [ ][ ]
+ ve.pushFrame(false);
+ assertFalse(ve.isEmpty());
+ // [ ]
+ ve.popFrame();
+ assertTrue(ve.isEmpty());
+ }
+
+
+ /**
+ * tests pushFrame, popFrame
+ *
+ * - after pushing a new frame, new assignments happen there
+ * - mappings in a popped frame are gone
+ */
+ @Test
+ public void testPushPopFrame() {
+ // [ ][ ]
+ ve.pushFrame(false);
+ // [ ][n1 -> v1]
+ ve.assign(n1, v1);
+ assertEquals(ve.lookUp(n1), v1);
+ // [ ]
+ ve.popFrame();
+ assertNull(ve.lookUp(n1));
+ // [n1 -> v1]
+ ve.assign(n1, v1);
+ assertEquals(ve.lookUp(n1), v1);
+ }
+
+
+ /**
+ * tests assign and lookup methods
+ *
+ * - assignments should only occur on the most recent level
+ * - previous assignments on that level should be updated in the most
+ * recent frame
+ */
+ @Test
+ public void testAssignLookUp() {
+ // [n1 -> v1]
+ ve.assign(n1, v1);
+ assertEquals(ve.lookUp(n1), v1);
+ // [n1 -> v2]
+ ve.assign(n1, v2);
+ assertEquals(ve.lookUp(n1), v2);
+ // [n1 -> v2, n2 -> v2]
+ ve.assign(n2, v2);
+ assertEquals(ve.lookUp(n1), v2);
+ assertEquals(ve.lookUp(n2), v2);
+ // [n1 -> v2, n2 -> v2][n1 -> v3, n2 -> v3, n3 -> v1]
+ ve.pushFrame(false);
+ ve.assign(n1, v3);
+ ve.assign(n2, v3);
+ ve.assign(n3, v1);
+ assertEquals(ve.lookUp(n1), v3);
+ assertEquals(ve.lookUp(n2), v3);
+ assertEquals(ve.lookUp(n3), v1);
+ // [n1 -> v2, n2 -> v2]
+ ve.popFrame();
+ assertEquals(ve.lookUp(n1), v2);
+ assertEquals(ve.lookUp(n2), v2);
+ assertEquals(ve.lookUp(n3), vUnassigned);
+ }
+
+
+ /**
+ * tests undefineReferencesTo, getTopLevelReferencesTo
+ *
+ * - all variables - disregarding the containing the level or frame -
+ * reference to the undefined value after undefineReferencesTo
+ * - getTopLevelReferencesTo returns the names of all variables in the
+ * first frame of the first level which refer to the specified object
+ */
+ @Test
+ public void testObjectReferences() {
+ MObject object = null;
+ ModelFactory mf = new ModelFactory();
+ MModel model = mf.createModel("m");
+ MClass cls = mf.createClass("c", false);
+ try {
+ model.addClass(cls);
+ } catch (MInvalidModelException e) {
+ fail(e.getMessage());
+ }
+ MSystem system = new MSystem(model);
+ try {
+ object = system.state().createObject(cls, "o");
+ } catch (MSystemException e) {
+ fail(e.getMessage());
+ }
+
+ Value vO = object.value();
+ Value vU = UndefinedValue.instance;
+
+ // [n1 -> vO1]
+ ve.assign(n1, vO);
+ assertTrue(ve.getTopLevelReferencesTo(object).contains(n1));
+ // [n1 -> vU]
+ ve.undefineReferencesTo(object);
+ assertEquals(ve.lookUp(n1), vU);
+ // [n1 -> vO1, n2 -> vO1]
+ ve.assign(n1, vO);
+ ve.assign(n2, vO);
+ assertTrue(ve.getTopLevelReferencesTo(object).contains(n1));
+ assertTrue(ve.getTopLevelReferencesTo(object).contains(n2));
+ // [n1 -> vU, n2 -> vU]
+ ve.undefineReferencesTo(object);
+ assertEquals(ve.lookUp(n1), vU);
+ assertEquals(ve.lookUp(n2), vU);
+ // [n1 -> vO1][n2 -> vO1]
+ // [n1 -> vO1, n2 -> vO1]
+ ve.assign(n1, vO);
+ ve.assign(n2, vO);
+ ve.pushFrame(false);
+ ve.assign(n1, vO);
+ ve.pushFrame(false);
+ ve.assign(n2, vO);
+ // [n1 -> vU][n2 -> vU]
+ // [n1 -> vU, n2 -> vU]
+ ve.undefineReferencesTo(object);
+ assertEquals(ve.lookUp(n2), vU);
+ // [n1 -> vU]
+ // [n1 -> vU, n2 -> vU]
+ ve.popFrame();
+ assertEquals(ve.lookUp(n1), vU);
+ // [n1 -> vU, n2 -> vU]
+ ve.popFrame();
+ assertEquals(ve.lookUp(n1), vU);
+ assertEquals(ve.lookUp(n2), vU);
+ }
+
+
+ /**
+ * tests remove
+ *
+ * - removes a mapping in the most recent frame
+ */
+ @Test
+ public void testRemove() {
+ // [n1 -> v1]
+ ve.assign(n1, v1);
+ assertEquals(ve.lookUp(n1), v1);
+ // [ ]
+ ve.remove(n1);
+ assertEquals(ve.lookUp(n1), vUnassigned);
+ // [n1 -> v1][n1 -> v2]
+ ve.assign(n1, v1);
+ ve.pushFrame(false);
+ ve.assign(n1, v2);
+ assertEquals(ve.lookUp(n1), v2);
+ // [n -> v1][ ]
+ ve.remove(n1);
+ assertEquals(ve.lookUp(n1), vUnassigned);
+ // [n -> v1]
+ ve.popFrame();
+ assertEquals(ve.lookUp(n1), v1);
+ }
+
+
+ /**
+ * test constructSymbolTable
+ *
+ * - name -> value mappings are transformed to corresponding
+ * name -> TypeOf(value) mappings
+ * - the symbol table in constructed only by mappings in the most recent
+ * frame
+ */
+ @Test
+ public void testConstructSymbolTable() {
+ // VE
+ // [n1 -> v1, n2 -> v2, n3 -> v3]
+ ve.assign(n1, v1);
+ ve.assign(n2, v2);
+ ve.assign(n3, v3);
+ // ST
+ // [n1 -> Type(v1), n2 -> Type(v2), n3 -> Type(v3)]
+ SymbolTable st = ve.constructSymbolTable();
+ assertEquals(st.getType(n1), v1.type());
+ assertEquals(st.getType(n2), v2.type());
+ assertEquals(st.getType(n3), v3.type());
+ // VE
+ // [n1 -> v1, n2 -> v2, n3 -> v3][n1 -> v2, n2 -> v3, n3 -> v1]
+ ve.pushFrame(false);
+ ve.assign(n1, v2);
+ ve.assign(n2, v3);
+ ve.assign(n3, v1);
+ // ST
+ // [n1 -> Type(v2), n2 -> Type(v3), n3 -> Type(v1)]
+ st = ve.constructSymbolTable();
+ assertEquals(st.getType(n1), v2.type());
+ assertEquals(st.getType(n2), v3.type());
+ assertEquals(st.getType(n3), v1.type());
+ }
+
+
+ /**
+ * tests constructVarBindings
+ *
+ * - all mappings in the current frame get copied
+ */
+ @Test
+ public void testConstructVarBindings() {
+ VarBindings vb;
+ // VE
+ // [n1 -> v1, n2 -> v2, n3 -> v3]
+ ve.assign(n1, v1);
+ ve.assign(n2, v2);
+ ve.assign(n3, v3);
+ // VB
+ // [n1 -> v1, n2 -> v2, n3 -> v3]
+ vb = ve.constructVarBindings();
+ assertEquals(vb.getValue(n1), v1);
+ assertEquals(vb.getValue(n2), v2);
+ assertEquals(vb.getValue(n3), v3);
+ // VE
+ // [n1 -> v1, n2 -> v2, n3 -> v3][n1 -> v2, n2 -> v3, n3 -> v1]
+ ve.pushFrame(false);
+ ve.assign(n1, v2);
+ ve.assign(n2, v3);
+ ve.assign(n3, v1);
+ // VB
+ // [n1 -> v2, n2 -> v3, n3 -> v1]
+ vb = ve.constructVarBindings();
+ assertEquals(vb.getValue(n1), v2);
+ assertEquals(vb.getValue(n2), v3);
+ assertEquals(vb.getValue(n3), v1);
+ }
+
+ // TODO lookup, constructVBetc with visible objects
+}
diff --git a/use-core/src/test/java/org/tzi/use/util/soil/VariableSetTest.java b/use-core/src/test/java/org/tzi/use/util/soil/VariableSetTest.java
new file mode 100644
index 000000000..2bafb505f
--- /dev/null
+++ b/use-core/src/test/java/org/tzi/use/util/soil/VariableSetTest.java
@@ -0,0 +1,243 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2010 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.util.soil;
+
+import java.util.Random;
+
+import junit.framework.TestCase;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.tzi.use.uml.ocl.type.Type;
+import org.tzi.use.uml.ocl.type.TypeFactory;
+
+
+/**
+ * Test cases for the special set operations of {@code VariableSet}s
+ *
+ * @author Daniel Gent
+ * @see VariableSet
+ */
+public class VariableSetTest extends TestCase {
+ /** {@code VariableSet} A */
+ private VariableSet fA;
+ /** {@code VariableSet} B */
+ private VariableSet fB;
+
+
+ /**
+ * constructs the fixtures
+ */
+ @Override
+ @Before
+ public void setUp() {
+
+ // fill A and B with some random data
+ Type[] types = {
+ TypeFactory.mkInteger(),
+ TypeFactory.mkReal(),
+ TypeFactory.mkString(),
+ TypeFactory.mkBoolean(),
+ TypeFactory.mkOclAny(),
+ };
+
+ String[] names = {
+ "v00", "v01", "v02", "v03", "v04", "v05", "v06", "v07", "v08",
+ "v09", "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17",
+ "v18", "v19"
+ };
+
+ int numElems = 10;
+ Random random = new Random();
+
+ fA = new VariableSet();
+ for (int i = 0; i < numElems; ++i) {
+ fA.add(
+ // the last 5 names are exclusively in B
+ names[random.nextInt(names.length - 5)],
+ types[random.nextInt(types.length)]);
+ }
+
+ fB = new VariableSet();
+ for (int i = 0; i < numElems; ++i) {
+ fB.add(
+ // the first 5 names are exclusively in A
+ names[5 + random.nextInt(names.length - 5)],
+ types[random.nextInt(types.length)]);
+ }
+
+ // make sure there is an element in one set, which is not in the other
+ fA.add("aExclusive", types[random.nextInt(types.length)]);
+ fB.add("bExclusive", types[random.nextInt(types.length)]);
+
+ // make sure A and B have at least one element in common
+ Type commonType = types[random.nextInt(types.length)];
+ fA.add("common", commonType);
+ fB.add("common", commonType);
+
+ // something to do for polydiff2...
+ Type integerType = TypeFactory.mkInteger();
+ Type realType = TypeFactory.mkReal();
+ // just to make sure...
+ assertTrue(integerType.conformsTo(realType));
+
+ fA.add("aInt_bReal", integerType);
+ fB.add("aInt_bReal", realType);
+
+ fA.add("aReal_bInt", realType);
+ fB.add("aReal_bInt", integerType);
+ }
+
+
+ /**
+ * tests {@link VariableSet#add(VariableSet) Union} respectively
+ * {@link VariableSet#add(VariableSet) add}
+ */
+ @Test
+ public void testUnion() {
+ VariableSet result = VariableSet.union(fA, fB);
+
+ // everything in A must be in the result
+ assertTrue(result.containsAll(fA));
+
+ // everything in B must be in the result
+ assertTrue(result.containsAll(fB));
+
+ // everything in the result must be in either A or B
+ for (String name : result.getNames()) {
+ for (Type type : result.getTypes(name)) {
+ assertTrue(fA.contains(name, type) || fB.contains(name, type));
+ }
+ }
+ }
+
+
+ /**
+ * tests {@link VariableSet#difference(VariableSet, VariableSet) Difference}
+ * respectively {@link VariableSet#add(VariableSet) remove}
+ */
+ @Test
+ public void testDifference() {
+ VariableSet diffAB = VariableSet.difference(fA, fB);
+
+ // everything in the difference must be in A
+ assertTrue(fA.containsAll(diffAB));
+
+ // nothing in B might be in the difference
+ for (String name : fB.getNames()) {
+ for (Type type : fB.getTypes(name)) {
+ assertFalse(diffAB.contains(name, type));
+ }
+ }
+
+ VariableSet diffBA = VariableSet.difference(fB, fA);
+
+ // everything in the difference must be in B
+ assertTrue(fB.containsAll(diffBA));
+
+ // nothing in A might be in the difference
+ for (String name : fA.getNames()) {
+ for (Type type : fA.getTypes(name)) {
+ assertFalse(diffBA.contains(name, type));
+ }
+ }
+ }
+
+
+ /**
+ * tests
+ * {@link VariableSet#polymorphicDifference1(VariableSet, VariableSet)
+ * PolymorphicDifference1}
+ * respectively
+ * {@link VariableSet#removePolymorphic1(VariableSet) removePolymorphic1}
+ */
+ @Test
+ public void testPolymorphicDifference1() {
+ VariableSet pDiff1 = VariableSet.polymorphicDifference1(fA, fB);
+
+ // everything in pDiff1 must be in A
+ assertTrue(fA.containsAll(pDiff1));
+
+ // the normal difference is a subset of the first polymorphic difference
+ // (it removes everything a normal difference would + possibly some more)
+ // we want to take a look everything that gets only removed by the
+ // first polymorphic difference
+
+ VariableSet diff = VariableSet.difference(fA, fB);
+ VariableSet pDiffExcl = VariableSet.difference(diff, pDiff1);
+
+ // for each element in pDiffExcl the following must hold:
+ // - element of vA
+ // - not element of vB
+ // - vB has a variable with that name
+ for (String name : pDiffExcl.getNames()) {
+ for (Type type : pDiffExcl.getTypes(name)) {
+ assertTrue(fA.contains(name, type));
+ assertFalse(fB.contains(name, type));
+ assertTrue(fB.contains(name));
+ }
+ }
+ }
+
+
+ /**
+ * tests
+ * {@link VariableSet#polymorphicDifference2(VariableSet, VariableSet)
+ * PolymorphicDifference2}
+ * respectively
+ * {@link VariableSet#removePolymorphic2(VariableSet) removePolymorphic2}
+ */
+ @Test
+ public void testPolymorphicDifference2() {
+ VariableSet pDiff2 = VariableSet.polymorphicDifference2(fA, fB);
+
+ // everything in pDiff2 must be in A
+ assertTrue(fA.containsAll(pDiff2));
+
+ // the normal difference is a subset of the second polymorphic difference
+ // (it removes everything a normal difference would + possibly some more)
+ // we want to take a look everything that gets only removed by the
+ // second polymorphic difference
+
+ VariableSet diff = VariableSet.difference(fA, fB);
+ VariableSet pDiffExcl = VariableSet.difference(diff, pDiff2);
+
+ // for each element in pDiffExcl the following must hold:
+ // - element of A
+ // - not element of B
+ // - B has a variable with that name
+ // - one of its types must be a subtype of the current elements type
+ for (String name : pDiffExcl.getNames()) {
+ for (Type type : pDiffExcl.getTypes(name)) {
+ assertTrue(fA.contains(name, type));
+ assertFalse(fB.contains(name, type));
+ assertTrue(fB.contains(name));
+ boolean containsSubType = false;
+ for (Type otherType : fB.getTypes(name)) {
+ if (otherType.conformsTo(type)) {
+ containsSubType = true;
+ break;
+ }
+ }
+ assertTrue(containsSubType);
+ }
+ }
+ }
+}
diff --git a/use-gui/src/it/java/org/tzi/use/main/ShellIT.java b/use-gui/src/it/java/org/tzi/use/main/ShellIT.java
new file mode 100644
index 000000000..df4992dde
--- /dev/null
+++ b/use-gui/src/it/java/org/tzi/use/main/ShellIT.java
@@ -0,0 +1,304 @@
+package org.tzi.use.main;
+
+import com.github.difflib.text.DiffRow;
+import com.github.difflib.text.DiffRowGenerator;
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.TestFactory;
+import org.tzi.use.config.Options;
+import org.tzi.use.util.USEWriter;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * This class implements the shell integration tests.
+ *
+ *
These tests represent nearly the exact behavior of the
+ * USE shell. Only some whitespace differences and time outputs are ignored.
+ *
+ * Each test consists of the following files:
+ *
+ * - a model file (suffix {@code .use}) - this file provides the (possible empty) model used
+ * for the tests
+ * - an input file (suffix: {@code .in}) - this file can contain any commands USE supports.
+ * The expected output must be specified by starting a line with a star {@code *}
+ * - any other used file from the command line, e.g., ASSL- or command-files.
+ *
+ *
+ * All {@code .use and .in} files must share the same name, e.g., t555.use and t555.in for test
+ * case 555. These files must be placed in the folder {@code it/resources/testfiles/shell}.
+ *
+ * If an integration test fails, two additional files are created:
+ *
+ * - {@code {testcasename}.expected - The expected output calculated from the
{testcase}.in}-file
+ * - {@code {testcasename}.actual} - The output captured while running the test.
+ *
+ * These files can be used to easily diff expected and current output.
+ */
+public class ShellIT {
+
+ /**
+ * This TestFactory enumerates the {@code .in-files in th folder testfiles/shell}.
+ * For each file a {@code DynamicTest} is created with the name of the file.
+ *
+ * @return A {@code Stream with one DynamicTest for each *.in}-file.
+ */
+ @TestFactory
+ public Stream evaluateExpressionFiles() {
+ URL testDirURL = getClass().getClassLoader().getResource("testfiles/shell");
+ Path testDirPath = null;
+
+ if (testDirURL == null) {
+ fail("Directory for shell integration tests not found!");
+ }
+
+ try {
+ testDirPath = Path.of(testDirURL.toURI());
+ } catch (URISyntaxException e) {
+ fail("Directory for shell integration tests not found!");
+ }
+
+ try {
+ return Files.walk(testDirPath).filter(
+ path -> path.getFileName().toString().endsWith(".in")
+ ).map(mapInFileToTest());
+ } catch (IOException e) {
+ fail("Error iterating shell integration test input files!");
+ }
+
+ return Stream.empty();
+ }
+
+ /**
+ * This {@code Function} is used to map
+ * a given testinput-file given as a {@code Path}
+ * to a {@code DynamicTest}.
+ *
+ * @return A {@code DynamicTest that uses the function assertShellExpression}
+ * to test the given testinput file.
+ */
+ private Function mapInFileToTest() {
+ return path -> {
+ final String modelFilename = path.getFileName().toString().replace(".in", ".use");
+ final Path modelPath = path.resolveSibling(modelFilename);
+
+ return DynamicTest.dynamicTest(path.getFileName().toString(), path.toUri(), () -> assertShellExpressions(path, modelPath));
+ };
+ }
+
+ /**
+ * This function controls the overall process for test for a single testfile.
+ *
+ * The process is as follows:
+ *
+ * - a command file and the expected output are created by examining the input file (via {@code createCommandFile}.
+ * - USE is executed using the {@code useFile
and the created command file (runUSE}).
+ * The output of USE is compared to the expected output created in 1. ({@code validateOutput}).
+ *
+ *
+ * @param testFile {@code Path} to the test input file to execute.
+ * @param useFile {@code Path} to the USE file containing the model to load for the test.
+ */
+ private void assertShellExpressions(Path testFile, Path useFile) {
+
+ Path cmdFile = testFile.resolveSibling(testFile.getFileName() + ".cmd");
+
+ List expectedOutput = createCommandFile(testFile, cmdFile);
+
+ List actualOutput = runUSE(useFile, cmdFile).collect(Collectors.toList());
+
+ validateOutput(testFile, expectedOutput, actualOutput);
+ }
+
+ /**
+ * Compares the two lists of strings {@code expectedOutput}
+ * and {@code actualOutput}.
+ * If they differ, two files are written at the location of the
+ * {@code testFile. One with the expected output (.expected})
+ * and one with the actual output ({@code .actual}).
+ *
+ * @param testFile The {@code Path to the testFile}
+ * @param expectedOutput List of strings with the expected output (one String per line)
+ * @param actualOutput List of strings with the actual output (one String per line)
+ */
+ private void validateOutput(Path testFile, List expectedOutput, List actualOutput) {
+ //create a configured DiffRowGenerator
+ DiffRowGenerator generator = DiffRowGenerator.create()
+ .showInlineDiffs(true)
+ .mergeOriginalRevised(true)
+ .inlineDiffByWord(true)
+ .ignoreWhiteSpaces(true)
+ .lineNormalizer( (s) -> s ) // No normalization required
+ .oldTag((f, start) -> start ? "-\033[9m" : "\033[m-") //introduce markdown style for strikethrough
+ .newTag((f, start) -> start ? "+\033[97;42m" : "\033[m+") //introduce markdown style for bold
+ .build();
+
+ //compute the differences for two test texts.
+ List rows = generator.generateDiffRows(expectedOutput, actualOutput);
+ Predicate filter = d -> d.getTag() != DiffRow.Tag.EQUAL;
+
+ if (rows.stream().anyMatch(filter)) {
+ StringBuilder diffMsg = new StringBuilder("USE output does not match expected output!").append(System.lineSeparator());
+
+ diffMsg.append("Testfile: ").append(testFile).append(System.lineSeparator());
+
+ diffMsg.append(System.lineSeparator()).append("Note: the position is not the position in the input file!");
+ diffMsg.append(System.lineSeparator()).append(System.lineSeparator());
+
+ rows.stream().filter(filter).forEach(
+ row ->diffMsg.append(System.lineSeparator()).append(row.getOldLine())
+ );
+
+ writeToFile(expectedOutput, testFile.getParent().resolve(testFile.getFileName().toString() + ".expected"));
+ writeToFile(actualOutput, testFile.getParent().resolve(testFile.getFileName().toString() + ".actual"));
+
+ fail(diffMsg.toString());
+ }
+ }
+
+ /**
+ * Helper method that writes the list of strings {@code data}
+ * to the file located by the {@code Path} {@code file}.
+ *
+ * If the file is not accessible, i.e., an IOException is thrown,
+ * the exceptions is caught and the test case fails.
+ * @param data The {@code List} of string (lines) to write.
+ * @param file The path to the file to write (file is overwritten).
+ */
+ private void writeToFile(List data, Path file) {
+ try (FileWriter writer = new FileWriter(file.toFile())) {
+
+ for (String line : data) {
+ writer.write(line);
+ writer.write(System.lineSeparator());
+ }
+ } catch (IOException e) {
+ fail("Testoutput could not be written!", e);
+ }
+ }
+
+ /**
+ * Creates a USE-command file at the position located by the path {@code cmdFile}.
+ * The file contains all commands that are specified in the {@code inFile}.
+ * The expected output, i.e., lines starting with a {@code *} are added to the list {@code expectedOutput}.
+ *
+ * @param inFile The {@code Path} to the test input file.
+ * @param cmdFile The {@code Path} where to create the command file.
+ * @return A {@code List} which is filled with the expected output of USE.
+ */
+ private List createCommandFile(Path inFile, Path cmdFile) {
+ List expectedOutput = new LinkedList<>();
+
+ // Build USE command file and build expected output
+ try (
+ Stream linesStream = Files.lines(inFile, StandardCharsets.UTF_8);
+ FileWriter cmdWriter = new FileWriter(cmdFile.toFile(), StandardCharsets.UTF_8, false)
+ ) {
+
+ linesStream.forEach(inputLine -> {
+
+ // Ignore empty lines in expected, since they are also suppressed in actual output
+ if (inputLine.isBlank())
+ return;
+
+ if ((inputLine.startsWith("*") || inputLine.startsWith("#"))
+ && inputLine.substring(1).isBlank()) {
+ return;
+ }
+
+ if (inputLine.startsWith("*")) {
+ // Input line minus prefix(*) is expected output
+ expectedOutput.add(inputLine.substring(1).trim());
+ } else if (!inputLine.startsWith("#")) { // Not a comment
+ try {
+ cmdWriter.write(inputLine);
+ cmdWriter.write(System.lineSeparator());
+
+ // Multi line commands (backslash and dot) are ignored
+ if (!inputLine.matches("^[\\\\.]$")) {
+ expectedOutput.add(inputLine);
+ }
+ } catch (IOException e1) {
+ fail("Could not write USE command file for test!", e1);
+ }
+ }
+ });
+ } catch (IOException e) {
+ fail("Could not write USE command file for test!", e);
+ }
+
+ return expectedOutput;
+ }
+
+ /**
+ * Executes USE with the given {@code useFile} as the model
+ * and the {@code cmdFile} to execute commands.
+ * The output is captured from the output and error streams.
+ *
+ * @param useFile Path to the USE model to load on startup
+ * @param cmdFile Path to the commands file to execute
+ * @return A {@code List} of strings. Each string is one line of output.
+ */
+ private Stream runUSE(Path useFile, Path cmdFile) {
+
+ // We need to specify a concrete locale to always get the same formatted result
+ Locale.setDefault(new Locale("en", "US"));
+
+ Options.resetOptions();
+ USEWriter.getInstance().clearLog();
+
+ String homeDir = null;
+ try {
+ homeDir = useFile.getParent().resolve("../../../../../use-core/target/classes").toFile().getCanonicalPath();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+
+ String[] args = new String[] {
+ "-nogui",
+ "-nr",
+ "-t",
+ "-it",
+ "-q",
+ "-oclAnyCollectionsChecks:E",
+ "-extendedTypeSystemChecks:E",
+ /* This is currently an unstable workaround
+ USE determines the plugin and the extensions to OCL by fixed paths.
+ For now, the use-core module contains the directories including the extensions
+ and an empty plugins folder.
+ The folder is located: use/use-core/target/classes
+ Therefore, this is used as the USE home
+ */
+ "-H=" + homeDir,
+ useFile.toString(),
+ cmdFile.toString()};
+
+ Main.main(args);
+
+ try (ByteArrayOutputStream protocol = new ByteArrayOutputStream();) {
+ USEWriter.getInstance().writeProtocolFile(protocol);
+ String output = protocol.toString();
+ return output.lines().filter(l -> !l.isBlank());
+ } catch (IOException e) {
+ fail(e);
+ }
+
+ return Collections.emptyList().stream();
+ }
+}
diff --git a/use-gui/src/main/java/org/tzi/use/main/Main.java b/use-gui/src/main/java/org/tzi/use/main/Main.java
new file mode 100644
index 000000000..5a70ef8ad
--- /dev/null
+++ b/use-gui/src/main/java/org/tzi/use/main/Main.java
@@ -0,0 +1,259 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2004 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.main;
+
+import org.tzi.use.config.Options;
+import org.tzi.use.gui.main.MainWindow;
+import org.tzi.use.main.runtime.IRuntime;
+import org.tzi.use.main.shell.Shell;
+import org.tzi.use.parser.use.USECompiler;
+import org.tzi.use.uml.mm.MMPrintVisitor;
+import org.tzi.use.uml.mm.MMVisitor;
+import org.tzi.use.uml.mm.MModel;
+import org.tzi.use.uml.mm.ModelFactory;
+import org.tzi.use.uml.ocl.extension.ExtensionManager;
+import org.tzi.use.uml.sys.MSystem;
+import org.tzi.use.util.Log;
+import org.tzi.use.util.USEWriter;
+
+import javax.swing.*;
+import javax.swing.plaf.FontUIResource;
+import javax.swing.plaf.metal.DefaultMetalTheme;
+import javax.swing.plaf.metal.MetalLookAndFeel;
+import java.awt.*;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.lang.reflect.Method;
+import java.nio.file.Path;
+
+/**
+ * Main class.
+ *
+ * @author Mark Richters
+ */
+public final class Main {
+
+ // utility class
+ private Main() {
+ }
+
+ private static void initGUIdefaults() {
+ MetalLookAndFeel.setCurrentTheme(new MyTheme());
+ }
+
+ public static void main(String[] args) {
+ // set System.out to the OldUSEWriter to protocol the output.
+ System.setOut(USEWriter.getInstance().getOut());
+ // set System.err to the OldUSEWriter to protocol the output.
+ System.setErr(USEWriter.getInstance().getErr());
+
+ // read and set global options, setup application properties
+ Options.processArgs(args);
+ if (Options.doGUI) {
+ initGUIdefaults();
+ }
+
+ Session session = new Session();
+ IRuntime pluginRuntime = null;
+ MModel model = null;
+ MSystem system = null;
+
+ if (!Options.disableExtensions) {
+ ExtensionManager.EXTENSIONS_FOLDER = Options.homeDir + Options.FILE_SEPARATOR +
+ "oclextensions";
+ ExtensionManager.getInstance().loadExtensions();
+ }
+
+ // Plugin Framework
+ if (Options.doPLUGIN) {
+ // create URL from plugin directory
+ Path pluginDirURL = Options.pluginDir;
+ Log.verbose("Plugin path: [" + pluginDirURL + "]");
+ Class mainPluginRuntimeClass = null;
+ try {
+ mainPluginRuntimeClass = Class
+ .forName("org.tzi.use.runtime.MainPluginRuntime");
+ } catch (ClassNotFoundException e) {
+ Log
+ .error("Could not load PluginRuntime. Probably use-runtime-...jar is missing.\n"
+ + "Try starting use with -noplugins switch.\n"
+ + e.getMessage());
+ System.exit(1);
+ }
+ try {
+ Method run = mainPluginRuntimeClass.getMethod("run",
+ new Class[] { Path.class });
+ pluginRuntime = (IRuntime) run.invoke(null,
+ new Object[] { pluginDirURL });
+ Log.debug("Starting plugin runtime, got class ["
+ + pluginRuntime.getClass() + "]");
+ } catch (Exception e) {
+ e.printStackTrace();
+ Log.error("FATAL ERROR.");
+ System.exit(1);
+ }
+ }
+
+ // compile spec if filename given as argument
+ if (Options.specFilename != null) {
+ Path file = Path.of(Options.specFilename);
+
+ try (FileInputStream specStream = new FileInputStream(Options.specFilename)){
+ Log.verbose("compiling specification...");
+ model = USECompiler.compileSpecification(specStream,
+ file.getFileName().toString(), new PrintWriter(System.err),
+ new ModelFactory());
+ } catch (FileNotFoundException e) {
+ Log.error("File `" + Options.specFilename + "' not found.");
+ if (Options.integrationTestMode) {
+ return;
+ } else {
+ System.exit(1);
+ }
+ } catch (IOException e1) {
+ // close failed
+ }
+
+ // compile errors?
+ if (model == null) {
+ if (Options.integrationTestMode) {
+ return;
+ } else {
+ System.exit(1);
+ }
+ }
+
+ if(!Options.quiet){
+ Options.setLastDirectory(new java.io.File(Options.specFilename).getAbsoluteFile().toPath().getParent());
+ }
+ if (!Options.testMode)
+ Options.getRecentFiles().push(Options.specFilename);
+
+ if (Options.compileOnly) {
+ Log.verbose("no errors.");
+ if (Options.compileAndPrint) {
+ MMVisitor v = new MMPrintVisitor(new PrintWriter(
+ System.out, true));
+ model.processWithVisitor(v);
+ }
+ System.exit(0);
+ }
+
+ // print some info about model
+ Log.verbose(model.getStats());
+
+ // create system
+ system = new MSystem(model);
+ }
+ session.setSystem(system);
+
+ if (Options.doGUI) {
+ if (pluginRuntime == null) {
+ Log.debug("Starting gui without plugin runtime!");
+ MainWindow.create(session);
+ } else {
+ Log.debug("Starting gui with plugin runtime.");
+ MainWindow.create(session, pluginRuntime);
+ }
+ }
+
+ // create thread for shell
+ Shell.createInstance(session, pluginRuntime);
+ Shell sh = Shell.getInstance();
+ Thread t = new Thread(sh);
+ t.start();
+
+ // wait on exit from shell (this thread never returns)
+ try {
+ t.join();
+ } catch (InterruptedException ex) {
+ // ignored
+ }
+ }
+}
+
+/**
+ * A theme with full control over fonts and customized tree display.
+ */
+class MyTheme extends DefaultMetalTheme {
+ private FontUIResource controlFont;
+
+ private FontUIResource systemFont;
+
+ private FontUIResource userFont;
+
+ private FontUIResource smallFont;
+
+ MyTheme() {
+ // System.out.println("font: " + Font.getFont("use.gui.controlFont"));
+ controlFont = new FontUIResource(Font.getFont("use.gui.controlFont",
+ super.getControlTextFont()));
+ systemFont = new FontUIResource(Font.getFont("use.gui.systemFont",
+ super.getSystemTextFont()));
+ userFont = new FontUIResource(Font.getFont("use.gui.userFont", super
+ .getUserTextFont()));
+ smallFont = new FontUIResource(Font.getFont("use.gui.smallFont", super
+ .getSubTextFont()));
+ }
+
+ public String getName() {
+ return "USE";
+ }
+
+ public FontUIResource getControlTextFont() {
+ return controlFont;
+ }
+
+ public FontUIResource getSystemTextFont() {
+ return systemFont;
+ }
+
+ public FontUIResource getUserTextFont() {
+ return userFont;
+ }
+
+ public FontUIResource getMenuTextFont() {
+ return controlFont;
+ }
+
+ public FontUIResource getWindowTitleFont() {
+ return controlFont;
+ }
+
+ public FontUIResource getSubTextFont() {
+ return smallFont;
+ }
+
+ public void addCustomEntriesToTable(UIDefaults table) {
+ initIcon(table, "Tree.expandedIcon", "TreeExpanded.gif");
+ initIcon(table, "Tree.collapsedIcon", "TreeCollapsed.gif");
+ initIcon(table, "Tree.leafIcon", "TreeLeaf.gif");
+ initIcon(table, "Tree.openIcon", "TreeOpen.gif");
+ initIcon(table, "Tree.closedIcon", "TreeClosed.gif");
+ table.put("Desktop.background", table.get("Menu.background"));
+ }
+
+ private void initIcon(UIDefaults table, String property, String iconFilename) {
+ table.put(property, new ImageIcon(getClass().getResource("/images/" + iconFilename)));
+ }
+
+}
diff --git a/use-gui/src/main/java/org/tzi/use/util/input/ShellReadline.java b/use-gui/src/main/java/org/tzi/use/util/input/ShellReadline.java
new file mode 100644
index 000000000..03c17e035
--- /dev/null
+++ b/use-gui/src/main/java/org/tzi/use/util/input/ShellReadline.java
@@ -0,0 +1,71 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2010 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.util.input;
+
+import java.io.IOException;
+
+import org.tzi.use.main.shell.Shell;
+
+/**
+ * A {@link Readline} implementation that reads input from the {@link Shell}
+ * using the current readline that is on top of the readline stack. This might
+ * either be interactive or from an open soil file.
+ *
+ * @author Frank Hilken
+ */
+public class ShellReadline implements Readline {
+
+ private Shell shell;
+
+ public ShellReadline(Shell useShell) {
+ shell = useShell;
+ }
+
+ @Override
+ public String readline(String prompt) throws IOException {
+ if(shell == null){
+ throw new IOException("Stream closed");
+ }
+ return shell.readline(prompt);
+ }
+
+ @Override
+ public void usingHistory() {
+ }
+
+ @Override
+ public void readHistory(String filename) throws IOException {
+ }
+
+ @Override
+ public void writeHistory(String filename) throws IOException {
+ }
+
+ @Override
+ public void close() throws IOException {
+ shell = null;
+ }
+
+ @Override
+ public boolean doEcho() {
+ return false;
+ }
+
+}
diff --git a/use-gui/src/main/resources/images/use1.gif b/use-gui/src/main/resources/images/use1.gif
new file mode 100644
index 000000000..1b947ed71
Binary files /dev/null and b/use-gui/src/main/resources/images/use1.gif differ
diff --git a/use-gui/src/test/java/org/tzi/use/util/DiagramUtilTest.java b/use-gui/src/test/java/org/tzi/use/util/DiagramUtilTest.java
new file mode 100644
index 000000000..d84d8fe02
--- /dev/null
+++ b/use-gui/src/test/java/org/tzi/use/util/DiagramUtilTest.java
@@ -0,0 +1,130 @@
+/*
+ * USE - UML based specification environment
+ * Copyright (C) 1999-2010 Mark Richters, University of Bremen
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+package org.tzi.use.util;
+
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Line2D;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+import junit.framework.TestCase;
+
+import org.junit.Test;
+import org.tzi.use.gui.views.diagrams.util.Util;
+
+/**
+ * Test for diagram utilities (mainly geometry)
+ * @author Lars Hamann
+ *
+ */
+public class DiagramUtilTest extends TestCase {
+ @Test
+ public void testCircleIntersection() {
+ Ellipse2D circle = new Ellipse2D.Double(-4, -4, 8, 8);
+ Point2D res;
+ Point2D.Double expected = new Point2D.Double();
+
+ expected.x = 4;
+ expected.y = 0;
+ res = Util.intersectionPoint(circle, new Point2D.Double(4, 0));
+ assertEquals(expected, res);
+
+ expected.x = 0;
+ expected.y = 4;
+ res = Util.intersectionPoint(circle, new Point2D.Double(0, 4));
+ assertEquals(expected, res);
+
+ expected.x = -4;
+ expected.y = 0;
+ res = Util.intersectionPoint(circle, new Point2D.Double(-4, 0));
+ assertEquals(expected, res);
+
+ expected.x = 0;
+ expected.y = -4;
+ res = Util.intersectionPoint(circle, new Point2D.Double(0, -4));
+ assertEquals(expected, res);
+
+ res = Util.intersectionPoint(circle, new Point2D.Double(1.5, -2.5));
+ Point2D res2 = Util.intersectionPoint(circle, res);
+ assertEquals(res, res2);
+ }
+
+ public void testRectangleInterception() {
+ Rectangle2D.Double r = new Rectangle2D.Double();
+ r.x = 0;
+ r.y = 0;
+ r.width = 1;
+ r.height = 1;
+
+ Line2D.Double l = new Line2D.Double();
+ l.x1 = 0.5;
+ l.y1 = 0.5;
+
+ l.x2 = 1.5;
+ l.y2 = 0.5;
+
+ Point2D res = Util.intersectionPoint(r, l.getP1(), l.getP2(), true);
+ assertEquals(1.0, res.getX());
+ assertEquals(0.5, res.getY());
+
+ l.x2 = 0.5;
+ l.y2 = 1.5;
+ res = Util.intersectionPoint(r, l.getP1(), l.getP2(), true);
+ assertEquals(0.5, res.getX());
+ assertEquals(1.0, res.getY());
+
+ l.x2 = -0.5;
+ l.y2 = 0.5;
+ res = Util.intersectionPoint(r, l.getP1(), l.getP2(), true);
+ assertEquals(0.0, res.getX());
+ assertEquals(50, Math.round(res.getY() * 100));
+
+ l.x2 = 0.5;
+ l.y2 = -1.5;
+ res = Util.intersectionPoint(r, l.getP1(), l.getP2(), true);
+ assertEquals(0.5, res.getX());
+ assertEquals(0.0, res.getY() * 100);
+
+ // Test enlarge
+ l.x2 = 0.6;
+ l.y2 = 0.5;
+ res = Util.intersectionPoint(r, l.getP1(), l.getP2(), true);
+ assertEquals(1.0, res.getX());
+ assertEquals(0.5, res.getY());
+
+ l.x2 = 0.5;
+ l.y2 = 0.6;
+ res = Util.intersectionPoint(r, l.getP1(), l.getP2(), true);
+ assertEquals(0.5, res.getX());
+ assertEquals(1.0, res.getY());
+
+ l.x2 = 0.4;
+ l.y2 = 0.5;
+ res = Util.intersectionPoint(r, l.getP1(), l.getP2(), true);
+ assertEquals(0.0, res.getX());
+ assertEquals(50, Math.round(res.getY() * 100));
+
+ l.x2 = 0.5;
+ l.y2 = 0.4;
+ res = Util.intersectionPoint(r, l.getP1(), l.getP2(), true);
+ assertEquals(0.5, res.getX());
+ assertEquals(0.0, res.getY() * 100);
+ }
+}