private Graph<Integer, DefaultEdge> createGraph() {
    Class<? extends DefaultEdge> edgeClass =
            model.weighted() ? DefaultWeightedEdge.class : DefaultEdge.class;

    if (model.loops()) {
        if (model.multiGraph() == false) {
            throw new IllegalArgumentException("Self-loops are only supported " +
                    "with multi-graphs");
        }
        if (isDirected()) {
            if (model.weighted()) {
                return new DirectedWeightedPseudograph<>(edgeClass);
            } else {
                return new DirectedPseudograph<>(edgeClass);
            }
        } else {
            if (model.weighted()) {
                return new WeightedPseudograph<>(edgeClass);
            } else {
                return new Pseudograph<>(edgeClass);
            }
        }
    } else {
        if (model.multiGraph()) {
            if (isDirected()) {
                if (model.weighted()) {
                    return new DirectedWeightedMultigraph<>(edgeClass);
                } else {
                    return new DirectedMultigraph<>(edgeClass);
                }
            } else {
                if (model.weighted()) {
                    return new WeightedMultigraph<>(edgeClass);
                } else {
                    return new Multigraph<>(edgeClass);
                }
            }
        } else {
            if (isDirected()) {
                if (model.weighted()) {
                    return new SimpleDirectedWeightedGraph<>(edgeClass);
                } else {
                    return new SimpleDirectedGraph<>(edgeClass);
                }
            } else {
                if (model.weighted()) {
                    return new SimpleWeightedGraph<>(edgeClass);
                } else {
                    return new SimpleGraph<>(edgeClass);
                }
            }
        }
    }

}
 

@Test
public void testStateGraphDotOutput() throws IOException, ImportException {
    URL stateGraphDotFileUrl = Resources.getResource("state-graph.dot");
    String expectedStateGraphDot = Resources.toString(stateGraphDotFileUrl, StandardCharsets.UTF_8);

    StringWriter sw = new StringWriter();
    PrintWriter pw  = new PrintWriter(sw);
    ModularXmppClientToServerConnectionTool.printStateGraph(pw, false);
    String currentStateGraphDot = sw.toString();

    @SuppressWarnings("serial")
    DOTImporter<String, DefaultEdge> dotImporter = new DOTImporter<>(
            (id, attributes) -> id,
            (from, to, label, attributes) -> {
                    return new DefaultEdge() {
                        @Override
                        public int hashCode() {
                            return HashCode.builder()
                                    .append(getSource())
                                    .append(getTarget())
                                    .build();
                        }

                        @Override
                        public boolean equals(Object other) {
                            return EqualsUtil.equals(this, other, (b, o) ->
                                b.append(getSource(), o.getSource())
                                 .append(getTarget(), o.getTarget())
                            );
                        }
                    };
                }
            );

    DirectedPseudograph<String, DefaultEdge> currentStateGraph = new DirectedPseudograph<>(DefaultEdge.class);
    DirectedPseudograph<String, DefaultEdge> expectedStateGraph = new DirectedPseudograph<>(DefaultEdge.class);

    dotImporter.importGraph(expectedStateGraph, new StringReader(expectedStateGraphDot));
    dotImporter.importGraph(currentStateGraph, new StringReader(currentStateGraphDot));

    assertEquals(expectedStateGraph, currentStateGraph);
}