kinetics comparators

commons/src/main/java/lcsb/mapviewer/common/comparator/EnumComparator.java

+package lcsb.mapviewer.common.comparator;
+
+import java.awt.Color;
+import java.util.Comparator;
+
+/**
+ * Comparator implementation for {@link Color} class.
+ * 
+ * @author Piotr Gawron
+ * 
+ */
+public class EnumComparator implements Comparator<Enum<?>> {
+
+	@Override
+	public int compare(Enum arg0, Enum arg1) {
+		if (arg0 == null) {
+			if (arg1 == null) {
+				return 0;
+			} else {
+				return 1;
+			}
+
+		} else if (arg1 == null) {
+			return -1;
+		}
+		return arg0.compareTo(arg1);
+	}
+
+}

commons/src/test/java/lcsb/mapviewer/common/comparator/AllComparatorTests.java

@@ -8,6 +8,7 @@ import org.junit.runners.Suite.SuiteClasses;
 @SuiteClasses({ BooleanComparatorTest.class, //
     ColorComparatorTest.class, //
     DoubleComparatorTest.class, //
+    EnumComparatorTest.class, //
     IntegerComparatorTest.class, //
     PointComparatorTest.class, //
     StringComparatorTest.class, //

commons/src/test/java/lcsb/mapviewer/common/comparator/EnumComparatorTest.java

+package lcsb.mapviewer.common.comparator;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import lcsb.mapviewer.common.MimeType;
+
+public class EnumComparatorTest {
+
+  @Test
+  public void testEquals() {
+    EnumComparator comp = new EnumComparator();
+    assertEquals(0, comp.compare(MimeType.CSS, MimeType.CSS));
+  }
+
+  @Test
+  public void testDifferent() {
+    EnumComparator comp = new EnumComparator();
+    assertTrue(0 != comp.compare(MimeType.CSS, MimeType.JPG));
+  }
+
+}

model/src/main/java/lcsb/mapviewer/model/map/kinetics/SbmlFunction.java

@@ -52,7 +52,7 @@ public class SbmlFunction implements Serializable, SbmlArgument {
   private String functionId;
 
   private String name;
-  
+
   @Column(columnDefinition = "TEXT")
   private String definition;
 
@@ -105,5 +105,8 @@ public class SbmlFunction implements Serializable, SbmlArgument {
     this.definition = definition;
   }
 
+  public void addArgument(String argument) {
+    arguments.add(argument);
+  }
 
 }

model/src/main/java/lcsb/mapviewer/model/map/kinetics/SbmlFunctionComparator.java

+package lcsb.mapviewer.model.map.kinetics;
+
+import lcsb.mapviewer.common.Comparator;
+import lcsb.mapviewer.common.comparator.StringComparator;
+import lcsb.mapviewer.common.comparator.StringListComparator;
+
+public class SbmlFunctionComparator extends Comparator<SbmlFunction> {
+
+  protected SbmlFunctionComparator() {
+    super(SbmlFunction.class);
+  }
+
+  @Override
+  protected int internalCompare(SbmlFunction arg0, SbmlFunction arg1) {
+    StringComparator stringComparator = new StringComparator();
+    StringListComparator stringListComparator = new StringListComparator();
+    if (stringComparator.compare(arg0.getFunctionId(), arg1.getFunctionId()) != 0) {
+      return stringComparator.compare(arg0.getFunctionId(), arg1.getFunctionId());
+    }
+    if (stringComparator.compare(arg0.getName(), arg1.getName()) != 0) {
+      return stringComparator.compare(arg0.getName(), arg1.getName());
+    }
+
+    if (stringComparator.compare(arg0.getDefinition(), arg1.getDefinition()) != 0) {
+      return stringComparator.compare(arg0.getDefinition(), arg1.getDefinition());
+    }
+
+    if (stringListComparator.compare(arg0.getArguments(), arg1.getArguments()) != 0) {
+      return stringListComparator.compare(arg0.getArguments(), arg1.getArguments());
+    }
+
+    return 0;
+  }
+
+}

model/src/main/java/lcsb/mapviewer/model/map/kinetics/SbmlKinetics.java

@@ -4,7 +4,6 @@ import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 import javax.persistence.Column;
@@ -53,7 +52,7 @@ public class SbmlKinetics implements Serializable {
   @OneToMany(mappedBy = "model", orphanRemoval = true)
   private Set<SbmlFunction> functions = new HashSet<>();
 
-  private List<Element> elements = new ArrayList<>();
+  private Set<Element> elements = new HashSet<>();
 
   /**
    * Unique database identifier.
@@ -142,4 +141,8 @@ public class SbmlKinetics implements Serializable {
     return functions;
   }
 
+  public Set<Element> getElements() {
+    return elements;
+  }
+
 }

model/src/main/java/lcsb/mapviewer/model/map/kinetics/SbmlKineticsComparator.java

 package lcsb.mapviewer.model.map.kinetics;
 
 import lcsb.mapviewer.common.Comparator;
+import lcsb.mapviewer.common.comparator.SetComparator;
+import lcsb.mapviewer.common.comparator.StringComparator;
+import lcsb.mapviewer.model.map.species.Element;
+import lcsb.mapviewer.model.map.species.ElementComparator;
 
 public class SbmlKineticsComparator extends Comparator<SbmlKinetics> {
 
@@ -10,6 +14,22 @@ public class SbmlKineticsComparator extends Comparator<SbmlKinetics> {
 
   @Override
   protected int internalCompare(SbmlKinetics arg0, SbmlKinetics arg1) {
+    SetComparator<SbmlFunction> functionComparator = new SetComparator<>(new SbmlFunctionComparator());
+    if (functionComparator.compare(arg0.getFunctions(), arg1.getFunctions()) != 0) {
+      return functionComparator.compare(arg0.getFunctions(), arg1.getFunctions());
+    }
+    SetComparator<SbmlParameter> parameterComparator = new SetComparator<>(new SbmlParameterComparator());
+    if (parameterComparator.compare(arg0.getParameters(), arg1.getParameters()) != 0) {
+      return parameterComparator.compare(arg0.getParameters(), arg1.getParameters());
+    }
+    SetComparator<Element> elementComparator = new SetComparator<>(new ElementComparator());
+    if (elementComparator.compare(arg0.getElements(), arg1.getElements()) != 0) {
+      return elementComparator.compare(arg0.getElements(), arg1.getElements());
+    }
+    StringComparator stringComparator = new StringComparator();
+    if (stringComparator.compare(arg0.getDefinition(), arg1.getDefinition()) != 0) {
+      return stringComparator.compare(arg0.getDefinition(), arg1.getDefinition());
+    }
     return 0;
   }
 

model/src/main/java/lcsb/mapviewer/model/map/kinetics/SbmlParameter.java

@@ -61,10 +61,6 @@ public class SbmlParameter implements Serializable, SbmlArgument {
     this.parameterId = parameterId;
   }
 
-  public void setFunctionId(String parameterId) {
-    this.parameterId = parameterId;
-  }
-
   public String getName() {
     return name;
   }

model/src/main/java/lcsb/mapviewer/model/map/kinetics/SbmlParameterComparator.java

+package lcsb.mapviewer.model.map.kinetics;
+
+import lcsb.mapviewer.common.Comparator;
+import lcsb.mapviewer.common.comparator.DoubleComparator;
+import lcsb.mapviewer.common.comparator.StringComparator;
+
+public class SbmlParameterComparator extends Comparator<SbmlParameter> {
+
+  protected SbmlParameterComparator() {
+    super(SbmlParameter.class);
+  }
+
+  @Override
+  protected int internalCompare(SbmlParameter arg0, SbmlParameter arg1) {
+    StringComparator stringComparator = new StringComparator();
+    DoubleComparator doubleComparator = new DoubleComparator();
+    SbmlUnitComparator unitComparator = new SbmlUnitComparator();
+    if (stringComparator.compare(arg0.getParameterId(), arg1.getParameterId()) != 0) {
+      return stringComparator.compare(arg0.getParameterId(), arg1.getParameterId());
+    }
+    if (stringComparator.compare(arg0.getName(), arg1.getName()) != 0) {
+      return stringComparator.compare(arg0.getName(), arg1.getName());
+    }
+
+    if (doubleComparator.compare(arg0.getValue(), arg1.getValue()) != 0) {
+      return doubleComparator.compare(arg0.getValue(), arg1.getValue());
+    }
+
+    if (unitComparator.compare(arg0.getUnits(), arg1.getUnits()) != 0) {
+      return unitComparator.compare(arg0.getUnits(), arg1.getUnits());
+    }
+
+    return 0;
+  }
+
+}

model/src/main/java/lcsb/mapviewer/model/map/kinetics/SbmlUnit.java

 package lcsb.mapviewer.model.map.kinetics;
 
 import java.io.Serializable;
-import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 import javax.persistence.Column;
 import javax.persistence.Entity;
@@ -48,7 +49,7 @@ public class SbmlUnit implements Serializable {
   private String unitId;
   private String name;
 
-  private List<SbmlUnitTypeFactor> unitTypeFactors = new ArrayList<>();
+  private Set<SbmlUnitTypeFactor> unitTypeFactors = new HashSet<>();
 
   /**
    * Constructor required by hibernate.
@@ -81,7 +82,7 @@ public class SbmlUnit implements Serializable {
     unitTypeFactors.add(factor);
   }
 
-  public List<SbmlUnitTypeFactor> getUnitTypeFactors() {
+  public Set<SbmlUnitTypeFactor> getUnitTypeFactors() {
     return unitTypeFactors;
   }
 

model/src/main/java/lcsb/mapviewer/model/map/kinetics/SbmlUnitComparator.java

+package lcsb.mapviewer.model.map.kinetics;
+
+import lcsb.mapviewer.common.Comparator;
+import lcsb.mapviewer.common.comparator.SetComparator;
+import lcsb.mapviewer.common.comparator.StringComparator;
+
+public class SbmlUnitComparator extends Comparator<SbmlUnit> {
+
+  protected SbmlUnitComparator() {
+    super(SbmlUnit.class);
+  }
+
+  @Override
+  protected int internalCompare(SbmlUnit arg0, SbmlUnit arg1) {
+    StringComparator stringComparator = new StringComparator();
+    SetComparator<SbmlUnitTypeFactor> unitTypeFactorComparator = new SetComparator<>(
+        new SbmlUnitTypeFactorComparator());
+    if (stringComparator.compare(arg0.getUnitId(), arg1.getUnitId()) != 0) {
+      return stringComparator.compare(arg0.getUnitId(), arg1.getUnitId());
+    }
+    if (stringComparator.compare(arg0.getName(), arg1.getName()) != 0) {
+      return stringComparator.compare(arg0.getName(), arg1.getName());
+    }
+
+    if (unitTypeFactorComparator.compare(arg0.getUnitTypeFactors(), arg1.getUnitTypeFactors()) != 0) {
+      return unitTypeFactorComparator.compare(arg0.getUnitTypeFactors(), arg1.getUnitTypeFactors());
+    }
+    //
+    // if (stringListComparator.compare(arg0.getArguments(), arg1.getArguments()) !=
+    // 0) {
+    // return stringListComparator.compare(arg0.getArguments(),
+    // arg1.getArguments());
+    // }
+
+    return 0;
+  }
+
+}

model/src/main/java/lcsb/mapviewer/model/map/kinetics/SbmlUnitTypeFactorComparator.java

+package lcsb.mapviewer.model.map.kinetics;
+
+import lcsb.mapviewer.common.Comparator;
+import lcsb.mapviewer.common.comparator.DoubleComparator;
+import lcsb.mapviewer.common.comparator.EnumComparator;
+import lcsb.mapviewer.common.comparator.IntegerComparator;
+
+public class SbmlUnitTypeFactorComparator extends Comparator<SbmlUnitTypeFactor> {
+
+  protected SbmlUnitTypeFactorComparator() {
+    super(SbmlUnitTypeFactor.class);
+  }
+
+  @Override
+  protected int internalCompare(SbmlUnitTypeFactor arg0, SbmlUnitTypeFactor arg1) {
+    IntegerComparator integerComparator = new IntegerComparator();
+    DoubleComparator doubleComparator = new DoubleComparator();
+    EnumComparator enumComparator = new EnumComparator();
+    if (integerComparator.compare(arg0.getExponent(), arg1.getExponent()) != 0) {
+      return integerComparator.compare(arg0.getExponent(), arg1.getExponent());
+    }
+    if (integerComparator.compare(arg0.getScale(), arg1.getScale()) != 0) {
+      return integerComparator.compare(arg0.getScale(), arg1.getScale());
+    }
+
+    if (doubleComparator.compare(arg0.getMultiplier(), arg1.getMultiplier()) != 0) {
+      return doubleComparator.compare(arg0.getMultiplier(), arg1.getMultiplier());
+    }
+
+    if (enumComparator.compare(arg0.getUnitType(), arg1.getUnitType()) != 0) {
+      return enumComparator.compare(arg0.getUnitType(), arg1.getUnitType());
+    }
+
+    return 0;
+  }
+
+}

model/src/test/java/lcsb/mapviewer/model/map/kinetics/AllKineticsTests.java

@@ -6,10 +6,16 @@ import org.junit.runners.Suite.SuiteClasses;
 
 @RunWith(Suite.class)
 @SuiteClasses({ SbmlFunctionTest.class, //
+    SbmlFunctionComparatorTest.class, //
     SbmlKineticsTest.class, //
+    SbmlKineticsComparatorTest.class, //
     SbmlParameterTest.class, //
+    SbmlParameterComparatorTest.class, //
     SbmlUnitTest.class, //
-    SbmlUnitTypeFactorTest.class })
+    SbmlUnitComparatorTest.class, //
+    SbmlUnitTypeFactorTest.class,//
+    SbmlUnitTypeFactorComparatorTest.class, //
+    })
 public class AllKineticsTests {
 
 }

model/src/test/java/lcsb/mapviewer/model/map/kinetics/SbmlFunctionComparatorTest.java

+package lcsb.mapviewer.model.map.kinetics;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class SbmlFunctionComparatorTest {
+  SbmlFunctionComparator comparator = new SbmlFunctionComparator();
+
+  @Test
+  public void testCompareEqual() {
+    SbmlFunction Function = createFunction();
+    SbmlFunction Function2 = createFunction();
+    assertEquals(0, comparator.compare(Function, Function2));
+  }
+
+  @Test
+  public void testCompareDifferentFunctionId() {
+    SbmlFunction function = createFunction();
+    SbmlFunction function2 = createFunction();
+    function.setFunctionId("xxx");
+    assertTrue("Function object have different id but comparison returned equal",
+        comparator.compare(function, function2) != 0);
+  }
+
+  @Test
+  public void testCompareDifferentName() {
+    SbmlFunction function = createFunction();
+    SbmlFunction function2 = createFunction();
+    function.setName("xxx");
+    assertTrue("Function object have different name but comparison returned equal",
+        comparator.compare(function, function2) != 0);
+  }
+
+  @Test
+  public void testCompareDifferentDefinition() {
+    SbmlFunction function = createFunction();
+    SbmlFunction function2 = createFunction();
+    function.setDefinition("xxx");
+    assertTrue("Function object have different name but comparison returned equal",
+        comparator.compare(function, function2) != 0);
+  }
+
+  @Test
+  public void testCompareDifferentArguments() {
+    SbmlFunction function = createFunction();
+    SbmlFunction function2 = createFunction();
+    function.addArgument("x");
+    assertTrue("Function object have different name but comparison returned equal",
+        comparator.compare(function, function2) != 0);
+  }
+
+  private SbmlFunction createFunction() {
+    SbmlFunction result = new SbmlFunction("fun_id");
+    return result;
+  }
+
+}

model/src/test/java/lcsb/mapviewer/model/map/kinetics/SbmlKineticsComparatorTest.java

+package lcsb.mapviewer.model.map.kinetics;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import lcsb.mapviewer.model.map.species.GenericProtein;
+
+public class SbmlKineticsComparatorTest {
+  SbmlKineticsComparator comparator = new SbmlKineticsComparator();
+
+  @Test
+  public void testCompareEqual() {
+    SbmlKinetics kinetics = createKinetics();
+    SbmlKinetics kinetics2 = createKinetics();
+    assertEquals(0, comparator.compare(kinetics, kinetics2));
+  }
+
+  @Test
+  public void testCompareDifferentFunction() {
+    SbmlKinetics kinetics = createKinetics();
+    SbmlKinetics kinetics2 = createKinetics();
+    kinetics2.getFunctions().iterator().next().setFunctionId("new_fun_id");
+    assertTrue("Kinetics object have different functions but comparison returned equal",
+        comparator.compare(kinetics, kinetics2) != 0);
+  }
+
+  @Test
+  public void testCompareDifferentParameters() {
+    SbmlKinetics kinetics = createKinetics();
+    SbmlKinetics kinetics2 = createKinetics();
+    kinetics2.getParameters().iterator().next().setParameterId("new_fun_id");
+    assertTrue("Kinetics object have different functions but comparison returned equal",
+        comparator.compare(kinetics, kinetics2) != 0);
+  }
+
+  @Test
+  public void testCompareDifferentDefinition() {
+    SbmlKinetics kinetics = createKinetics();
+    SbmlKinetics kinetics2 = createKinetics();
+    kinetics2.setDefinition("xxx");
+    assertTrue("Kinetics object have different definition but comparison returned equal",
+        comparator.compare(kinetics, kinetics2) != 0);
+  }
+
+  @Test
+  public void testCompareDifferentElements() {
+    SbmlKinetics kinetics = createKinetics();
+    SbmlKinetics kinetics2 = createKinetics();
+    kinetics2.addElement(new GenericProtein("x1"));
+    assertTrue("Kinetics object have different elements but comparison returned equal",
+        comparator.compare(kinetics, kinetics2) != 0);
+  }
+
+  private SbmlKinetics createKinetics() {
+    SbmlKinetics result = new SbmlKinetics();
+    result.addElement(new GenericProtein("protein_id"));
+    result.addFunction(new SbmlFunction("fun_id"));
+    result.addParameter(new SbmlParameter("param_id"));
+    result.setDefinition("<xml/>");
+    return result;
+  }
+
+}

model/src/test/java/lcsb/mapviewer/model/map/kinetics/SbmlParameterComparatorTest.java

+package lcsb.mapviewer.model.map.kinetics;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class SbmlParameterComparatorTest {
+  SbmlParameterComparator comparator = new SbmlParameterComparator();
+
+  private SbmlParameter createParameter() {
+    SbmlParameter result = new SbmlParameter("param_id");
+    return result;
+  }
+
+  @Test
+  public void testCompareEqual() {
+    SbmlParameter parameter = createParameter();
+    SbmlParameter parameter2 = createParameter();
+    assertEquals(0, comparator.compare(parameter, parameter2));
+  }
+
+  @Test
+  public void testCompareDifferentParameterId() {
+    SbmlParameter parameter = createParameter();
+    SbmlParameter parameter2 = createParameter();
+    parameter.setParameterId("xxx");
+    assertTrue("Parameter object have different id but comparison returned equal",
+        comparator.compare(parameter, parameter2) != 0);
+  }
+
+  @Test
+  public void testCompareDifferentName() {
+    SbmlParameter parameter = createParameter();
+    SbmlParameter parameter2 = createParameter();
+    parameter.setName("xxx");
+    assertTrue("Parameter object have different name but comparison returned equal",
+        comparator.compare(parameter, parameter2) != 0);
+  }
+
+  @Test
+  public void testCompareDifferentDefinition() {
+    SbmlParameter parameter = createParameter();
+    SbmlParameter parameter2 = createParameter();
+    parameter.setValue(13.0);
+    assertTrue("Parameter object have different value but comparison returned equal",
+        comparator.compare(parameter, parameter2) != 0);
+  }
+
+  @Test
+  public void testCompareDifferentArguments() {
+    SbmlParameter parameter = createParameter();
+    SbmlParameter parameter2 = createParameter();
+    parameter.setUnits(new SbmlUnit("x"));
+    assertTrue("Parameter object have different unit but comparison returned equal",
+        comparator.compare(parameter, parameter2) != 0);
+  }
+
+}

model/src/test/java/lcsb/mapviewer/model/map/kinetics/SbmlUnitComparatorTest.java

+package lcsb.mapviewer.model.map.kinetics;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class SbmlUnitComparatorTest {
+  SbmlUnitComparator comparator = new SbmlUnitComparator();
+
+  private SbmlUnit createUnit() {
+    SbmlUnit result = new SbmlUnit("unit_id");
+    return result;
+  }
+
+  @Test
+  public void testCompareEqual() {
+    SbmlUnit parameter = createUnit();
+    SbmlUnit parameter2 = createUnit();
+    assertEquals(0, comparator.compare(parameter, parameter2));
+  }
+
+  @Test
+  public void testCompareUnitId() {
+    SbmlUnit parameter = createUnit();
+    SbmlUnit parameter2 = createUnit();
+    parameter.setUnitId("xxx");
+    assertTrue(0 != comparator.compare(parameter, parameter2));
+  }
+
+  @Test
+  public void testCompareName() {
+    SbmlUnit parameter = createUnit();
+    SbmlUnit parameter2 = createUnit();
+    parameter.setName("xxx");
+    assertTrue(0 != comparator.compare(parameter, parameter2));
+  }
+
+  @Test
+  public void testCompareUnitTypes() {
+    SbmlUnit parameter = createUnit();
+    SbmlUnit parameter2 = createUnit();
+    parameter.addUnitTypeFactor(new SbmlUnitTypeFactor(SbmlUnitType.AMPERE, 1, 1, 1));;
+    assertTrue(0 != comparator.compare(parameter, parameter2));
+  }
+
+}

model/src/test/java/lcsb/mapviewer/model/map/kinetics/SbmlUnitTest.java

@@ -27,7 +27,7 @@ public class SbmlUnitTest {
     SbmlUnit unit = new SbmlUnit("");
     unit.addUnitTypeFactor(factor);
     assertEquals(unit.getUnitTypeFactors().size(), 1);
-    assertEquals(unit.getUnitTypeFactors().get(0), factor);
+    assertEquals(unit.getUnitTypeFactors().iterator().next(), factor);
   }
 
 }

model/src/test/java/lcsb/mapviewer/model/map/kinetics/SbmlUnitTypeFactorComparatorTest.java

+package lcsb.mapviewer.model.map.kinetics;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class SbmlUnitTypeFactorComparatorTest {
+
+  SbmlUnitTypeFactorComparator comparator = new SbmlUnitTypeFactorComparator();
+
+  private SbmlUnitTypeFactor createUnitTypeFactor() {
+    SbmlUnitTypeFactor result = new SbmlUnitTypeFactor(SbmlUnitType.AMPERE, 1, 1, 1);
+    return result;
+  }
+
+  @Test
+  public void testCompareEqual() {
+    SbmlUnitTypeFactor parameter = createUnitTypeFactor();
+    SbmlUnitTypeFactor parameter2 = createUnitTypeFactor();
+    assertEquals(0, comparator.compare(parameter, parameter2));
+  }
+
+  @Test
+  public void testCompareDifferentUnitType() {
+    SbmlUnitTypeFactor parameter = createUnitTypeFactor();
+    SbmlUnitTypeFactor parameter2 = createUnitTypeFactor();
+    parameter.setUnitType(SbmlUnitType.BECQUEREL);
+    assertTrue(0 != comparator.compare(parameter, parameter2));
+    assertTrue(0 != comparator.compare(parameter2, parameter));
+  }
+
+  @Test
+  public void testCompareDifferentExponent() {
+    SbmlUnitTypeFactor parameter = createUnitTypeFactor();
+    SbmlUnitTypeFactor parameter2 = createUnitTypeFactor();
+    parameter.setExponent(2);
+    assertTrue(0 != comparator.compare(parameter, parameter2));
+    assertTrue(0 != comparator.compare(parameter2, parameter));
+  }
+
+  @Test
+  public void testCompareDifferentMultiplier() {
+    SbmlUnitTypeFactor parameter = createUnitTypeFactor();
+    SbmlUnitTypeFactor parameter2 = createUnitTypeFactor();
+    parameter.setMultiplier(2);
+    assertTrue(0 != comparator.compare(parameter, parameter2));
+    assertTrue(0 != comparator.compare(parameter2, parameter));
+  }
+
+  @Test
+  public void testCompareDifferentScale() {
+    SbmlUnitTypeFactor parameter = createUnitTypeFactor();
+    SbmlUnitTypeFactor parameter2 = createUnitTypeFactor();
+    parameter.setScale(3);
+    assertTrue(0 != comparator.compare(parameter, parameter2));
+    assertTrue(0 != comparator.compare(parameter2, parameter));
+  }
+
+}

model/src/test/java/lcsb/mapviewer/model/map/reaction/ReactionTest.java

@@ -36,372 +36,377 @@ import lcsb.mapviewer.model.map.species.Species;
 
 public class ReactionTest extends ModelTestFunctions {
 
-	Logger					logger = Logger.getLogger(ReactantTest.class);
-
-	private Species	species;
-
-	@Before
-	public void setUp() throws Exception {
-		species = new GenericProtein("sa1");
-	}
-
-	@After
-	public void tearDown() throws Exception {
-	}
-
-	@Test
-	public void testContainsElement() {
-		try {
-			Reaction reaction = new Reaction();
-			assertFalse(reaction.containsElement(species));
-			Modifier modifier = new Catalysis(species);
-			reaction.addModifier(modifier);
-			assertTrue(reaction.containsElement(species));
-			assertFalse(reaction.containsElement(new GenericProtein("id")));
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testComparator() {
-		try {
-			Reaction reaction1 = new Reaction();
-			reaction1.setIdReaction("2");
-			Reaction reaction2 = new Reaction();
-			reaction2.setIdReaction("1");
-			Reaction reaction3 = new Reaction();
-			reaction3.setIdReaction("3");
-			List<Reaction> reactions = new ArrayList<>();
-			reactions.add(reaction1);
-			reactions.add(reaction2);
-			reactions.add(reaction3);
-			Collections.sort(reactions, Reaction.ID_COMPARATOR);
-			assertEquals(reaction2, reactions.get(0));
-			assertEquals(reaction1, reactions.get(1));
-			assertEquals(reaction3, reactions.get(2));
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testConstructor() {
-		try {
-			Reaction reaction1 = new Reaction();
-			reaction1.addMiriamData(new MiriamData());
-			reaction1.addSynonym("s");
-			Reaction reaction2 = new Reaction(reaction1);
-
-			assertEquals(1, reaction2.getMiriamData().size());
-			assertEquals(1, reaction2.getSynonyms().size());
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testGetDistanceFromPoint() {
-		try {
-			Reaction reaction1 = new Reaction();
-			Reactant reactant = new Reactant();
-			PolylineData line = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(2.0, 0.0));
-			reactant.setLine(line);
-			reaction1.addReactant(reactant);
-
-			assertEquals(0.0, reaction1.getDistanceFromPoint(new Point2D.Double(0.0, 0.0)), Configuration.EPSILON);
-			assertEquals(0.0, reaction1.getDistanceFromPoint(new Point2D.Double(1.0, 0.0)), Configuration.EPSILON);
-			assertEquals(1.0, reaction1.getDistanceFromPoint(new Point2D.Double(1.0, 1.0)), Configuration.EPSILON);
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testGetClosestPointTo() {
-		try {
-			Reaction reaction1 = new Reaction();
-			Reactant reactant = new Reactant();
-			PolylineData line = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(2.0, 0.0));
-			reactant.setLine(line);
-			reaction1.addReactant(reactant);
-
-			assertEquals(0.0, reaction1.getClosestPointTo(new Point2D.Double(0.0, 0.0)).distance(new Point2D.Double(0.0, 0.0)), Configuration.EPSILON);
-			assertEquals(0.0, reaction1.getClosestPointTo(new Point2D.Double(1.0, 0.0)).distance(new Point2D.Double(1.0, 0.0)), Configuration.EPSILON);
-			assertEquals(0.0, reaction1.getClosestPointTo(new Point2D.Double(1.0, 1.0)).distance(new Point2D.Double(1.0, 0.0)), Configuration.EPSILON);
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testAddMiriam() {
-		try {
-			Reaction reaction1 = new Reaction();
-
-			MiriamData md = new MiriamData(MiriamType.CAS, "1");
-			reaction1.addMiriamData(md);
-
-			assertEquals(1, reaction1.getMiriamData().size());
-
-			reaction1.addMiriamData(md);
-			assertEquals(1, reaction1.getMiriamData().size());
-			assertEquals(1, getWarnings().size());
-
-			List<MiriamData> list = new ArrayList<>();
-			list.add(md);
-
-			reaction1.addMiriamData(list);
-			assertEquals(2, getWarnings().size());
-
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testGetters() {
-		try {
-			Reaction reaction1 = new Reaction();
-
-			assertNotNull(reaction1.getStringType());
-			assertNull(reaction1.getReactionRect());
-
-			int id = 61;
-			List<AbstractNode> nodes = new ArrayList<>();
-			String notes = "dfp";
-
-			boolean kineticLaw = true;
-			ModelData data = new ModelData();
-			Model model = new ModelFullIndexed(data);
-			String symbol = "sybm";
-			String formula = "form";
-			Integer mechanicalConfidenceScore = 9908;
-			Double lowerBound = 9.2;
-			Double upperBound = 9.2;
-			String subsystem = "ssyst";
-			String geneProteinReaction = "GPR";
-			List<String> synonyms = new ArrayList<>();
-
-			reaction1.setId(id);
-			reaction1.setNodes(nodes);
-			reaction1.setNotes(notes);
-			reaction1.setModel(model);
-			assertEquals(model, reaction1.getModel());
-			reaction1.setModelData(data);
-			assertEquals(data, reaction1.getModelData());
-			reaction1.setSymbol(symbol);
-			assertEquals(symbol, reaction1.getSymbol());
-			reaction1.setFormula(formula);
-			assertEquals(formula, reaction1.getFormula());
-			reaction1.setMechanicalConfidenceScore(mechanicalConfidenceScore);
-			assertEquals(mechanicalConfidenceScore, reaction1.getMechanicalConfidenceScore());
-			reaction1.setLowerBound(lowerBound);
-			assertEquals(lowerBound, reaction1.getLowerBound());
-			reaction1.setUpperBound(upperBound);
-			assertEquals(upperBound, reaction1.getUpperBound());
-			reaction1.setSubsystem(subsystem);
-			assertEquals(subsystem, reaction1.getSubsystem());
-			reaction1.setGeneProteinReaction(geneProteinReaction);
-			assertEquals(geneProteinReaction, reaction1.getGeneProteinReaction());
-			reaction1.setSynonyms(synonyms);
-			assertEquals(synonyms, reaction1.getSynonyms());
-
-			assertEquals(id, reaction1.getId());
-			assertEquals(nodes, reaction1.getNodes());
-			assertEquals(notes, reaction1.getNotes());
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testVisibilityLevel() {
-		try {
-			Reaction reaction1 = new Reaction();
-			assertEquals("", reaction1.getVisibilityLevel());
-
-			reaction1.setVisibilityLevel(1);
-			assertEquals("1", reaction1.getVisibilityLevel());
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testGetCenterLine() {
-		try {
-			Reaction reaction1 = new Reaction();
-
-			Reactant reactant = new Reactant();
-			PolylineData line1 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
-			reactant.setLine(line1);
-			reaction1.addReactant(reactant);
-
-			Product product = new Product();
-			PolylineData line2 = new PolylineData(new Point2D.Double(0.0, 2.0), new Point2D.Double(4.0, 0.0));
-			product.setLine(line2);
-			reaction1.addProduct(product);
-
-			Line2D line = reaction1.getCenterLine();
-			assertEquals(4.0, line.getP1().distance(line.getP2()), Configuration.EPSILON);
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testGetCenterPoint() {
-		try {
-			Reaction reaction1 = new Reaction();
-
-			Reactant reactant = new Reactant();
-			PolylineData line1 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
-			reactant.setLine(line1);
-			reaction1.addReactant(reactant);
-
-			Product product = new Product();
-			PolylineData line2 = new PolylineData(new Point2D.Double(0.0, 2.0), new Point2D.Double(4.0, 0.0));
-			product.setLine(line2);
-			reaction1.addProduct(product);
-
-			assertEquals(0.0, reaction1.getCenterPoint().distance(new Point2D.Double(2.0, 0.0)), Configuration.EPSILON);
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testGetCenterLine2() {
-		try {
-			Reaction reaction1 = new HeterodimerAssociationReaction();
-
-			Reactant reactant = new Reactant();
-			PolylineData line1 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
-			reactant.setLine(line1);
-			reaction1.addReactant(reactant);
-
-			Reactant reactant2 = new Reactant();
-			PolylineData line3 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
-			reactant2.setLine(line3);
-			reaction1.addReactant(reactant2);
-			AndOperator operator = new AndOperator();
-			operator.addInput(reactant);
-			operator.addInput(reactant2);
-			PolylineData line4 = new PolylineData(new Point2D.Double(10.0, 0.0), new Point2D.Double(11.0, 11.0));
-			operator.setLine(line4);
-			reaction1.addNode(operator);
-
-			Product product = new Product();
-			PolylineData line2 = new PolylineData(new Point2D.Double(0.0, 2.0), new Point2D.Double(4.0, 0.0));
-			product.setLine(line2);
-			reaction1.addProduct(product);
-
-			Line2D line = reaction1.getCenterLine();
-			assertEquals(6.0, line.getP1().distance(line.getP2()), Configuration.EPSILON);
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testGetCenterLine3() {
-		try {
-			Reaction reaction1 = new DissociationReaction();
-
-			Reactant reactant = new Reactant();
-			PolylineData line1 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
-			reactant.setLine(line1);
-			reaction1.addReactant(reactant);
-
-			Product product = new Product();
-			PolylineData line2 = new PolylineData(new Point2D.Double(0.0, 2.0), new Point2D.Double(4.0, 0.0));
-			product.setLine(line2);
-			reaction1.addProduct(product);
-
-			Product product2 = new Product();
-			PolylineData line3 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
-			product2.setLine(line3);
-			reaction1.addProduct(product2);
-			SplitOperator operator = new SplitOperator();
-			operator.addOutput(product);
-			operator.addOutput(product2);
-			PolylineData line4 = new PolylineData(new Point2D.Double(10.0, 0.0), new Point2D.Double(11.0, 0.0));
-			operator.setLine(line4);
-			reaction1.addNode(operator);
-
-			Line2D line = reaction1.getCenterLine();
-			assertEquals(10.0, line.getP1().distance(line.getP2()), Configuration.EPSILON);
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testSerialization() {
-		try {
-			SerializationUtils.serialize(new Reaction());
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testRemoveModifier() {
-		try {
-			Reaction reaction = new Reaction();
-			Modifier modifier = new Modifier();
-			reaction.addModifier(modifier);
-			assertEquals(1, reaction.getModifiers().size());
-			reaction.removeModifier(modifier);
-			assertEquals(0, reaction.getModifiers().size());
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testCopy() {
-		try {
-			Reaction original = new Reaction();
-			Reaction reactant = original.copy();
-			assertNotNull(reactant);
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
-
-	@Test
-	public void testInvalidCopy() {
-		try {
-			new Reaction() {
-
-				/**
-				 * 
-				 */
-				private static final long serialVersionUID = 1L;
-			}.copy();
-			fail("Exception expected");
-		} catch (NotImplementedException e) {
-		} catch (Exception e) {
-			e.printStackTrace();
-			throw e;
-		}
-	}
+  Logger logger = Logger.getLogger(ReactantTest.class);
+
+  private Species species;
+
+  @Before
+  public void setUp() throws Exception {
+    species = new GenericProtein("sa1");
+  }
+
+  @After
+  public void tearDown() throws Exception {
+  }
+
+  @Test
+  public void testContainsElement() {
+    try {
+      Reaction reaction = new Reaction();
+      assertFalse(reaction.containsElement(species));
+      Modifier modifier = new Catalysis(species);
+      reaction.addModifier(modifier);
+      assertTrue(reaction.containsElement(species));
+      assertFalse(reaction.containsElement(new GenericProtein("id")));
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testComparator() {
+    try {
+      Reaction reaction1 = new Reaction();
+      reaction1.setIdReaction("2");
+      Reaction reaction2 = new Reaction();
+      reaction2.setIdReaction("1");
+      Reaction reaction3 = new Reaction();
+      reaction3.setIdReaction("3");
+      List<Reaction> reactions = new ArrayList<>();
+      reactions.add(reaction1);
+      reactions.add(reaction2);
+      reactions.add(reaction3);
+      Collections.sort(reactions, Reaction.ID_COMPARATOR);
+      assertEquals(reaction2, reactions.get(0));
+      assertEquals(reaction1, reactions.get(1));
+      assertEquals(reaction3, reactions.get(2));
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testConstructor() {
+    try {
+      Reaction reaction1 = new Reaction();
+      reaction1.addMiriamData(new MiriamData());
+      reaction1.addSynonym("s");
+      Reaction reaction2 = new Reaction(reaction1);
+
+      assertEquals(1, reaction2.getMiriamData().size());
+      assertEquals(1, reaction2.getSynonyms().size());
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testGetDistanceFromPoint() {
+    try {
+      Reaction reaction1 = new Reaction();
+      Reactant reactant = new Reactant();
+      PolylineData line = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(2.0, 0.0));
+      reactant.setLine(line);
+      reaction1.addReactant(reactant);
+
+      assertEquals(0.0, reaction1.getDistanceFromPoint(new Point2D.Double(0.0, 0.0)), Configuration.EPSILON);
+      assertEquals(0.0, reaction1.getDistanceFromPoint(new Point2D.Double(1.0, 0.0)), Configuration.EPSILON);
+      assertEquals(1.0, reaction1.getDistanceFromPoint(new Point2D.Double(1.0, 1.0)), Configuration.EPSILON);
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testGetClosestPointTo() {
+    try {
+      Reaction reaction1 = new Reaction();
+      Reactant reactant = new Reactant();
+      PolylineData line = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(2.0, 0.0));
+      reactant.setLine(line);
+      reaction1.addReactant(reactant);
+
+      assertEquals(0.0,
+          reaction1.getClosestPointTo(new Point2D.Double(0.0, 0.0)).distance(new Point2D.Double(0.0, 0.0)),
+          Configuration.EPSILON);
+      assertEquals(0.0,
+          reaction1.getClosestPointTo(new Point2D.Double(1.0, 0.0)).distance(new Point2D.Double(1.0, 0.0)),
+          Configuration.EPSILON);
+      assertEquals(0.0,
+          reaction1.getClosestPointTo(new Point2D.Double(1.0, 1.0)).distance(new Point2D.Double(1.0, 0.0)),
+          Configuration.EPSILON);
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testAddMiriam() {
+    try {
+      Reaction reaction1 = new Reaction();
+
+      MiriamData md = new MiriamData(MiriamType.CAS, "1");
+      reaction1.addMiriamData(md);
+
+      assertEquals(1, reaction1.getMiriamData().size());
+
+      reaction1.addMiriamData(md);
+      assertEquals(1, reaction1.getMiriamData().size());
+      assertEquals(1, getWarnings().size());
+
+      List<MiriamData> list = new ArrayList<>();
+      list.add(md);
+
+      reaction1.addMiriamData(list);
+      assertEquals(2, getWarnings().size());
+
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testGetters() {
+    try {
+      Reaction reaction1 = new Reaction();
+
+      assertNotNull(reaction1.getStringType());
+      assertNull(reaction1.getReactionRect());
+
+      int id = 61;
+      List<AbstractNode> nodes = new ArrayList<>();
+      String notes = "dfp";
+
+      ModelData data = new ModelData();
+      Model model = new ModelFullIndexed(data);
+      String symbol = "sybm";
+      String formula = "form";
+      Integer mechanicalConfidenceScore = 9908;
+      Double lowerBound = 9.2;
+      Double upperBound = 9.2;
+      String subsystem = "ssyst";
+      String geneProteinReaction = "GPR";
+      List<String> synonyms = new ArrayList<>();
+
+      reaction1.setId(id);
+      reaction1.setNodes(nodes);
+      reaction1.setNotes(notes);
+      reaction1.setModel(model);
+      assertEquals(model, reaction1.getModel());
+      reaction1.setModelData(data);
+      assertEquals(data, reaction1.getModelData());
+      reaction1.setSymbol(symbol);
+      assertEquals(symbol, reaction1.getSymbol());
+      reaction1.setFormula(formula);
+      assertEquals(formula, reaction1.getFormula());
+      reaction1.setMechanicalConfidenceScore(mechanicalConfidenceScore);
+      assertEquals(mechanicalConfidenceScore, reaction1.getMechanicalConfidenceScore());
+      reaction1.setLowerBound(lowerBound);
+      assertEquals(lowerBound, reaction1.getLowerBound());
+      reaction1.setUpperBound(upperBound);
+      assertEquals(upperBound, reaction1.getUpperBound());
+      reaction1.setSubsystem(subsystem);
+      assertEquals(subsystem, reaction1.getSubsystem());
+      reaction1.setGeneProteinReaction(geneProteinReaction);
+      assertEquals(geneProteinReaction, reaction1.getGeneProteinReaction());
+      reaction1.setSynonyms(synonyms);
+      assertEquals(synonyms, reaction1.getSynonyms());
+
+      assertEquals(id, reaction1.getId());
+      assertEquals(nodes, reaction1.getNodes());
+      assertEquals(notes, reaction1.getNotes());
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testVisibilityLevel() {
+    try {
+      Reaction reaction1 = new Reaction();
+      assertEquals("", reaction1.getVisibilityLevel());
+
+      reaction1.setVisibilityLevel(1);
+      assertEquals("1", reaction1.getVisibilityLevel());
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testGetCenterLine() {
+    try {
+      Reaction reaction1 = new Reaction();
+
+      Reactant reactant = new Reactant();
+      PolylineData line1 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
+      reactant.setLine(line1);
+      reaction1.addReactant(reactant);
+
+      Product product = new Product();
+      PolylineData line2 = new PolylineData(new Point2D.Double(0.0, 2.0), new Point2D.Double(4.0, 0.0));
+      product.setLine(line2);
+      reaction1.addProduct(product);
+
+      Line2D line = reaction1.getCenterLine();
+      assertEquals(4.0, line.getP1().distance(line.getP2()), Configuration.EPSILON);
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testGetCenterPoint() {
+    try {
+      Reaction reaction1 = new Reaction();
+
+      Reactant reactant = new Reactant();
+      PolylineData line1 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
+      reactant.setLine(line1);
+      reaction1.addReactant(reactant);
+
+      Product product = new Product();
+      PolylineData line2 = new PolylineData(new Point2D.Double(0.0, 2.0), new Point2D.Double(4.0, 0.0));
+      product.setLine(line2);
+      reaction1.addProduct(product);
+
+      assertEquals(0.0, reaction1.getCenterPoint().distance(new Point2D.Double(2.0, 0.0)), Configuration.EPSILON);
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testGetCenterLine2() {
+    try {
+      Reaction reaction1 = new HeterodimerAssociationReaction();
+
+      Reactant reactant = new Reactant();
+      PolylineData line1 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
+      reactant.setLine(line1);
+      reaction1.addReactant(reactant);
+
+      Reactant reactant2 = new Reactant();
+      PolylineData line3 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
+      reactant2.setLine(line3);
+      reaction1.addReactant(reactant2);
+      AndOperator operator = new AndOperator();
+      operator.addInput(reactant);
+      operator.addInput(reactant2);
+      PolylineData line4 = new PolylineData(new Point2D.Double(10.0, 0.0), new Point2D.Double(11.0, 11.0));
+      operator.setLine(line4);
+      reaction1.addNode(operator);
+
+      Product product = new Product();
+      PolylineData line2 = new PolylineData(new Point2D.Double(0.0, 2.0), new Point2D.Double(4.0, 0.0));
+      product.setLine(line2);
+      reaction1.addProduct(product);
+
+      Line2D line = reaction1.getCenterLine();
+      assertEquals(6.0, line.getP1().distance(line.getP2()), Configuration.EPSILON);
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testGetCenterLine3() {
+    try {
+      Reaction reaction1 = new DissociationReaction();
+
+      Reactant reactant = new Reactant();
+      PolylineData line1 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
+      reactant.setLine(line1);
+      reaction1.addReactant(reactant);
+
+      Product product = new Product();
+      PolylineData line2 = new PolylineData(new Point2D.Double(0.0, 2.0), new Point2D.Double(4.0, 0.0));
+      product.setLine(line2);
+      reaction1.addProduct(product);
+
+      Product product2 = new Product();
+      PolylineData line3 = new PolylineData(new Point2D.Double(0.0, 0.0), new Point2D.Double(0.0, 1.0));
+      product2.setLine(line3);
+      reaction1.addProduct(product2);
+      SplitOperator operator = new SplitOperator();
+      operator.addOutput(product);
+      operator.addOutput(product2);
+      PolylineData line4 = new PolylineData(new Point2D.Double(10.0, 0.0), new Point2D.Double(11.0, 0.0));
+      operator.setLine(line4);
+      reaction1.addNode(operator);
+
+      Line2D line = reaction1.getCenterLine();
+      assertEquals(10.0, line.getP1().distance(line.getP2()), Configuration.EPSILON);
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testSerialization() {
+    try {
+      SerializationUtils.serialize(new Reaction());
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testRemoveModifier() {
+    try {
+      Reaction reaction = new Reaction();
+      Modifier modifier = new Modifier();
+      reaction.addModifier(modifier);
+      assertEquals(1, reaction.getModifiers().size());
+      reaction.removeModifier(modifier);
+      assertEquals(0, reaction.getModifiers().size());
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testCopy() {
+    try {
+      Reaction original = new Reaction();
+      Reaction reactant = original.copy();
+      assertNotNull(reactant);
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
+
+  @Test
+  public void testInvalidCopy() {
+    try {
+      new Reaction() {
+
+        /**
+         * 
+         */
+        private static final long serialVersionUID = 1L;
+      }.copy();
+      fail("Exception expected");
+    } catch (NotImplementedException e) {
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw e;
+    }
+  }
 
 }