commit 77453bccc55ac286a9f3f4eb4c3dd447747deba8
Author: Martin Matas <nouzovekonto@gmail.com>
Date:   Wed Apr 3 13:00:49 2019 +0200

    Indentation correction

diff --git a/sources/imiger-dot-converter/src/main/java/cz/zcu/kiv/imiger/plugin/dot/BaseGraphFactory.java b/sources/imiger-dot-converter/src/main/java/cz/zcu/kiv/imiger/plugin/dot/BaseGraphFactory.java
index fe22aed..254ef66 100644
--- a/sources/imiger-dot-converter/src/main/java/cz/zcu/kiv/imiger/plugin/dot/BaseGraphFactory.java
+++ b/sources/imiger-dot-converter/src/main/java/cz/zcu/kiv/imiger/plugin/dot/BaseGraphFactory.java
@@ -17,83 +17,83 @@ import java.util.*;
  */
 public abstract class BaseGraphFactory<V extends VertexDTO, E extends EdgeDTO> {
 
-	/**
-	 * List of vertex archetypes that must factory initialize.
-	 */
-	protected List<VertexArchetype> vertexArchetypes;
-
-	/**
-	 * List of edge archetypes that must factory initialize.
-	 */
-	protected List<EdgeArchetype> edgeArchetypes;
-
-	/**
-	 * List of defined attribute types retrieved from {@link BaseDOTLoader}.
-	 */
-	protected List<AttributeType> attributeTypes;
-
-	/**
-	 * List of defined vertices retrieved from {@link BaseDOTLoader}. {@link VertexDTO} is
-	 * specific vertex created with DOTLoader.
-	 */
-	protected List<VertexDTO> vertices;
-
-	/**
-	 * List of defined edges retrieved from {@link BaseDOTLoader}. {@link EdgeDTO} is
-	 * specific vertex created with DOTLoader.
-	 */
-	protected List<EdgeDTO> edges;
+    /**
+     * List of vertex archetypes that must factory initialize.
+     */
+    protected List<VertexArchetype> vertexArchetypes;
+
+    /**
+     * List of edge archetypes that must factory initialize.
+     */
+    protected List<EdgeArchetype> edgeArchetypes;
+
+    /**
+     * List of defined attribute types retrieved from {@link BaseDOTLoader}.
+     */
+    protected List<AttributeType> attributeTypes;
+
+    /**
+     * List of defined vertices retrieved from {@link BaseDOTLoader}. {@link VertexDTO} is
+     * specific vertex created with DOTLoader.
+     */
+    protected List<VertexDTO> vertices;
+
+    /**
+     * List of defined edges retrieved from {@link BaseDOTLoader}. {@link EdgeDTO} is
+     * specific vertex created with DOTLoader.
+     */
+    protected List<EdgeDTO> edges;
 
     /**
      * Map of possible enum values that must factory initialize.
      */
-	protected Map<Integer, List<String>> possibleEnumValues;
+    protected Map<Integer, List<String>> possibleEnumValues;
 
     /**
      * List of groups that must factory initialize.
      */
-	protected List<Group> groups;
+    protected List<Group> groups;
 
     /**
      * List of sidebars that must factory initialize.
      */
-	protected List<SideBar> sideBar;
+    protected List<SideBar> sideBar;
 
     /**
      * Edge that will be highlighted when graph loads. GraphFactory must initialize.
      */
-	protected String highlightedEdge;
+    protected String highlightedEdge;
 
     /**
      * Vertex that will be highlighted when graph loads. GraphFactory must initialize.
      */
-	protected String highlightedVertex;
-
-	/**
-	 * Constructor initialize data that can be retrieved from {@link BaseDOTLoader}, the rest of
-	 * necessary attributes for creating graph must be initialized in children of this abstract class.
-	 *
-	 * @param dotLoader - instance of {@link BaseDOTLoader} which provides parsed data from DOT file
-	 */
-	protected BaseGraphFactory(BaseDOTLoader<V, E> dotLoader) {
-		vertices = new ArrayList<>();
-		edges = new ArrayList<>();
-		attributeTypes = new ArrayList<>();
-		loadData(dotLoader);
-	}
-
-	/**
-	 * Must initialize necessary attributes for creating graph from data provided by {@link BaseDOTLoader}.
-	 *
-	 * @param dotLoader - instance of {@link BaseDOTLoader} which provides parsed data from DOT file
-	 */
-	protected abstract void loadData(BaseDOTLoader<V, E> dotLoader);
-
-	/**
-	 * Must create instance of {@link Graph} from created and retrieved data.
-	 *
-	 * @return - new graph created from prepared data
-	 */
-	public abstract Graph createGraph();
+    protected String highlightedVertex;
+
+    /**
+     * Constructor initialize data that can be retrieved from {@link BaseDOTLoader}, the rest of
+     * necessary attributes for creating graph must be initialized in children of this abstract class.
+     *
+     * @param dotLoader - instance of {@link BaseDOTLoader} which provides parsed data from DOT file
+     */
+    protected BaseGraphFactory(BaseDOTLoader<V, E> dotLoader) {
+        vertices = new ArrayList<>();
+        edges = new ArrayList<>();
+        attributeTypes = new ArrayList<>();
+        loadData(dotLoader);
+    }
+
+    /**
+     * Must initialize necessary attributes for creating graph from data provided by {@link BaseDOTLoader}.
+     *
+     * @param dotLoader - instance of {@link BaseDOTLoader} which provides parsed data from DOT file
+     */
+    protected abstract void loadData(BaseDOTLoader<V, E> dotLoader);
+
+    /**
+     * Must create instance of {@link Graph} from created and retrieved data.
+     *
+     * @return - new graph created from prepared data
+     */
+    public abstract Graph createGraph();
 
 }
