diff --git a/src/main/java/org/olat/modules/forms/RubricsComparison.java b/src/main/java/org/olat/modules/forms/RubricsComparison.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a1b4fcff673b1521839411d6059cd1338eb7c14
--- /dev/null
+++ b/src/main/java/org/olat/modules/forms/RubricsComparison.java
@@ -0,0 +1,141 @@
+/**
+ * <a href="http://www.openolat.org">
+ * OpenOLAT - Online Learning and Training</a><br>
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at the
+ * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Initial code contributed and copyrighted by<br>
+ * frentix GmbH, http://www.frentix.com
+ * <p>
+ */
+package org.olat.modules.forms;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.olat.core.util.StringHelper;
+import org.olat.modules.forms.model.xml.Rubric;
+import org.olat.modules.forms.model.xml.Slider;
+
+/**
+ * 
+ * Initial date: 9 Jul 2019<br>
+ * @author uhensler, urs.hensler@frentix.com, http://www.frentix.com
+ *
+ */
+public class RubricsComparison {
+	
+	public enum Attribute {
+		sliderType,
+		scaleType,
+		name,
+		start,
+		end,
+		steps,
+		noResponseEnabled,
+		lowerBoundInsufficient,
+		upperBoundInsufficient,
+		lowerBoundNeutral,
+		upperBoundNeutral,
+		lowerBoundSufficient,
+		upperBoundSufficient,
+		startGoodRating,
+		slidersLabel,
+		slidersWeighted
+	}
+	
+	private enum LabelType {
+		none,
+		start,
+		end,
+		both
+	}
+	
+	public static boolean areIdentical(Collection<Rubric> rubrics, Attribute... attributes) {
+		Iterator<Rubric> iterator = rubrics.iterator();
+		Rubric master = iterator.next();
+		while (iterator.hasNext()) {
+			Rubric rubric = iterator.next();
+			if (!areIdentical(master, rubric, attributes)) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	private static boolean areIdentical(Rubric master, Rubric rubric, Attribute[] attributes) {
+		for (Attribute attribute : attributes) {
+			if (!areIdentical(master, rubric, attribute)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static boolean areIdentical(Rubric master, Rubric rubric, Attribute attribute) {
+		switch(attribute) {
+		case sliderType: return master.getSliderType() == rubric.getSliderType();
+		case scaleType: return master.getScaleType() == rubric.getScaleType();
+		//
+		case name: return equalsNull(master.getName(), rubric.getName());
+		case start: return master.getStart() == rubric.getStart();
+		case end: return master.getEnd() == rubric.getEnd();
+		case steps: return master.getSteps() == rubric.getSteps();
+		//
+		case noResponseEnabled: return master.isNoResponseEnabled() == rubric.isNoResponseEnabled();
+		case lowerBoundInsufficient: return equalsNull(master.getLowerBoundInsufficient(), rubric.getLowerBoundInsufficient());
+		case upperBoundInsufficient: return equalsNull(master.getUpperBoundInsufficient(), rubric.getUpperBoundInsufficient());
+		case lowerBoundNeutral: return equalsNull(master.getLowerBoundNeutral(), rubric.getLowerBoundNeutral());
+		case upperBoundNeutral: return equalsNull(master.getUpperBoundNeutral(), rubric.getUpperBoundNeutral());
+		case lowerBoundSufficient: return equalsNull(master.getLowerBoundSufficient(), rubric.getLowerBoundSufficient());
+		case upperBoundSufficient: return equalsNull(master.getUpperBoundSufficient(), rubric.getUpperBoundSufficient());
+		case startGoodRating: return master.isStartGoodRating() == rubric.isStartGoodRating();
+		case slidersLabel: return getSlidersLabelType(master) == getSlidersLabelType(rubric);
+		case slidersWeighted: return hasWeightedSliders(master) == hasWeightedSliders(rubric);
+		default: return false;
+		}
+	}
+
+	private static LabelType getSlidersLabelType(Rubric rubric) {
+		boolean start = false;
+		boolean end = false;
+		for (Slider slider: rubric.getSliders()) {
+			if (StringHelper.containsNonWhitespace(slider.getStartLabel())) {
+				start = true;
+			}
+			if (StringHelper.containsNonWhitespace(slider.getEndLabel())) {
+				end = true;
+			}
+		}
+		
+		if (start && end) return LabelType.both;
+		if (start)        return LabelType.start;
+		if (end)          return LabelType.end;
+		return LabelType.none;
+	}
+
+	private static boolean hasWeightedSliders(Rubric rubric) {
+		return rubric.getSliders().stream()
+				.filter(slider -> slider.getWeight().intValue() != 1)
+				.findFirst()
+				.isPresent();
+	}
+
+	@SuppressWarnings("null")
+	private static boolean equalsNull(Object o1, Object o2) {
+		if (o1 == null && o2 == null) return true;
+		if (o1 == null && o2 != null) return false;
+		if (o1 != null && o2 == null) return false;
+		return o1.equals(o2);
+	}
+
+}
diff --git a/src/main/java/org/olat/modules/forms/handler/RubricTableHandler.java b/src/main/java/org/olat/modules/forms/handler/RubricTableHandler.java
index cc3c08394894e47b143605ef1ab081c03aef6d52..3456fe7142538aa3cf3de919c53b84bbf3a94ae9 100644
--- a/src/main/java/org/olat/modules/forms/handler/RubricTableHandler.java
+++ b/src/main/java/org/olat/modules/forms/handler/RubricTableHandler.java
@@ -23,6 +23,7 @@ import org.olat.core.gui.UserRequest;
 import org.olat.core.gui.control.Controller;
 import org.olat.core.gui.control.WindowControl;
 import org.olat.modules.ceditor.PageElement;
+import org.olat.modules.forms.RubricsComparison.Attribute;
 import org.olat.modules.forms.SessionFilter;
 import org.olat.modules.forms.model.xml.Rubric;
 import org.olat.modules.forms.ui.ReportHelper;
@@ -38,9 +39,15 @@ import org.olat.modules.forms.ui.model.EvaluationFormReportElement;
  */
 public class RubricTableHandler implements EvaluationFormReportHandler {
 
+	public static final String TYPE = "rubrictablehandler";
+	;
+	public static Attribute[] getAttributesColumnAlignemt() {
+		return RubricTableController.ATTRIBUTES_COLUMN_ALLIGNMENT;
+	}
+
 	@Override
 	public String getType() {
-		return "rubrictablehandler";
+		return TYPE;
 	}
 
 	@Override
diff --git a/src/main/java/org/olat/modules/forms/ui/EvaluationFormReportController.java b/src/main/java/org/olat/modules/forms/ui/EvaluationFormReportController.java
index bf3ab751a2c44b84b5b8b6b28c5e852b6f1c32de..5b4f7f42a5821b699fb2bee00ed5df636fbc01a8 100644
--- a/src/main/java/org/olat/modules/forms/ui/EvaluationFormReportController.java
+++ b/src/main/java/org/olat/modules/forms/ui/EvaluationFormReportController.java
@@ -30,12 +30,15 @@ import org.olat.core.gui.control.Controller;
 import org.olat.core.gui.control.WindowControl;
 import org.olat.core.util.CodeHelper;
 import org.olat.modules.ceditor.DataStorage;
+import org.olat.modules.forms.RubricsComparison;
 import org.olat.modules.forms.SessionFilter;
 import org.olat.modules.forms.handler.DefaultReportProvider;
 import org.olat.modules.forms.handler.EvaluationFormReportHandler;
 import org.olat.modules.forms.handler.EvaluationFormReportProvider;
+import org.olat.modules.forms.handler.RubricTableHandler;
 import org.olat.modules.forms.model.xml.AbstractElement;
 import org.olat.modules.forms.model.xml.Form;
+import org.olat.modules.forms.model.xml.Rubric;
 import org.olat.modules.forms.ui.model.EvaluationFormReportElement;
 
 /**
@@ -82,6 +85,7 @@ public class EvaluationFormReportController extends FormBasicController {
 
 	@Override
 	protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
+		List<Rubric> rubrics = new ArrayList<>();
 		if (header != null) {
 			flc.put("header", header);
 		}
@@ -93,9 +97,17 @@ public class EvaluationFormReportController extends FormBasicController {
 				String cmpId = "cpt-" + CodeHelper.getRAMUniqueID();
 				flc.put(cmpId, reportElement.getReportComponent());
 				fragments.add(new ReportFragment(reportHandler.getType(), cmpId, reportElement));
+				if (RubricTableHandler.TYPE.equals(reportHandler.getType()) && Rubric.TYPE.equals(element.getType())) {
+					rubrics.add((Rubric) element);
+				}
 			}
 		}
 		flc.contextPut("fragments", fragments);
+		
+		// Would be better, if more generic
+		Boolean rubricsIdentical = rubrics.size() > 1
+				&& RubricsComparison.areIdentical(rubrics, RubricTableHandler.getAttributesColumnAlignemt());
+		flc.contextPut("alignRubricsTables", rubricsIdentical);
 	}
 
 	@Override
@@ -122,6 +134,14 @@ public class EvaluationFormReportController extends FormBasicController {
 			this.reportElement = reportElement;
 		}
 		
+		public String getType() {
+			return type;
+		}
+
+		public EvaluationFormReportElement getReportElement() {
+			return reportElement;
+		}
+
 		public String getCssClass() {
 			return "o_ed_".concat(type);
 		}
diff --git a/src/main/java/org/olat/modules/forms/ui/RubricTableController.java b/src/main/java/org/olat/modules/forms/ui/RubricTableController.java
index efe5d569e743388a213a8845195aa5d9f667e3b3..65df474d245a5a402b0d7d0719c3eee8f530d66b 100644
--- a/src/main/java/org/olat/modules/forms/ui/RubricTableController.java
+++ b/src/main/java/org/olat/modules/forms/ui/RubricTableController.java
@@ -39,6 +39,7 @@ import org.olat.core.util.CodeHelper;
 import org.olat.core.util.StringHelper;
 import org.olat.modules.forms.EvaluationFormManager;
 import org.olat.modules.forms.RubricStatistic;
+import org.olat.modules.forms.RubricsComparison.Attribute;
 import org.olat.modules.forms.SessionFilter;
 import org.olat.modules.forms.SliderStatistic;
 import org.olat.modules.forms.model.xml.Rubric;
@@ -57,6 +58,13 @@ import org.springframework.beans.factory.annotation.Autowired;
  */
 public class RubricTableController extends FormBasicController {
 	
+	public static final Attribute[] ATTRIBUTES_COLUMN_ALLIGNMENT = {
+			Attribute.steps,
+			Attribute.noResponseEnabled,
+			Attribute.slidersLabel,
+			Attribute.slidersWeighted
+	};
+	
 	private final Rubric rubric;
 	private final SessionFilter filter;
 	
diff --git a/src/main/java/org/olat/modules/forms/ui/_content/report.html b/src/main/java/org/olat/modules/forms/ui/_content/report.html
index 2eaf6e1a9aef258ae9183bd0bdfc86c300d1d616..07f5085873e817ba2300771e087c2e1713c9158c 100644
--- a/src/main/java/org/olat/modules/forms/ui/_content/report.html
+++ b/src/main/java/org/olat/modules/forms/ui/_content/report.html
@@ -7,4 +7,14 @@
 			<div class="$fragment.cssClass">$r.render($fragment.componentName)</div>
 		</div>
 	#end
-</div>
\ No newline at end of file
+</div>
+#if($alignRubricsTables)
+	<script>
+		/* <![CDATA[ */ 
+		jQuery(function() {
+			var tables = jQuery('.o_rubric_table table');
+			BFormatter.alignTableColumns(tables);
+		});
+		/* ]]> */
+	</script>
+#end
\ No newline at end of file
diff --git a/src/main/java/org/olat/modules/quality/analysis/ui/AnalysisUIFactory.java b/src/main/java/org/olat/modules/quality/analysis/ui/AnalysisUIFactory.java
index a282164c8001b8e4fd47e109ab070a41d6faaddd..e6b3b956d40ec2e5c4078b3b33dcbb18f65beda0 100644
--- a/src/main/java/org/olat/modules/quality/analysis/ui/AnalysisUIFactory.java
+++ b/src/main/java/org/olat/modules/quality/analysis/ui/AnalysisUIFactory.java
@@ -31,6 +31,7 @@ import org.olat.core.gui.components.util.KeyValues;
 import org.olat.core.gui.translator.Translator;
 import org.olat.core.util.StringHelper;
 import org.olat.modules.curriculum.CurriculumModule;
+import org.olat.modules.forms.RubricsComparison;
 import org.olat.modules.forms.model.xml.Rubric;
 import org.olat.modules.forms.model.xml.Rubric.NameDisplay;
 import org.olat.modules.forms.model.xml.Slider;
@@ -197,9 +198,10 @@ class AnalysisUIFactory {
 		return key;
 	}
 
-	static KeyValues getRubricKeyValue(Translator translator, List<Rubric> rubrics) {
+	static KeyValues getRubricKeyValue(Translator translator, List<Rubric> rubrics,
+			RubricsComparison.Attribute... attributes) {
 		KeyValues keyValues = new KeyValues();
-		boolean identicaRubrics = areIdenticalRubrics(rubrics);
+		boolean identicaRubrics = RubricsComparison.areIdentical(rubrics, attributes);
 		if (identicaRubrics) {
 			keyValues.add(entry(ALL_RUBRICS_KEY, translator.translate("trend.rubric.index.all")));
 		}
@@ -209,37 +211,6 @@ class AnalysisUIFactory {
 		}
 		return keyValues;
 	}
-	
-	static boolean areIdenticalRubrics(List<Rubric> rubrics) {
-		Rubric master = rubrics.get(0);
-		for (int i = 1; i < rubrics.size(); i++) {
-			Rubric rubric = rubrics.get(i);
-			if (!equalsNull(master.getLowerBoundInsufficient(), rubric.getLowerBoundInsufficient())
-					|| !equalsNull(master.getLowerBoundNeutral(), rubric.getLowerBoundNeutral())
-					|| !equalsNull(master.getLowerBoundSufficient(), rubric.getLowerBoundSufficient())
-					|| !equalsNull(master.getUpperBoundInsufficient(), rubric.getUpperBoundInsufficient())
-					|| !equalsNull(master.getUpperBoundNeutral(), rubric.getUpperBoundNeutral())
-					|| !equalsNull(master.getUpperBoundSufficient(), rubric.getUpperBoundSufficient())
-					|| master.getScaleType() != rubric.getScaleType()
-					|| master.getSliderType() != rubric.getSliderType()
-					|| master.getSteps() != rubric.getSteps()
-					|| master.getStart() != rubric.getStart()
-					|| master.getEnd() != rubric.getEnd()
-					|| master.isStartGoodRating() != master.isStartGoodRating()
-					) {
-				return false;
-			}
-		}
-		return true;
-	}
-	
-	@SuppressWarnings("null")
-	private static boolean equalsNull(Object o1, Object o2) {
-		if (o1 == null && o2 == null) return true;
-		if (o1 == null && o2 != null) return false;
-		if (o1 != null && o2 == null) return false;
-		return o1.equals(o2);
-	}
 
 	private static String getRubricName(Translator translator, Rubric rubric, int i) {
 		String index = String.valueOf(i + 1);
diff --git a/src/main/java/org/olat/modules/quality/analysis/ui/GroupByController.java b/src/main/java/org/olat/modules/quality/analysis/ui/GroupByController.java
index 5054e6f17f059140aad07c7fe3f1792484bb5395..8481711ee4090df00f6c33fa3fcc8afa274106cc 100644
--- a/src/main/java/org/olat/modules/quality/analysis/ui/GroupByController.java
+++ b/src/main/java/org/olat/modules/quality/analysis/ui/GroupByController.java
@@ -66,6 +66,7 @@ import org.olat.core.gui.control.creator.ControllerCreator;
 import org.olat.core.util.StringHelper;
 import org.olat.modules.curriculum.model.CurriculumElementRefImpl;
 import org.olat.modules.curriculum.model.CurriculumRefImpl;
+import org.olat.modules.forms.RubricsComparison.Attribute;
 import org.olat.modules.forms.model.xml.AbstractElement;
 import org.olat.modules.forms.model.xml.Form;
 import org.olat.modules.forms.model.xml.Rubric;
@@ -98,6 +99,23 @@ import org.springframework.beans.factory.annotation.Autowired;
  */
 public abstract class GroupByController extends FormBasicController implements FilterableController {
 
+	protected final static Attribute[] identicalRubricsAttributes = {
+			Attribute.sliderType,
+			Attribute.scaleType,
+			Attribute.name,
+			Attribute.start,
+			Attribute.end,
+			Attribute.steps,
+			Attribute.noResponseEnabled,
+			Attribute.lowerBoundInsufficient,
+			Attribute.upperBoundInsufficient,
+			Attribute.lowerBoundNeutral,
+			Attribute.upperBoundNeutral,
+			Attribute.lowerBoundSufficient,
+			Attribute.upperBoundSufficient,
+			Attribute.startGoodRating
+	};
+	
 	public static final int TOTAL_OFFSET = 99;
 	public static final int DATA_OFFSET = 100;
 	
@@ -336,7 +354,7 @@ public abstract class GroupByController extends FormBasicController implements F
 			
 			List<Rubric> rubrics = getSliders().stream().map(SliderWrapper::getRubric).distinct().collect(toList());
 			if (rubrics.size() > 0) {
-				KeyValues rubricKV = AnalysisUIFactory.getRubricKeyValue(getTranslator(), rubrics);
+				KeyValues rubricKV = AnalysisUIFactory.getRubricKeyValue(getTranslator(), rubrics, identicalRubricsAttributes);
 				rubricEl = uifactory.addDropdownSingleselect("trend.rubrics", groupingCont, rubricKV.keys(), rubricKV.values());
 				rubricEl.addActionListener(FormEvent.ONCHANGE);
 				if (StringHelper.containsNonWhitespace(rubricId)) {
diff --git a/src/main/java/org/olat/modules/quality/analysis/ui/HeatMapController.java b/src/main/java/org/olat/modules/quality/analysis/ui/HeatMapController.java
index 53e6247beec208dfc203a78ba014d73b42f5032e..fa9f10c8135c639408ad391fef250763894f0fb0 100644
--- a/src/main/java/org/olat/modules/quality/analysis/ui/HeatMapController.java
+++ b/src/main/java/org/olat/modules/quality/analysis/ui/HeatMapController.java
@@ -20,7 +20,6 @@
 package org.olat.modules.quality.analysis.ui;
 
 import static java.util.stream.Collectors.toList;
-import static org.olat.modules.quality.analysis.ui.AnalysisUIFactory.areIdenticalRubrics;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -32,6 +31,7 @@ import org.olat.core.gui.components.form.flexible.impl.elements.table.FlexiTable
 import org.olat.core.gui.components.form.flexible.impl.elements.table.FlexiTableDataModel;
 import org.olat.core.gui.components.stack.TooledStackedPanel;
 import org.olat.core.gui.control.WindowControl;
+import org.olat.modules.forms.RubricsComparison;
 import org.olat.modules.forms.model.xml.Form;
 import org.olat.modules.forms.model.xml.Rubric;
 import org.olat.modules.quality.analysis.AvailableAttributes;
@@ -67,7 +67,7 @@ public class HeatMapController extends GroupByController {
 		super(ureq, wControl, stackPanel, filterCtrl, evaluationForm, availableAttributes, multiGroupBy,
 				insufficientOnly, temporalGroupBy, trendDifference, rubricId);
 		List<Rubric> rubrics = getSliders().stream().map(SliderWrapper::getRubric).distinct().collect(toList());
-		this.identicalRubrics = areIdenticalRubrics(rubrics);
+		this.identicalRubrics = RubricsComparison.areIdentical(rubrics, identicalRubricsAttributes);
 	}
 
 	@Override
diff --git a/src/test/java/org/olat/modules/forms/RubricsComparisonTest.java b/src/test/java/org/olat/modules/forms/RubricsComparisonTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..92dd8b300792fa31e9c66ff880dda7e61f911b0b
--- /dev/null
+++ b/src/test/java/org/olat/modules/forms/RubricsComparisonTest.java
@@ -0,0 +1,243 @@
+/**
+ * <a href="http://www.openolat.org">
+ * OpenOLAT - Online Learning and Training</a><br>
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at the
+ * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Initial code contributed and copyrighted by<br>
+ * frentix GmbH, http://www.frentix.com
+ * <p>
+ */
+package org.olat.modules.forms;
+
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+import org.olat.modules.forms.RubricsComparison.Attribute;
+import org.olat.modules.forms.model.xml.Rubric;
+import org.olat.modules.forms.model.xml.Rubric.SliderType;
+import org.olat.modules.forms.model.xml.ScaleType;
+import org.olat.modules.forms.model.xml.Slider;
+
+/**
+ * 
+ * Initial date: 9 Jul 2019<br>
+ * @author uhensler, urs.hensler@frentix.com, http://www.frentix.com
+ *
+ */
+public class RubricsComparisonTest {
+	
+	@Test
+	public void shouldReturnIdentical() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		Rubric rubric3 = createRubric();
+		
+		Attribute[] all = RubricsComparison.Attribute.values();
+		boolean areIdentical = RubricsComparison.areIdentical(asList(rubric1, rubric2, rubric3), all);
+
+		assertThat(areIdentical).isTrue();
+	}
+	
+	@Test
+	public void shouldReturnIdenticalIfNoCheck() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		Rubric rubric3 = createRubric();
+		
+		boolean areIdentical = RubricsComparison.areIdentical(asList(rubric1, rubric2, rubric3));
+
+		assertThat(areIdentical).isTrue();
+	}
+	
+	@Test
+	public void shouldFindDifferentSliderType() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setSliderType(SliderType.discrete);
+		
+		findDifference(rubric1, rubric2, Attribute.sliderType);
+	}
+	
+	@Test
+	public void shouldFindDifferentScaleType() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setScaleType(ScaleType.maxToZero);
+		
+		findDifference(rubric1, rubric2, Attribute.scaleType);
+	}
+	
+	@Test
+	public void shouldFindDifferentName() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setName("new name");
+		
+		findDifference(rubric1, rubric2, Attribute.name);
+	}
+	
+	@Test
+	public void shouldFindDifferentStart() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setStart(3);
+		
+		findDifference(rubric1, rubric2, Attribute.start);
+	}
+	
+	@Test
+	public void shouldFindDifferentEnd() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setEnd(11);
+		
+		findDifference(rubric1, rubric2, Attribute.end);
+	}
+	
+	@Test
+	public void shouldFindDifferentSteps() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setSteps(101);
+		
+		findDifference(rubric1, rubric2, Attribute.steps);
+	}
+	
+	@Test
+	public void shouldFindDifferentNoResponseEnabled() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setNoResponseEnabled(true);
+		
+		findDifference(rubric1, rubric2, Attribute.noResponseEnabled);
+	}
+	
+	@Test
+	public void shouldFindDifferentLowerBoundInsufficient() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setLowerBoundInsufficient(null);
+		
+		findDifference(rubric1, rubric2, Attribute.lowerBoundInsufficient);
+	}
+	
+	@Test
+	public void shouldFindDifferentUpperBoundInsufficient() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setUpperBoundInsufficient(null);
+		
+		findDifference(rubric1, rubric2, Attribute.upperBoundInsufficient);
+	}
+	
+	@Test
+	public void shouldFindDifferentLowerBoundNeutral() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setLowerBoundNeutral(null);
+		
+		findDifference(rubric1, rubric2, Attribute.lowerBoundNeutral);
+	}
+	
+	@Test
+	public void shouldFindDifferentUpperBoundNeutral() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setUpperBoundNeutral(null);
+		
+		findDifference(rubric1, rubric2, Attribute.upperBoundNeutral);
+	}
+	
+	@Test
+	public void shouldFindDifferentLowerBoundSufficient() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setLowerBoundSufficient(null);
+		
+		findDifference(rubric1, rubric2, Attribute.lowerBoundSufficient);
+	}
+	
+	@Test
+	public void shouldFindDifferentUpperBoundSufficient() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setUpperBoundSufficient(null);
+		
+		findDifference(rubric1, rubric2, Attribute.upperBoundSufficient);
+	}
+	
+	@Test
+	public void shouldFindDifferentStartGoodRating() {
+		Rubric rubric1 = createRubric();
+		Rubric rubric2 = createRubric();
+		rubric2.setStartGoodRating(true);
+		
+		findDifference(rubric1, rubric2, Attribute.startGoodRating);
+	}
+	
+	@Test
+	public void shouldFindDifferentSliderWeighted() {
+		Rubric rubric1 = createRubric();
+		Slider slider1 = new Slider();
+		rubric1.setSliders(asList(slider1));
+		Rubric rubric2 = createRubric();
+		Slider slider2 = new Slider();
+		slider2.setWeight(9);
+		rubric2.setSliders(asList(slider2));
+		
+		findDifference(rubric1, rubric2, Attribute.slidersWeighted);
+	}
+	
+	@Test
+	public void shouldFindDifferentSlidersLabel() {
+		Rubric rubric1 = createRubric();
+		Slider slider1 = new Slider();
+		slider1.setStartLabel("start");
+		rubric1.setSliders(asList(slider1));
+		Rubric rubric2 = createRubric();
+		Slider slider2 = new Slider();
+		slider2.setStartLabel("start");;
+		slider2.setEndLabel("end");
+		rubric2.setSliders(asList(slider2));
+		
+		findDifference(rubric1, rubric2, Attribute.slidersLabel);
+	}
+	
+	private void findDifference(Rubric rubric1, Rubric rubric2, Attribute... attribute) {
+		boolean areIdentical = RubricsComparison.areIdentical(asList(rubric1, rubric2), attribute);
+
+		assertThat(areIdentical).isFalse();
+	}
+
+	private Rubric createRubric() {
+		Rubric rubric = new Rubric();
+		rubric.setSliderType(SliderType.continuous);
+		rubric.setScaleType(ScaleType.maxToOne);
+		rubric.setName("rubric");
+		rubric.setStart(1);
+		rubric.setEnd(10);
+		rubric.setSteps(10);
+		rubric.setNoResponseEnabled(false);
+		rubric.setLowerBoundInsufficient(1.0);
+		rubric.setUpperBoundInsufficient(4.0);
+		rubric.setLowerBoundNeutral(4.0);
+		rubric.setUpperBoundNeutral(8.0);
+		rubric.setLowerBoundSufficient(8.0);
+		rubric.setUpperBoundSufficient(10.0);
+		rubric.setStartGoodRating(false);
+		return rubric;
+	}
+
+
+}
diff --git a/src/test/java/org/olat/test/AllTestsJunit4.java b/src/test/java/org/olat/test/AllTestsJunit4.java
index 55ce51bef1ad5d7ffc1acc67ba8e6eb26bc22cdf..799b96960e09e9efaab63404d74bbc021c080dca 100644
--- a/src/test/java/org/olat/test/AllTestsJunit4.java
+++ b/src/test/java/org/olat/test/AllTestsJunit4.java
@@ -459,6 +459,7 @@ import org.junit.runners.Suite;
 	org.olat.modules.forms.manager.EvaluationFormMangerImplTest.class,
 	org.olat.modules.forms.manager.RubricStatisticCalculatorTest.class,
 	org.olat.modules.forms.model.xml.ScaleTypeTest.class,
+	org.olat.modules.forms.RubricsComparisonTest.class,
 	org.olat.modules.qpool.manager.QuestionPoolServiceImplTest.class,
 	org.olat.modules.qpool.manager.QuestionPoolUserDataDeletableTest.class,
 	org.olat.modules.qpool.manager.review.LowerLimitProviderTest.class,