diff --git a/sources/imiger-dot-converter/src/main/java/cz/zcu/kiv/imiger/plugin/dot/GraphFactory.java b/sources/imiger-dot-converter/src/main/java/cz/zcu/kiv/imiger/plugin/dot/GraphFactory.java
index a852b3a..e83aa37 100644
--- a/sources/imiger-dot-converter/src/main/java/cz/zcu/kiv/imiger/plugin/dot/GraphFactory.java
+++ b/sources/imiger-dot-converter/src/main/java/cz/zcu/kiv/imiger/plugin/dot/GraphFactory.java
@@ -16,207 +16,207 @@ import java.util.*;
  */
 public class GraphFactory extends BaseGraphFactory<VertexDTO, EdgeDTO> {
 
-	/**
-	 * Name of default edge archetype name field.
-	 */
-	private static final String EDGE_ARCHETYPE_NAME = "Edge";
-
-	/**
-	 * Name of default vertex archetype name field.
-	 */
-	private static final String VERTEX_ARCHETYPE_NAME = "Vertex";
-
-	/**
-	 * Value of default archetype text field.
-	 */
-	private static final String ARCHETYPE_TEXT = "";
-
-	/**
-	 * Index of default archetype in created archetype list.
-	 */
-	private static final int DEFAULT_ARCHETYPE_INDEX = 0;
-
-	/**
-	 * Retrieves data from {@link BaseDOTLoader} and defines archetypes for vertices and edges.
-	 *
-	 * @param dotLoader - instance of {@link BaseDOTLoader} which provides parsed data from DOT file
-	 */
-	public GraphFactory(BaseDOTLoader<VertexDTO,EdgeDTO> dotLoader) {
-		super(dotLoader);
-		prepareEdgeArchetypes();
-		prepareVertexArchetypes();
-		preparePossibleEnumValues();
-		prepareGroups();
-		prepareSideBar();
-		defineHighlightedVertex();
+    /**
+     * Name of default edge archetype name field.
+     */
+    private static final String EDGE_ARCHETYPE_NAME = "Edge";
+
+    /**
+     * Name of default vertex archetype name field.
+     */
+    private static final String VERTEX_ARCHETYPE_NAME = "Vertex";
+
+    /**
+     * Value of default archetype text field.
+     */
+    private static final String ARCHETYPE_TEXT = "";
+
+    /**
+     * Index of default archetype in created archetype list.
+     */
+    private static final int DEFAULT_ARCHETYPE_INDEX = 0;
+
+    /**
+     * Retrieves data from {@link BaseDOTLoader} and defines archetypes for vertices and edges.
+     *
+     * @param dotLoader - instance of {@link BaseDOTLoader} which provides parsed data from DOT file
+     */
+    public GraphFactory(BaseDOTLoader<VertexDTO,EdgeDTO> dotLoader) {
+        super(dotLoader);
+        prepareEdgeArchetypes();
+        prepareVertexArchetypes();
+        preparePossibleEnumValues();
+        prepareGroups();
+        prepareSideBar();
+        defineHighlightedVertex();
         defineHighlightedEdge();
-	}
-
-	/**
-	 * Initialize attributes that can be filled with data from {@link BaseDOTLoader}. In case when
-	 * DOTLoader returns uninitialized lists, attributes will be initialized empty.
-	 *
-	 * @param dotLoader - instance of {@link BaseDOTLoader} which provides parsed data from DOT file
-	 */
-	@Override
-	protected void loadData(BaseDOTLoader<VertexDTO,EdgeDTO> dotLoader) {
-		List<VertexDTO> loadedVertices = dotLoader.getVertices();
-		List<EdgeDTO> loadedEdges = dotLoader.getEdges();
-		Set<AttributeType> loadedAttributeTypes = dotLoader.getAttributeTypes();
-
-		if (loadedVertices != null) {
-			vertices = new ArrayList<>(loadedVertices);
-		}
-
-		if (loadedEdges != null) {
-			edges = new ArrayList<>(loadedEdges);
-		}
-
-		if (loadedAttributeTypes != null) {
-			attributeTypes = new ArrayList<>(loadedAttributeTypes);
-		}
-	}
-
-	/**
-	 * Creates new graph from data which were prepared when instance was created.
-	 *
-	 * @return - new instance of graph
-	 */
-	@Override
-	public Graph createGraph() {
-		Graph graph = new Graph();
-
-		graph.setEdgeArchetypes(edgeArchetypes);
-		graph.setVertexArchetypes(vertexArchetypes);
-		graph.setAttributeTypes(attributeTypes);
-		graph.setPossibleEnumValues(possibleEnumValues);
-		graph.setGroups(groups);
-		graph.setSideBar(sideBar);
-		graph.setHighlightedEdge(highlightedEdge);
-		graph.setHighlightedVertex(highlightedVertex);
-		addEdgesToGraph(graph, edges);
-		addVerticesToGraph(graph, vertices);
-
-		return graph;
-	}
-
-	/**
-	 * Iterates through the list of vertices retrieved from {@link BaseDOTLoader} and for each of them
-	 * creates new graph vertex.
-	 *
-	 * @param graph - reference to the instance of new graph
-	 * @param vertices - vertices retrieved from {@link BaseDOTLoader}
-	 */
-	private void addVerticesToGraph(Graph graph, List<VertexDTO> vertices) {
-		for (VertexDTO v : vertices) {
-
-			List<String[]> attributes = checkAttributes(v.getAttributes(), attributeTypes);
-			Vertex vertex = new Vertex(v.getId(), v.getName(), DEFAULT_ARCHETYPE_INDEX, "", attributes);
-			graph.getVertices().add(vertex);
-		}
-	}
-
-	/**
-	 * Iterates through the list of edges retrieved from {@link BaseDOTLoader} and for each of them
-	 * creates new graph edge.
-	 *
-	 * @param graph - reference to the instance of new graph
-	 * @param edges - edges retrieved from {@link BaseDOTLoader}
-	 */
-	private void addEdgesToGraph(Graph graph, List<EdgeDTO> edges) {
-		for (EdgeDTO e : edges) {
-
-			List<String[]> attributes = checkAttributes(e.getAttributes(), attributeTypes);
-			SubedgeInfo subedgeInfo = new SubedgeInfo(e.getId(), DEFAULT_ARCHETYPE_INDEX, attributes);
-
-			List<SubedgeInfo> subedgeInfos = new ArrayList<>();
-			subedgeInfos.add(subedgeInfo);
-
-			Edge edge = new Edge(e.getId(), e.getIdFrom(), e.getIdTo(), e.getName(), subedgeInfos);
-			graph.getEdges().add(edge);
-		}
-	}
-
-	/**
-	 * Iterates through the list of attributes and for each of them checks if the attribute type exists. Then for the
-	 * attribute creates key-value pair using {@link String[]}, where key is the attribute type and value is the
-	 * value of attribute.
-	 *
-	 * @param uncheckedAttributes - map of attributes retrieved from {@link BaseDOTLoader}, where key is unchecked
-	 *                            attribute type and value is the value of attribute
-	 * @param attributeTypes - list of attribute types retrieved from {@link BaseDOTLoader} against which will be unchecked
-	 *                       attributes validated
-	 * @return - list of checked attributes
-	 */
-	private List<String[]> checkAttributes(Map<String, String> uncheckedAttributes, List<AttributeType> attributeTypes) {
-		List<String[]> attributes = new ArrayList<>();
-		Set<String> attributesHashSet = new HashSet<>();
-
-		attributeTypes.forEach(t -> attributesHashSet.add(t.getName()));
-
-		for (Map.Entry<String, String> e: uncheckedAttributes.entrySet()) {
-			if (attributesHashSet.contains(e.getKey())) {
-				attributes.add(new String[]{e.getKey(), e.getValue()});
-			}
-		}
-
-		return attributes;
-	}
-
-	/**
-	 * Defines default edge archetype for edges.
-	 */
-	private void prepareEdgeArchetypes() {
-		edgeArchetypes = new ArrayList<>();
-		edgeArchetypes.add(new EdgeArchetype(EDGE_ARCHETYPE_NAME, ARCHETYPE_TEXT));
-	}
-
-	/**
-	 * Defines default vertex archetypes for vertices.
-	 */
-	private void prepareVertexArchetypes() {
-		vertexArchetypes = new ArrayList<>();
-		vertexArchetypes.add(new VertexArchetype(VERTEX_ARCHETYPE_NAME, ARCHETYPE_TEXT));
-	}
+    }
+
+    /**
+     * Initialize attributes that can be filled with data from {@link BaseDOTLoader}. In case when
+     * DOTLoader returns uninitialized lists, attributes will be initialized empty.
+     *
+     * @param dotLoader - instance of {@link BaseDOTLoader} which provides parsed data from DOT file
+     */
+    @Override
+    protected void loadData(BaseDOTLoader<VertexDTO,EdgeDTO> dotLoader) {
+        List<VertexDTO> loadedVertices = dotLoader.getVertices();
+        List<EdgeDTO> loadedEdges = dotLoader.getEdges();
+        Set<AttributeType> loadedAttributeTypes = dotLoader.getAttributeTypes();
+
+        if (loadedVertices != null) {
+            vertices = new ArrayList<>(loadedVertices);
+        }
+
+        if (loadedEdges != null) {
+            edges = new ArrayList<>(loadedEdges);
+        }
+
+        if (loadedAttributeTypes != null) {
+            attributeTypes = new ArrayList<>(loadedAttributeTypes);
+        }
+    }
+
+    /**
+     * Creates new graph from data which were prepared when instance was created.
+     *
+     * @return - new instance of graph
+     */
+    @Override
+    public Graph createGraph() {
+        Graph graph = new Graph();
+
+        graph.setEdgeArchetypes(edgeArchetypes);
+        graph.setVertexArchetypes(vertexArchetypes);
+        graph.setAttributeTypes(attributeTypes);
+        graph.setPossibleEnumValues(possibleEnumValues);
+        graph.setGroups(groups);
+        graph.setSideBar(sideBar);
+        graph.setHighlightedEdge(highlightedEdge);
+        graph.setHighlightedVertex(highlightedVertex);
+        addEdgesToGraph(graph, edges);
+        addVerticesToGraph(graph, vertices);
+
+        return graph;
+    }
+
+    /**
+     * Iterates through the list of vertices retrieved from {@link BaseDOTLoader} and for each of them
+     * creates new graph vertex.
+     *
+     * @param graph - reference to the instance of new graph
+     * @param vertices - vertices retrieved from {@link BaseDOTLoader}
+     */
+    private void addVerticesToGraph(Graph graph, List<VertexDTO> vertices) {
+        for (VertexDTO v : vertices) {
+
+            List<String[]> attributes = checkAttributes(v.getAttributes(), attributeTypes);
+            Vertex vertex = new Vertex(v.getId(), v.getName(), DEFAULT_ARCHETYPE_INDEX, "", attributes);
+            graph.getVertices().add(vertex);
+        }
+    }
+
+    /**
+     * Iterates through the list of edges retrieved from {@link BaseDOTLoader} and for each of them
+     * creates new graph edge.
+     *
+     * @param graph - reference to the instance of new graph
+     * @param edges - edges retrieved from {@link BaseDOTLoader}
+     */
+    private void addEdgesToGraph(Graph graph, List<EdgeDTO> edges) {
+        for (EdgeDTO e : edges) {
+
+            List<String[]> attributes = checkAttributes(e.getAttributes(), attributeTypes);
+            SubedgeInfo subedgeInfo = new SubedgeInfo(e.getId(), DEFAULT_ARCHETYPE_INDEX, attributes);
+
+            List<SubedgeInfo> subedgeInfos = new ArrayList<>();
+            subedgeInfos.add(subedgeInfo);
+
+            Edge edge = new Edge(e.getId(), e.getIdFrom(), e.getIdTo(), e.getName(), subedgeInfos);
+            graph.getEdges().add(edge);
+        }
+    }
+
+    /**
+     * Iterates through the list of attributes and for each of them checks if the attribute type exists. Then for the
+     * attribute creates key-value pair using {@link String[]}, where key is the attribute type and value is the
+     * value of attribute.
+     *
+     * @param uncheckedAttributes - map of attributes retrieved from {@link BaseDOTLoader}, where key is unchecked
+     *                            attribute type and value is the value of attribute
+     * @param attributeTypes - list of attribute types retrieved from {@link BaseDOTLoader} against which will be unchecked
+     *                       attributes validated
+     * @return - list of checked attributes
+     */
+    private List<String[]> checkAttributes(Map<String, String> uncheckedAttributes, List<AttributeType> attributeTypes) {
+        List<String[]> attributes = new ArrayList<>();
+        Set<String> attributesHashSet = new HashSet<>();
+
+        attributeTypes.forEach(t -> attributesHashSet.add(t.getName()));
+
+        for (Map.Entry<String, String> e: uncheckedAttributes.entrySet()) {
+            if (attributesHashSet.contains(e.getKey())) {
+                attributes.add(new String[]{e.getKey(), e.getValue()});
+            }
+        }
+
+        return attributes;
+    }
+
+    /**
+     * Defines default edge archetype for edges.
+     */
+    private void prepareEdgeArchetypes() {
+        edgeArchetypes = new ArrayList<>();
+        edgeArchetypes.add(new EdgeArchetype(EDGE_ARCHETYPE_NAME, ARCHETYPE_TEXT));
+    }
+
+    /**
+     * Defines default vertex archetypes for vertices.
+     */
+    private void prepareVertexArchetypes() {
+        vertexArchetypes = new ArrayList<>();
+        vertexArchetypes.add(new VertexArchetype(VERTEX_ARCHETYPE_NAME, ARCHETYPE_TEXT));
+    }
 
     /**
      * Defines default map of possible enum values.
      */
-	private void preparePossibleEnumValues() {
-		possibleEnumValues = new HashMap<>();
-	}
+    private void preparePossibleEnumValues() {
+        possibleEnumValues = new HashMap<>();
+    }
 
 
     /**
      * Defines default list fo groups.
      */
-	private void prepareGroups() {
-		groups = new ArrayList<>();
-	}
+    private void prepareGroups() {
+        groups = new ArrayList<>();
+    }
 
 
     /**
      * Defines default list of sidebars.
      */
-	private void prepareSideBar() {
-		sideBar = new ArrayList<>();
-	}
+    private void prepareSideBar() {
+        sideBar = new ArrayList<>();
+    }
 
 
     /**
      * Defines default highlighted edge. Empty string means that no edge will be highlighted
      * when graph loads.
      */
-	private void defineHighlightedEdge() {
-		highlightedEdge = "";
-	}
+    private void defineHighlightedEdge() {
+        highlightedEdge = "";
+    }
 
     /**
      * Defines default highlighted vertex. Empty string means that no vertex will be highlighted
      * when graph loads.
      */
-	private void defineHighlightedVertex() {
-		highlightedVertex = "";
-	}
+    private void defineHighlightedVertex() {
+        highlightedVertex = "";
+    }
 
 }
diff --git a/sources/imiger-dot-converter/src/test/java/cz/zcu/kiv/imiger/plugin/dot/GraphFactoryTest.java b/sources/imiger-dot-converter/src/test/java/cz/zcu/kiv/imiger/plugin/dot/GraphFactoryTest.java
index 7c2fd12..5875a03 100644
--- a/sources/imiger-dot-converter/src/test/java/cz/zcu/kiv/imiger/plugin/dot/GraphFactoryTest.java
+++ b/sources/imiger-dot-converter/src/test/java/cz/zcu/kiv/imiger/plugin/dot/GraphFactoryTest.java
@@ -29,236 +29,236 @@ import static org.mockito.Mockito.when;
 @RunWith(MockitoJUnitRunner.class)
 public class GraphFactoryTest {
 
-	/** Name of attribute type */
-	private static final String ATTR_TYPE_NAME = "test";
-
-	/** Text of attribute type */
-	private static final String ATTR_TYPE_TEXT = "test attribute type";
-
-	/** List index / Attribute identifier */
-	private static final int ATTR_TYPE_ID = 0;
-
-	/** Vertex / Edge attribute value */
-	private static final String ATTR_VALUE = "test value";
-
-	/** Vertices names */
-	private static final String VERTEX_A = "A";
-	private static final String VERTEX_B = "B";
-
-	/** Lists indexes / Vertices identifiers */
-	private static final int VERTEX_A_ID = 0;
-	private static final int VERTEX_B_ID = 1;
-
-	/** Edge name */
-	private static final String EDGE_AB = "A-B";
-
-	/** Edge identifier */
-	private static final int EDGE_AB_ID = 0;
-
-	/** Archetypes names */
-	private static final String EDGE_ARCHETYPE = "Edge";
-	private static final String VERTEX_ARCHETYPE = "Vertex";
-
-	private static final boolean EMPTY_UNUSED_CLASS_ATTR = true;
-
-	/**
-	 * Mock object of {@link BaseDOTLoader}.
-	 */
-	@Mock
-	private BaseDOTLoader<VertexDTO, EdgeDTO> loaderMock;
-
-	/**
-	 * Expects that retrieves correct non-empty data from DOTLoader.
-	 */
-	@Test
-	public void loadDataFromCorrectLoader() {
-		final int expectedAttributeTypeSize = 1, expectedEdgesSize = 1, expectedVerticesSize = 2;
-
-		initCorrectLoader();
-		BaseGraphFactory<VertexDTO, EdgeDTO> factory = new GraphFactory(loaderMock);
-
-		// test method logic
-		verify(loaderMock).getAttributeTypes();
-		verify(loaderMock).getEdges();
-		verify(loaderMock).getVertices();
-		// test attributes initialization
-		assertThat(factory.attributeTypes.size(), is(expectedAttributeTypeSize));
-		assertThat(factory.edges.size(), is(expectedEdgesSize));
-		assertThat(factory.vertices.size(), is(expectedVerticesSize));
-		assertThat(factory.edgeArchetypes, is(not(nullValue())));
-		assertThat(factory.vertexArchetypes, is(not(nullValue())));
-		assertThat(factory.possibleEnumValues, is(not(nullValue())));
-		assertThat(factory.groups, is(not(nullValue())));
-		assertThat(factory.sideBar, is(not(nullValue())));
-		assertThat(factory.highlightedEdge, is(not(nullValue())));
-		assertThat(factory.highlightedVertex, is(not(nullValue())));
-		// test attribute type
-		assertThat(factory.attributeTypes.get(ATTR_TYPE_ID).getName(), is(equalTo(ATTR_TYPE_NAME)));
-		assertThat(factory.attributeTypes.get(ATTR_TYPE_ID).getText(), is(equalTo(ATTR_TYPE_TEXT)));
-		// test vertices
-		assertThat(factory.vertices.get(VERTEX_A_ID).getName(), is(equalTo(VERTEX_A)));
-		assertThat(factory.vertices.get(VERTEX_A_ID).getAttributes().get(ATTR_TYPE_NAME), is(equalTo(ATTR_VALUE)));
-		assertThat(factory.vertices.get(VERTEX_B_ID).getName(), is(equalTo(VERTEX_B)));
-		assertThat(factory.vertices.get(VERTEX_B_ID).getAttributes().get(ATTR_TYPE_NAME), is(equalTo(ATTR_VALUE)));
-		// test edges
-		assertThat(factory.edges.get(EDGE_AB_ID).getName(), is(equalTo(EDGE_AB)));
-		// test archetypes
-		assertThat(factory.edgeArchetypes.get(0).getName(), is(equalTo(EDGE_ARCHETYPE)));
-		assertThat(factory.vertexArchetypes.get(0).getName(), is(equalTo(VERTEX_ARCHETYPE)));
-		// the rest of required but unused attributes
-		assertThat(factory.possibleEnumValues.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-		assertThat(factory.groups.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-		assertThat(factory.sideBar.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-		assertThat(factory.highlightedEdge.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-		assertThat(factory.highlightedVertex.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-	}
-
-	/**
-	 * Expects that retrieves empty data from DOTLoader. In that case all factory attributes
-	 * will empty except archetypes that will be created in factory.
-	 */
-	@Test
-	public void loadDataFromEmptyLoader() {
-		final int expectedAttributeTypeSize = 0, expectedEdgesSize = 0, expectedVerticesSize = 0;
-
-		initEmptyLoader();
-		BaseGraphFactory<VertexDTO, EdgeDTO> factory = new GraphFactory(loaderMock);
-
-		verify(loaderMock).getAttributeTypes();
-		verify(loaderMock).getEdges();
-		verify(loaderMock).getVertices();
-
-		assertThat(factory.attributeTypes.size(), is(expectedAttributeTypeSize));
-		assertThat(factory.edges.size(), is(expectedEdgesSize));
-		assertThat(factory.vertices.size(), is(expectedVerticesSize));
-		assertThat(factory.edgeArchetypes, is(not(nullValue())));
-		assertThat(factory.vertexArchetypes, is(not(nullValue())));
-		assertThat(factory.possibleEnumValues, is(not(nullValue())));
-		assertThat(factory.groups, is(not(nullValue())));
-		assertThat(factory.sideBar, is(not(nullValue())));
-		assertThat(factory.highlightedEdge, is(not(nullValue())));
-		assertThat(factory.highlightedVertex, is(not(nullValue())));
-	}
-
-	/**
-	 * Expects that retrieves uninitialized data from DOTLoader. In that case all factory attributes
-	 * will be initialized empty except archetypes that will be created in factory.
-	 */
-	@Test
-	public void loadDataFromIncorrectLoader() {
-		final int expectedAttributeTypeSize = 0, expectedEdgesSize = 0, expectedVerticesSize = 0;
-
-		initNullValueLoader();
-		BaseGraphFactory<VertexDTO, EdgeDTO> factory = new GraphFactory(loaderMock);
-
-		verify(loaderMock).getAttributeTypes();
-		verify(loaderMock).getEdges();
-		verify(loaderMock).getVertices();
-
-		assertThat(factory.attributeTypes.size(), is(expectedAttributeTypeSize));
-		assertThat(factory.edges.size(), is(expectedEdgesSize));
-		assertThat(factory.vertices.size(), is(expectedVerticesSize));
-		assertThat(factory.edgeArchetypes, is(not(nullValue())));
-		assertThat(factory.vertexArchetypes, is(not(nullValue())));
-		assertThat(factory.possibleEnumValues, is(not(nullValue())));
-		assertThat(factory.groups, is(not(nullValue())));
-		assertThat(factory.sideBar, is(not(nullValue())));
-		assertThat(factory.highlightedEdge, is(not(nullValue())));
-		assertThat(factory.highlightedVertex, is(not(nullValue())));
-	}
-
-	/**
-	 * Tests correct creation of the graph instance. Especially vertex's and edge's attributes must be in
-	 * correct form.
-	 */
-	@Test
-	public void createGraph() {
-		final int expectedAttributeTypeSize = 1, expectedEdgesSize = 1, expectedVerticesSize = 2;
-
-		// correct loader initialized
-		initCorrectLoader();
-		// loaded data from loader
-		BaseGraphFactory<VertexDTO, EdgeDTO> factory = new GraphFactory(loaderMock);
-
-		// final graph
-		Graph graph = factory.createGraph();
-
-		assertThat(graph, is(not(nullValue())));
-		assertThat(graph.getAttributeTypes().size(), is(expectedAttributeTypeSize));
-		assertThat(graph.getEdges().size(), is(expectedEdgesSize));
-		assertThat(graph.getVertices().size(), is(expectedVerticesSize));
-		assertThat(graph.getEdgeArchetypes(), is(not(nullValue())));
-		assertThat(graph.getVertexArchetypes(), is(not(nullValue())));
-		// test attribute type
-		assertThat(graph.getAttributeTypes().get(ATTR_TYPE_ID).getName(), is(equalTo(ATTR_TYPE_NAME)));
-		assertThat(graph.getAttributeTypes().get(ATTR_TYPE_ID).getText(), is(equalTo(ATTR_TYPE_TEXT)));
-		// test vertices
-		Iterator<Vertex> iterator = graph.getVertices().iterator();
-		Vertex a = iterator.next();
-		Vertex b = iterator.next();
-		assertThat(a.getName(), is(equalTo(VERTEX_A)));
-		assertThat(a.getAttributes().get(0)[0], is(equalTo(ATTR_TYPE_NAME)));
-		assertThat(a.getAttributes().get(0)[1], is(equalTo(ATTR_VALUE)));
-		assertThat(b.getName(), is(equalTo(VERTEX_B)));
-		assertThat(b.getAttributes().get(0)[0], is(equalTo(ATTR_TYPE_NAME)));
-		assertThat(b.getAttributes().get(0)[1], is(equalTo(ATTR_VALUE)));
-		// test edges
-		assertThat(graph.getEdges().get(EDGE_AB_ID).getText(), is(equalTo(EDGE_AB)));
-		assertThat(graph.getEdges().get(EDGE_AB_ID).getSubedgeInfo().get(0).getAttributes().get(0)[0], is(equalTo(ATTR_TYPE_NAME)));
-		assertThat(graph.getEdges().get(EDGE_AB_ID).getSubedgeInfo().get(0).getAttributes().get(0)[1], is(equalTo(ATTR_VALUE)));
-		// test archetypes
-		assertThat(graph.getEdgeArchetypes().get(0).getName(), is(equalTo(EDGE_ARCHETYPE)));
-		assertThat(graph.getVertexArchetypes().get(0).getName(), is(equalTo(VERTEX_ARCHETYPE)));
-		// the rest of required but unused attributes
-		assertThat(graph.getPossibleEnumValues().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-		assertThat(graph.getGroups().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-		assertThat(graph.getSideBar().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-		assertThat(graph.getHighlightedEdge().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-		assertThat(graph.getHighlightedVertex().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
-	}
-
-	/**
-	 * Initializes loader with correct data.
-	 */
-	private void initCorrectLoader() {
-		HashMap<String, String> map = new HashMap<>();
-		map.put(ATTR_TYPE_NAME, ATTR_VALUE);
-
-		Set<AttributeType> attributeTypes = new HashSet<>();
-		attributeTypes.add(new AttributeType(ATTR_TYPE_NAME, AttributeDataType.STRING, ATTR_TYPE_TEXT));
-
-		List<VertexDTO> vertices = new ArrayList<>();
-		vertices.add(new VertexDTO(VERTEX_A, VERTEX_A_ID, map));
-		vertices.add(new VertexDTO(VERTEX_B, VERTEX_B_ID, map));
-
-		List<EdgeDTO> edges = new ArrayList<>();
-		edges.add(new EdgeDTO(EDGE_AB, VERTEX_A_ID, VERTEX_B_ID, EDGE_AB_ID, map));
-
-		when(loaderMock.getAttributeTypes()).thenReturn(attributeTypes);
-		when(loaderMock.getVertices()).thenReturn(vertices);
-		when(loaderMock.getEdges()).thenReturn(edges);
-	}
-
-	/**
-	 * Initializes loader for returning empty data.
-	 */
-	private void initEmptyLoader() {
-		Set<AttributeType> attributeTypes = new HashSet<>();
-		List<VertexDTO> vertices = new ArrayList<>();
-		List<EdgeDTO> edges = new ArrayList<>();
-
-		when(loaderMock.getAttributeTypes()).thenReturn(attributeTypes);
-		when(loaderMock.getVertices()).thenReturn(vertices);
-		when(loaderMock.getEdges()).thenReturn(edges);
-	}
-
-	/**
-	 * Initializes loader for returning uninitialized data.
-	 */
-	private void initNullValueLoader() {
-		when(loaderMock.getAttributeTypes()).thenReturn(null);
-		when(loaderMock.getVertices()).thenReturn(null);
-		when(loaderMock.getEdges()).thenReturn(null);
-	}
+    /** Name of attribute type */
+    private static final String ATTR_TYPE_NAME = "test";
+
+    /** Text of attribute type */
+    private static final String ATTR_TYPE_TEXT = "test attribute type";
+
+    /** List index / Attribute identifier */
+    private static final int ATTR_TYPE_ID = 0;
+
+    /** Vertex / Edge attribute value */
+    private static final String ATTR_VALUE = "test value";
+
+    /** Vertices names */
+    private static final String VERTEX_A = "A";
+    private static final String VERTEX_B = "B";
+
+    /** Lists indexes / Vertices identifiers */
+    private static final int VERTEX_A_ID = 0;
+    private static final int VERTEX_B_ID = 1;
+
+    /** Edge name */
+    private static final String EDGE_AB = "A-B";
+
+    /** Edge identifier */
+    private static final int EDGE_AB_ID = 0;
+
+    /** Archetypes names */
+    private static final String EDGE_ARCHETYPE = "Edge";
+    private static final String VERTEX_ARCHETYPE = "Vertex";
+
+    private static final boolean EMPTY_UNUSED_CLASS_ATTR = true;
+
+    /**
+     * Mock object of {@link BaseDOTLoader}.
+     */
+    @Mock
+    private BaseDOTLoader<VertexDTO, EdgeDTO> loaderMock;
+
+    /**
+     * Expects that retrieves correct non-empty data from DOTLoader.
+     */
+    @Test
+    public void loadDataFromCorrectLoader() {
+        final int expectedAttributeTypeSize = 1, expectedEdgesSize = 1, expectedVerticesSize = 2;
+
+        initCorrectLoader();
+        BaseGraphFactory<VertexDTO, EdgeDTO> factory = new GraphFactory(loaderMock);
+
+        // test method logic
+        verify(loaderMock).getAttributeTypes();
+        verify(loaderMock).getEdges();
+        verify(loaderMock).getVertices();
+        // test attributes initialization
+        assertThat(factory.attributeTypes.size(), is(expectedAttributeTypeSize));
+        assertThat(factory.edges.size(), is(expectedEdgesSize));
+        assertThat(factory.vertices.size(), is(expectedVerticesSize));
+        assertThat(factory.edgeArchetypes, is(not(nullValue())));
+        assertThat(factory.vertexArchetypes, is(not(nullValue())));
+        assertThat(factory.possibleEnumValues, is(not(nullValue())));
+        assertThat(factory.groups, is(not(nullValue())));
+        assertThat(factory.sideBar, is(not(nullValue())));
+        assertThat(factory.highlightedEdge, is(not(nullValue())));
+        assertThat(factory.highlightedVertex, is(not(nullValue())));
+        // test attribute type
+        assertThat(factory.attributeTypes.get(ATTR_TYPE_ID).getName(), is(equalTo(ATTR_TYPE_NAME)));
+        assertThat(factory.attributeTypes.get(ATTR_TYPE_ID).getText(), is(equalTo(ATTR_TYPE_TEXT)));
+        // test vertices
+        assertThat(factory.vertices.get(VERTEX_A_ID).getName(), is(equalTo(VERTEX_A)));
+        assertThat(factory.vertices.get(VERTEX_A_ID).getAttributes().get(ATTR_TYPE_NAME), is(equalTo(ATTR_VALUE)));
+        assertThat(factory.vertices.get(VERTEX_B_ID).getName(), is(equalTo(VERTEX_B)));
+        assertThat(factory.vertices.get(VERTEX_B_ID).getAttributes().get(ATTR_TYPE_NAME), is(equalTo(ATTR_VALUE)));
+        // test edges
+        assertThat(factory.edges.get(EDGE_AB_ID).getName(), is(equalTo(EDGE_AB)));
+        // test archetypes
+        assertThat(factory.edgeArchetypes.get(0).getName(), is(equalTo(EDGE_ARCHETYPE)));
+        assertThat(factory.vertexArchetypes.get(0).getName(), is(equalTo(VERTEX_ARCHETYPE)));
+        // the rest of required but unused attributes
+        assertThat(factory.possibleEnumValues.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+        assertThat(factory.groups.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+        assertThat(factory.sideBar.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+        assertThat(factory.highlightedEdge.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+        assertThat(factory.highlightedVertex.isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+    }
+
+    /**
+     * Expects that retrieves empty data from DOTLoader. In that case all factory attributes
+     * will empty except archetypes that will be created in factory.
+     */
+    @Test
+    public void loadDataFromEmptyLoader() {
+        final int expectedAttributeTypeSize = 0, expectedEdgesSize = 0, expectedVerticesSize = 0;
+
+        initEmptyLoader();
+        BaseGraphFactory<VertexDTO, EdgeDTO> factory = new GraphFactory(loaderMock);
+
+        verify(loaderMock).getAttributeTypes();
+        verify(loaderMock).getEdges();
+        verify(loaderMock).getVertices();
+
+        assertThat(factory.attributeTypes.size(), is(expectedAttributeTypeSize));
+        assertThat(factory.edges.size(), is(expectedEdgesSize));
+        assertThat(factory.vertices.size(), is(expectedVerticesSize));
+        assertThat(factory.edgeArchetypes, is(not(nullValue())));
+        assertThat(factory.vertexArchetypes, is(not(nullValue())));
+        assertThat(factory.possibleEnumValues, is(not(nullValue())));
+        assertThat(factory.groups, is(not(nullValue())));
+        assertThat(factory.sideBar, is(not(nullValue())));
+        assertThat(factory.highlightedEdge, is(not(nullValue())));
+        assertThat(factory.highlightedVertex, is(not(nullValue())));
+    }
+
+    /**
+     * Expects that retrieves uninitialized data from DOTLoader. In that case all factory attributes
+     * will be initialized empty except archetypes that will be created in factory.
+     */
+    @Test
+    public void loadDataFromIncorrectLoader() {
+        final int expectedAttributeTypeSize = 0, expectedEdgesSize = 0, expectedVerticesSize = 0;
+
+        initNullValueLoader();
+        BaseGraphFactory<VertexDTO, EdgeDTO> factory = new GraphFactory(loaderMock);
+
+        verify(loaderMock).getAttributeTypes();
+        verify(loaderMock).getEdges();
+        verify(loaderMock).getVertices();
+
+        assertThat(factory.attributeTypes.size(), is(expectedAttributeTypeSize));
+        assertThat(factory.edges.size(), is(expectedEdgesSize));
+        assertThat(factory.vertices.size(), is(expectedVerticesSize));
+        assertThat(factory.edgeArchetypes, is(not(nullValue())));
+        assertThat(factory.vertexArchetypes, is(not(nullValue())));
+        assertThat(factory.possibleEnumValues, is(not(nullValue())));
+        assertThat(factory.groups, is(not(nullValue())));
+        assertThat(factory.sideBar, is(not(nullValue())));
+        assertThat(factory.highlightedEdge, is(not(nullValue())));
+        assertThat(factory.highlightedVertex, is(not(nullValue())));
+    }
+
+    /**
+     * Tests correct creation of the graph instance. Especially vertex's and edge's attributes must be in
+     * correct form.
+     */
+    @Test
+    public void createGraph() {
+        final int expectedAttributeTypeSize = 1, expectedEdgesSize = 1, expectedVerticesSize = 2;
+
+        // correct loader initialized
+        initCorrectLoader();
+        // loaded data from loader
+        BaseGraphFactory<VertexDTO, EdgeDTO> factory = new GraphFactory(loaderMock);
+
+        // final graph
+        Graph graph = factory.createGraph();
+
+        assertThat(graph, is(not(nullValue())));
+        assertThat(graph.getAttributeTypes().size(), is(expectedAttributeTypeSize));
+        assertThat(graph.getEdges().size(), is(expectedEdgesSize));
+        assertThat(graph.getVertices().size(), is(expectedVerticesSize));
+        assertThat(graph.getEdgeArchetypes(), is(not(nullValue())));
+        assertThat(graph.getVertexArchetypes(), is(not(nullValue())));
+        // test attribute type
+        assertThat(graph.getAttributeTypes().get(ATTR_TYPE_ID).getName(), is(equalTo(ATTR_TYPE_NAME)));
+        assertThat(graph.getAttributeTypes().get(ATTR_TYPE_ID).getText(), is(equalTo(ATTR_TYPE_TEXT)));
+        // test vertices
+        Iterator<Vertex> iterator = graph.getVertices().iterator();
+        Vertex a = iterator.next();
+        Vertex b = iterator.next();
+        assertThat(a.getName(), is(equalTo(VERTEX_A)));
+        assertThat(a.getAttributes().get(0)[0], is(equalTo(ATTR_TYPE_NAME)));
+        assertThat(a.getAttributes().get(0)[1], is(equalTo(ATTR_VALUE)));
+        assertThat(b.getName(), is(equalTo(VERTEX_B)));
+        assertThat(b.getAttributes().get(0)[0], is(equalTo(ATTR_TYPE_NAME)));
+        assertThat(b.getAttributes().get(0)[1], is(equalTo(ATTR_VALUE)));
+        // test edges
+        assertThat(graph.getEdges().get(EDGE_AB_ID).getText(), is(equalTo(EDGE_AB)));
+        assertThat(graph.getEdges().get(EDGE_AB_ID).getSubedgeInfo().get(0).getAttributes().get(0)[0], is(equalTo(ATTR_TYPE_NAME)));
+        assertThat(graph.getEdges().get(EDGE_AB_ID).getSubedgeInfo().get(0).getAttributes().get(0)[1], is(equalTo(ATTR_VALUE)));
+        // test archetypes
+        assertThat(graph.getEdgeArchetypes().get(0).getName(), is(equalTo(EDGE_ARCHETYPE)));
+        assertThat(graph.getVertexArchetypes().get(0).getName(), is(equalTo(VERTEX_ARCHETYPE)));
+        // the rest of required but unused attributes
+        assertThat(graph.getPossibleEnumValues().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+        assertThat(graph.getGroups().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+        assertThat(graph.getSideBar().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+        assertThat(graph.getHighlightedEdge().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+        assertThat(graph.getHighlightedVertex().isEmpty(), is(equalTo(EMPTY_UNUSED_CLASS_ATTR)));
+    }
+
+    /**
+     * Initializes loader with correct data.
+     */
+    private void initCorrectLoader() {
+        HashMap<String, String> map = new HashMap<>();
+        map.put(ATTR_TYPE_NAME, ATTR_VALUE);
+
+        Set<AttributeType> attributeTypes = new HashSet<>();
+        attributeTypes.add(new AttributeType(ATTR_TYPE_NAME, AttributeDataType.STRING, ATTR_TYPE_TEXT));
+
+        List<VertexDTO> vertices = new ArrayList<>();
+        vertices.add(new VertexDTO(VERTEX_A, VERTEX_A_ID, map));
+        vertices.add(new VertexDTO(VERTEX_B, VERTEX_B_ID, map));
+
+        List<EdgeDTO> edges = new ArrayList<>();
+        edges.add(new EdgeDTO(EDGE_AB, VERTEX_A_ID, VERTEX_B_ID, EDGE_AB_ID, map));
+
+        when(loaderMock.getAttributeTypes()).thenReturn(attributeTypes);
+        when(loaderMock.getVertices()).thenReturn(vertices);
+        when(loaderMock.getEdges()).thenReturn(edges);
+    }
+
+    /**
+     * Initializes loader for returning empty data.
+     */
+    private void initEmptyLoader() {
+        Set<AttributeType> attributeTypes = new HashSet<>();
+        List<VertexDTO> vertices = new ArrayList<>();
+        List<EdgeDTO> edges = new ArrayList<>();
+
+        when(loaderMock.getAttributeTypes()).thenReturn(attributeTypes);
+        when(loaderMock.getVertices()).thenReturn(vertices);
+        when(loaderMock.getEdges()).thenReturn(edges);
+    }
+
+    /**
+     * Initializes loader for returning uninitialized data.
+     */
+    private void initNullValueLoader() {
+        when(loaderMock.getAttributeTypes()).thenReturn(null);
+        when(loaderMock.getVertices()).thenReturn(null);
+        when(loaderMock.getEdges()).thenReturn(null);
+    }
 
 }
\ No newline at end of file
