[mirror_qemu.git] / tests / test-qgraph.c

/*
 * libqos driver framework
 *
 * Copyright (c) 2018 Emanuele Giuseppe Esposito <e.emanuelegiuseppe@gmail.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2 as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>
 */

#include "qemu/osdep.h"
#include "libqtest.h"
#include "libqos/qgraph.h"
#include "libqos/qgraph_internal.h"

#define MACHINE_PC "x86_64/pc"
#define MACHINE_RASPI2 "arm/raspi2"
#define I440FX "i440FX-pcihost"
#define PCIBUS_PC "pcibus-pc"
#define SDHCI "sdhci"
#define PCIBUS "pci-bus"
#define SDHCI_PCI "sdhci-pci"
#define SDHCI_MM "generic-sdhci"
#define REGISTER_TEST "register-test"

int npath;

static void *machinefunct(QTestState *qts)
{
    return NULL;
}

static void *driverfunct(void *obj, QGuestAllocator *machine, void *arg)
{
    return NULL;
}

static void testfunct(void *obj, void *arg, QGuestAllocator *alloc)
{
    return;
}

static void check_interface(const char *interface)
{
    g_assert_cmpint(qos_graph_has_machine(interface), ==, FALSE);
    g_assert_nonnull(qos_graph_get_node(interface));
    g_assert_cmpint(qos_graph_has_node(interface), ==, TRUE);
    g_assert_cmpint(qos_graph_get_node_type(interface), ==, QNODE_INTERFACE);
    qos_graph_node_set_availability(interface, TRUE);
    g_assert_cmpint(qos_graph_get_node_availability(interface), ==, TRUE);
}

static void check_machine(const char *machine)
{
    qos_node_create_machine(machine, machinefunct);
    g_assert_nonnull(qos_graph_get_machine(machine));
    g_assert_cmpint(qos_graph_has_machine(machine), ==, TRUE);
    g_assert_nonnull(qos_graph_get_node(machine));
    g_assert_cmpint(qos_graph_get_node_availability(machine), ==, FALSE);
    qos_graph_node_set_availability(machine, TRUE);
    g_assert_cmpint(qos_graph_get_node_availability(machine), ==, TRUE);
    g_assert_cmpint(qos_graph_has_node(machine), ==, TRUE);
    g_assert_cmpint(qos_graph_get_node_type(machine), ==, QNODE_MACHINE);
}

static void check_contains(const char *machine, const char *driver)
{
    QOSGraphEdge *edge;
    qos_node_contains(machine, driver, NULL);

    edge = qos_graph_get_edge(machine, driver);
    g_assert_nonnull(edge);
    g_assert_cmpint(qos_graph_edge_get_type(edge), ==, QEDGE_CONTAINS);
    g_assert_cmpint(qos_graph_has_edge(machine, driver), ==, TRUE);
}

static void check_produces(const char *machine, const char *interface)
{
    QOSGraphEdge *edge;

    qos_node_produces(machine, interface);
    check_interface(interface);
    edge = qos_graph_get_edge(machine, interface);
    g_assert_nonnull(edge);
    g_assert_cmpint(qos_graph_edge_get_type(edge), ==,
                    QEDGE_PRODUCES);
    g_assert_cmpint(qos_graph_has_edge(machine, interface), ==, TRUE);
}

static void check_consumes(const char *driver, const char *interface)
{
    QOSGraphEdge *edge;

    qos_node_consumes(driver, interface, NULL);
    check_interface(interface);
    edge = qos_graph_get_edge(interface, driver);
    g_assert_nonnull(edge);
    g_assert_cmpint(qos_graph_edge_get_type(edge), ==, QEDGE_CONSUMED_BY);
    g_assert_cmpint(qos_graph_has_edge(interface, driver), ==, TRUE);
}

static void check_driver(const char *driver)
{
    qos_node_create_driver(driver, driverfunct);
    g_assert_cmpint(qos_graph_has_machine(driver), ==, FALSE);
    g_assert_nonnull(qos_graph_get_node(driver));
    g_assert_cmpint(qos_graph_has_node(driver), ==, TRUE);
    g_assert_cmpint(qos_graph_get_node_type(driver), ==, QNODE_DRIVER);
    g_assert_cmpint(qos_graph_get_node_availability(driver), ==, FALSE);
    qos_graph_node_set_availability(driver, TRUE);
    g_assert_cmpint(qos_graph_get_node_availability(driver), ==, TRUE);
}

static void check_test(const char *test, const char *interface)
{
    QOSGraphEdge *edge;
    char *full_name = g_strdup_printf("%s-tests/%s", interface, test);

    qos_add_test(test, interface, testfunct, NULL);
    g_assert_cmpint(qos_graph_has_machine(test), ==, FALSE);
    g_assert_cmpint(qos_graph_has_machine(full_name), ==, FALSE);
    g_assert_nonnull(qos_graph_get_node(full_name));
    g_assert_cmpint(qos_graph_has_node(full_name), ==, TRUE);
    g_assert_cmpint(qos_graph_get_node_type(full_name), ==, QNODE_TEST);
    edge = qos_graph_get_edge(interface, full_name);
    g_assert_nonnull(edge);
    g_assert_cmpint(qos_graph_edge_get_type(edge), ==,
                    QEDGE_CONSUMED_BY);
    g_assert_cmpint(qos_graph_has_edge(interface, full_name), ==, TRUE);
    g_assert_cmpint(qos_graph_get_node_availability(full_name), ==, TRUE);
    qos_graph_node_set_availability(full_name, FALSE);
    g_assert_cmpint(qos_graph_get_node_availability(full_name), ==, FALSE);
    g_free(full_name);
}

static void count_each_test(QOSGraphNode *path, int len)
{
    npath++;
}

static void check_leaf_discovered(int n)
{
    npath = 0;
    qos_graph_foreach_test_path(count_each_test);
    g_assert_cmpint(n, ==, npath);
}

/* G_Test functions */

static void init_nop(void)
{
    qos_graph_init();
    qos_graph_destroy();
}

static void test_machine(void)
{
    qos_graph_init();
    check_machine(MACHINE_PC);
    qos_graph_destroy();
}

static void test_contains(void)
{
    qos_graph_init();
    check_contains(MACHINE_PC, I440FX);
    g_assert_null(qos_graph_get_machine(MACHINE_PC));
    g_assert_null(qos_graph_get_machine(I440FX));
    g_assert_null(qos_graph_get_node(MACHINE_PC));
    g_assert_null(qos_graph_get_node(I440FX));
    qos_graph_destroy();
}

static void test_multiple_contains(void)
{
    qos_graph_init();
    check_contains(MACHINE_PC, I440FX);
    check_contains(MACHINE_PC, PCIBUS_PC);
    qos_graph_destroy();
}

static void test_produces(void)
{
    qos_graph_init();
    check_produces(MACHINE_PC, I440FX);
    g_assert_null(qos_graph_get_machine(MACHINE_PC));
    g_assert_null(qos_graph_get_machine(I440FX));
    g_assert_null(qos_graph_get_node(MACHINE_PC));
    g_assert_nonnull(qos_graph_get_node(I440FX));
    qos_graph_destroy();
}

static void test_multiple_produces(void)
{
    qos_graph_init();
    check_produces(MACHINE_PC, I440FX);
    check_produces(MACHINE_PC, PCIBUS_PC);
    qos_graph_destroy();
}

static void test_consumes(void)
{
    qos_graph_init();
    check_consumes(I440FX, SDHCI);
    g_assert_null(qos_graph_get_machine(I440FX));
    g_assert_null(qos_graph_get_machine(SDHCI));
    g_assert_null(qos_graph_get_node(I440FX));
    g_assert_nonnull(qos_graph_get_node(SDHCI));
    qos_graph_destroy();
}

static void test_multiple_consumes(void)
{
    qos_graph_init();
    check_consumes(I440FX, SDHCI);
    check_consumes(PCIBUS_PC, SDHCI);
    qos_graph_destroy();
}

static void test_driver(void)
{
    qos_graph_init();
    check_driver(I440FX);
    qos_graph_destroy();
}

static void test_test(void)
{
    qos_graph_init();
    check_test(REGISTER_TEST, SDHCI);
    qos_graph_destroy();
}

static void test_machine_contains_driver(void)
{
    qos_graph_init();
    check_machine(MACHINE_PC);
    check_driver(I440FX);
    check_contains(MACHINE_PC, I440FX);
    qos_graph_destroy();
}

static void test_driver_contains_driver(void)
{
    qos_graph_init();
    check_driver(PCIBUS_PC);
    check_driver(I440FX);
    check_contains(PCIBUS_PC, I440FX);
    qos_graph_destroy();
}

static void test_machine_produces_interface(void)
{
    qos_graph_init();
    check_machine(MACHINE_PC);
    check_produces(MACHINE_PC, SDHCI);
    qos_graph_destroy();
}

static void test_driver_produces_interface(void)
{
    qos_graph_init();
    check_driver(I440FX);
    check_produces(I440FX, SDHCI);
    qos_graph_destroy();
}

static void test_machine_consumes_interface(void)
{
    qos_graph_init();
    check_machine(MACHINE_PC);
    check_consumes(MACHINE_PC, SDHCI);
    qos_graph_destroy();
}

static void test_driver_consumes_interface(void)
{
    qos_graph_init();
    check_driver(I440FX);
    check_consumes(I440FX, SDHCI);
    qos_graph_destroy();
}

static void test_test_consumes_interface(void)
{
    qos_graph_init();
    check_test(REGISTER_TEST, SDHCI);
    qos_graph_destroy();
}

static void test_full_sample(void)
{
    qos_graph_init();
    check_machine(MACHINE_PC);
    check_contains(MACHINE_PC, I440FX);
    check_driver(I440FX);
    check_driver(PCIBUS_PC);
    check_contains(I440FX, PCIBUS_PC);
    check_produces(PCIBUS_PC, PCIBUS);
    check_driver(SDHCI_PCI);
    qos_node_consumes(SDHCI_PCI, PCIBUS, NULL);
    check_produces(SDHCI_PCI, SDHCI);
    check_driver(SDHCI_MM);
    check_produces(SDHCI_MM, SDHCI);
    qos_add_test(REGISTER_TEST, SDHCI, testfunct, NULL);
    check_leaf_discovered(1);
    qos_print_graph();
    qos_graph_destroy();
}

static void test_full_sample_raspi(void)
{
    qos_graph_init();
    check_machine(MACHINE_PC);
    check_contains(MACHINE_PC, I440FX);
    check_driver(I440FX);
    check_driver(PCIBUS_PC);
    check_contains(I440FX, PCIBUS_PC);
    check_produces(PCIBUS_PC, PCIBUS);
    check_driver(SDHCI_PCI);
    qos_node_consumes(SDHCI_PCI, PCIBUS, NULL);
    check_produces(SDHCI_PCI, SDHCI);
    check_machine(MACHINE_RASPI2);
    check_contains(MACHINE_RASPI2, SDHCI_MM);
    check_driver(SDHCI_MM);
    check_produces(SDHCI_MM, SDHCI);
    qos_add_test(REGISTER_TEST, SDHCI, testfunct, NULL);
    qos_print_graph();
    check_leaf_discovered(2);
    qos_graph_destroy();
}

static void test_cycle(void)
{
    qos_graph_init();
    check_machine(MACHINE_RASPI2);
    check_driver("B");
    check_driver("C");
    check_driver("D");
    check_contains(MACHINE_RASPI2, "B");
    check_contains("B", "C");
    check_contains("C", "D");
    check_contains("D", MACHINE_RASPI2);
    check_leaf_discovered(0);
    qos_print_graph();
    qos_graph_destroy();
}

static void test_two_test_same_interface(void)
{
    qos_graph_init();
    check_machine(MACHINE_RASPI2);
    check_produces(MACHINE_RASPI2, "B");
    qos_add_test("C", "B", testfunct, NULL);
    qos_add_test("D", "B", testfunct, NULL);
    check_contains(MACHINE_RASPI2, "B");
    check_leaf_discovered(4);
    qos_print_graph();
    qos_graph_destroy();
}

static void test_test_in_path(void)
{
    qos_graph_init();
    check_machine(MACHINE_RASPI2);
    check_produces(MACHINE_RASPI2, "B");
    qos_add_test("C", "B", testfunct, NULL);
    check_driver("D");
    check_consumes("D", "B");
    check_produces("D", "E");
    qos_add_test("F", "E", testfunct, NULL);
    check_leaf_discovered(2);
    qos_print_graph();
    qos_graph_destroy();
}

static void test_double_edge(void)
{
    qos_graph_init();
    check_machine(MACHINE_RASPI2);
    check_produces("B", "C");
    qos_node_consumes("C", "B", NULL);
    qos_add_test("D", "C", testfunct, NULL);
    check_contains(MACHINE_RASPI2, "B");
    qos_print_graph();
    qos_graph_destroy();
}

int main(int argc, char **argv)
{
    g_test_init(&argc, &argv, NULL);
    g_test_add_func("/qgraph/init_nop", init_nop);
    g_test_add_func("/qgraph/test_machine", test_machine);
    g_test_add_func("/qgraph/test_contains", test_contains);
    g_test_add_func("/qgraph/test_multiple_contains", test_multiple_contains);
    g_test_add_func("/qgraph/test_produces", test_produces);
    g_test_add_func("/qgraph/test_multiple_produces", test_multiple_produces);
    g_test_add_func("/qgraph/test_consumes", test_consumes);
    g_test_add_func("/qgraph/test_multiple_consumes",
                    test_multiple_consumes);
    g_test_add_func("/qgraph/test_driver", test_driver);
    g_test_add_func("/qgraph/test_test", test_test);
    g_test_add_func("/qgraph/test_machine_contains_driver",
                    test_machine_contains_driver);
    g_test_add_func("/qgraph/test_driver_contains_driver",
                    test_driver_contains_driver);
    g_test_add_func("/qgraph/test_machine_produces_interface",
                    test_machine_produces_interface);
    g_test_add_func("/qgraph/test_driver_produces_interface",
                    test_driver_produces_interface);
    g_test_add_func("/qgraph/test_machine_consumes_interface",
                    test_machine_consumes_interface);
    g_test_add_func("/qgraph/test_driver_consumes_interface",
                    test_driver_consumes_interface);
    g_test_add_func("/qgraph/test_test_consumes_interface",
                    test_test_consumes_interface);
    g_test_add_func("/qgraph/test_full_sample", test_full_sample);
    g_test_add_func("/qgraph/test_full_sample_raspi", test_full_sample_raspi);
    g_test_add_func("/qgraph/test_cycle", test_cycle);
    g_test_add_func("/qgraph/test_two_test_same_interface",
                    test_two_test_same_interface);
    g_test_add_func("/qgraph/test_test_in_path", test_test_in_path);
    g_test_add_func("/qgraph/test_double_edge", test_double_edge);

    g_test_run();
    return 0;
}
Commit	Line	Data
fc281c80 EGE	1	/*
	2	* libqos driver framework
	3	*
	4	* Copyright (c) 2018 Emanuele Giuseppe Esposito <e.emanuelegiuseppe@gmail.com>
	5	*
	6	* This library is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License version 2 as published by the Free Software Foundation.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Lesser General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Lesser General Public
	16	* License along with this library; if not, see <http://www.gnu.org/licenses/>
	17	*/
	18
	19	#include "qemu/osdep.h"
	20	#include "libqtest.h"
	21	#include "libqos/qgraph.h"
	22	#include "libqos/qgraph_internal.h"
	23
	24	#define MACHINE_PC "x86_64/pc"
	25	#define MACHINE_RASPI2 "arm/raspi2"
	26	#define I440FX "i440FX-pcihost"
	27	#define PCIBUS_PC "pcibus-pc"
	28	#define SDHCI "sdhci"
	29	#define PCIBUS "pci-bus"
	30	#define SDHCI_PCI "sdhci-pci"
	31	#define SDHCI_MM "generic-sdhci"
	32	#define REGISTER_TEST "register-test"
	33
	34	int npath;
	35
	36	static void machinefunct(QTestState qts)
	37	{
	38	return NULL;
	39	}
	40
	41	static void driverfunct(void obj, QGuestAllocator machine, void arg)
	42	{
	43	return NULL;
	44	}
	45
	46	static void testfunct(void obj, void arg, QGuestAllocator *alloc)
	47	{
	48	return;
	49	}
	50
	51	static void check_interface(const char *interface)
	52	{
	53	g_assert_cmpint(qos_graph_has_machine(interface), ==, FALSE);
	54	g_assert_nonnull(qos_graph_get_node(interface));
	55	g_assert_cmpint(qos_graph_has_node(interface), ==, TRUE);
	56	g_assert_cmpint(qos_graph_get_node_type(interface), ==, QNODE_INTERFACE);
	57	qos_graph_node_set_availability(interface, TRUE);
	58	g_assert_cmpint(qos_graph_get_node_availability(interface), ==, TRUE);
	59	}
	60
	61	static void check_machine(const char *machine)
	62	{
	63	qos_node_create_machine(machine, machinefunct);
	64	g_assert_nonnull(qos_graph_get_machine(machine));
65	g_assert_cmpint(qos_graph_has_machine(machine), ==, TRUE);
66	g_assert_nonnull(qos_graph_get_node(machine));
67	g_assert_cmpint(qos_graph_get_node_availability(machine), ==, FALSE);
68	qos_graph_node_set_availability(machine, TRUE);
69	g_assert_cmpint(qos_graph_get_node_availability(machine), ==, TRUE);
70	g_assert_cmpint(qos_graph_has_node(machine), ==, TRUE);
71	g_assert_cmpint(qos_graph_get_node_type(machine), ==, QNODE_MACHINE);
72	}
73
74	static void check_contains(const char machine, const char driver)
75	{
76	QOSGraphEdge *edge;
77	qos_node_contains(machine, driver, NULL);
78
79	edge = qos_graph_get_edge(machine, driver);
80	g_assert_nonnull(edge);
81	g_assert_cmpint(qos_graph_edge_get_type(edge), ==, QEDGE_CONTAINS);
82	g_assert_cmpint(qos_graph_has_edge(machine, driver), ==, TRUE);
83	}
84
85	static void check_produces(const char machine, const char interface)
86	{
87	QOSGraphEdge *edge;
88
89	qos_node_produces(machine, interface);
90	check_interface(interface);
91	edge = qos_graph_get_edge(machine, interface);
92	g_assert_nonnull(edge);
93	g_assert_cmpint(qos_graph_edge_get_type(edge), ==,
94	QEDGE_PRODUCES);
95	g_assert_cmpint(qos_graph_has_edge(machine, interface), ==, TRUE);
96	}
97
98	static void check_consumes(const char driver, const char interface)
99	{
100	QOSGraphEdge *edge;
101
102	qos_node_consumes(driver, interface, NULL);
103	check_interface(interface);
104	edge = qos_graph_get_edge(interface, driver);
105	g_assert_nonnull(edge);
106	g_assert_cmpint(qos_graph_edge_get_type(edge), ==, QEDGE_CONSUMED_BY);
107	g_assert_cmpint(qos_graph_has_edge(interface, driver), ==, TRUE);
108	}
109
110	static void check_driver(const char *driver)
111	{
112	qos_node_create_driver(driver, driverfunct);
113	g_assert_cmpint(qos_graph_has_machine(driver), ==, FALSE);
114	g_assert_nonnull(qos_graph_get_node(driver));
115	g_assert_cmpint(qos_graph_has_node(driver), ==, TRUE);
116	g_assert_cmpint(qos_graph_get_node_type(driver), ==, QNODE_DRIVER);
117	g_assert_cmpint(qos_graph_get_node_availability(driver), ==, FALSE);
118	qos_graph_node_set_availability(driver, TRUE);
119	g_assert_cmpint(qos_graph_get_node_availability(driver), ==, TRUE);
120	}
121
122	static void check_test(const char test, const char interface)
123	{
124	QOSGraphEdge *edge;
944b96c6	125	char *full_name = g_strdup_printf("%s-tests/%s", interface, test);
fc281c80 EGE	126
	127	qos_add_test(test, interface, testfunct, NULL);
	128	g_assert_cmpint(qos_graph_has_machine(test), ==, FALSE);
	129	g_assert_cmpint(qos_graph_has_machine(full_name), ==, FALSE);
	130	g_assert_nonnull(qos_graph_get_node(full_name));
	131	g_assert_cmpint(qos_graph_has_node(full_name), ==, TRUE);
	132	g_assert_cmpint(qos_graph_get_node_type(full_name), ==, QNODE_TEST);
	133	edge = qos_graph_get_edge(interface, full_name);
	134	g_assert_nonnull(edge);
	135	g_assert_cmpint(qos_graph_edge_get_type(edge), ==,
	136	QEDGE_CONSUMED_BY);
	137	g_assert_cmpint(qos_graph_has_edge(interface, full_name), ==, TRUE);
	138	g_assert_cmpint(qos_graph_get_node_availability(full_name), ==, TRUE);
	139	qos_graph_node_set_availability(full_name, FALSE);
	140	g_assert_cmpint(qos_graph_get_node_availability(full_name), ==, FALSE);
944b96c6	141	g_free(full_name);
fc281c80 EGE	142	}
	143
	144	static void count_each_test(QOSGraphNode *path, int len)
	145	{
	146	npath++;
	147	}
	148
	149	static void check_leaf_discovered(int n)
	150	{
	151	npath = 0;
	152	qos_graph_foreach_test_path(count_each_test);
	153	g_assert_cmpint(n, ==, npath);
	154	}
	155
	156	/* G_Test functions */
	157
	158	static void init_nop(void)
	159	{
	160	qos_graph_init();
	161	qos_graph_destroy();
	162	}
	163
	164	static void test_machine(void)
	165	{
	166	qos_graph_init();
	167	check_machine(MACHINE_PC);
	168	qos_graph_destroy();
	169	}
	170
	171	static void test_contains(void)
	172	{
	173	qos_graph_init();
	174	check_contains(MACHINE_PC, I440FX);
	175	g_assert_null(qos_graph_get_machine(MACHINE_PC));
	176	g_assert_null(qos_graph_get_machine(I440FX));
	177	g_assert_null(qos_graph_get_node(MACHINE_PC));
	178	g_assert_null(qos_graph_get_node(I440FX));
	179	qos_graph_destroy();
	180	}
	181
	182	static void test_multiple_contains(void)
	183	{
	184	qos_graph_init();
	185	check_contains(MACHINE_PC, I440FX);
	186	check_contains(MACHINE_PC, PCIBUS_PC);
	187	qos_graph_destroy();
	188	}
	189
	190	static void test_produces(void)
	191	{
	192	qos_graph_init();
	193	check_produces(MACHINE_PC, I440FX);
	194	g_assert_null(qos_graph_get_machine(MACHINE_PC));
	195	g_assert_null(qos_graph_get_machine(I440FX));
	196	g_assert_null(qos_graph_get_node(MACHINE_PC));
	197	g_assert_nonnull(qos_graph_get_node(I440FX));
	198	qos_graph_destroy();
	199	}
	200
	201	static void test_multiple_produces(void)
	202	{
	203	qos_graph_init();
	204	check_produces(MACHINE_PC, I440FX);
	205	check_produces(MACHINE_PC, PCIBUS_PC);
206	qos_graph_destroy();
207	}
208
209	static void test_consumes(void)
210	{
211	qos_graph_init();
212	check_consumes(I440FX, SDHCI);
213	g_assert_null(qos_graph_get_machine(I440FX));
214	g_assert_null(qos_graph_get_machine(SDHCI));
215	g_assert_null(qos_graph_get_node(I440FX));
216	g_assert_nonnull(qos_graph_get_node(SDHCI));
217	qos_graph_destroy();
218	}
219
220	static void test_multiple_consumes(void)
221	{
222	qos_graph_init();
223	check_consumes(I440FX, SDHCI);
224	check_consumes(PCIBUS_PC, SDHCI);
225	qos_graph_destroy();
226	}
227
228	static void test_driver(void)
229	{
230	qos_graph_init();
231	check_driver(I440FX);
232	qos_graph_destroy();
233	}
234
235	static void test_test(void)
236	{
237	qos_graph_init();
238	check_test(REGISTER_TEST, SDHCI);
239	qos_graph_destroy();
240	}
241
242	static void test_machine_contains_driver(void)
243	{
244	qos_graph_init();
245	check_machine(MACHINE_PC);
246	check_driver(I440FX);
247	check_contains(MACHINE_PC, I440FX);
248	qos_graph_destroy();
249	}
250
251	static void test_driver_contains_driver(void)
252	{
253	qos_graph_init();
254	check_driver(PCIBUS_PC);
255	check_driver(I440FX);
256	check_contains(PCIBUS_PC, I440FX);
257	qos_graph_destroy();
258	}
259
260	static void test_machine_produces_interface(void)
261	{
262	qos_graph_init();
263	check_machine(MACHINE_PC);
264	check_produces(MACHINE_PC, SDHCI);
265	qos_graph_destroy();
266	}
267
268	static void test_driver_produces_interface(void)
269	{
270	qos_graph_init();
271	check_driver(I440FX);
272	check_produces(I440FX, SDHCI);
273	qos_graph_destroy();
274	}
275
276	static void test_machine_consumes_interface(void)
277	{
278	qos_graph_init();
279	check_machine(MACHINE_PC);
280	check_consumes(MACHINE_PC, SDHCI);
281	qos_graph_destroy();
282	}
283
284	static void test_driver_consumes_interface(void)
285	{
286	qos_graph_init();
287	check_driver(I440FX);
288	check_consumes(I440FX, SDHCI);
289	qos_graph_destroy();
290	}
291
292	static void test_test_consumes_interface(void)
293	{
294	qos_graph_init();
295	check_test(REGISTER_TEST, SDHCI);
296	qos_graph_destroy();
297	}
298
299	static void test_full_sample(void)
300	{
301	qos_graph_init();
302	check_machine(MACHINE_PC);
303	check_contains(MACHINE_PC, I440FX);
304	check_driver(I440FX);
305	check_driver(PCIBUS_PC);
306	check_contains(I440FX, PCIBUS_PC);
307	check_produces(PCIBUS_PC, PCIBUS);
308	check_driver(SDHCI_PCI);
309	qos_node_consumes(SDHCI_PCI, PCIBUS, NULL);
310	check_produces(SDHCI_PCI, SDHCI);
311	check_driver(SDHCI_MM);
312	check_produces(SDHCI_MM, SDHCI);
313	qos_add_test(REGISTER_TEST, SDHCI, testfunct, NULL);
314	check_leaf_discovered(1);
315	qos_print_graph();
316	qos_graph_destroy();
317	}
318
319	static void test_full_sample_raspi(void)
320	{
321	qos_graph_init();
322	check_machine(MACHINE_PC);
323	check_contains(MACHINE_PC, I440FX);
324	check_driver(I440FX);
325	check_driver(PCIBUS_PC);
326	check_contains(I440FX, PCIBUS_PC);
327	check_produces(PCIBUS_PC, PCIBUS);
328	check_driver(SDHCI_PCI);
329	qos_node_consumes(SDHCI_PCI, PCIBUS, NULL);
330	check_produces(SDHCI_PCI, SDHCI);
331	check_machine(MACHINE_RASPI2);
332	check_contains(MACHINE_RASPI2, SDHCI_MM);
333	check_driver(SDHCI_MM);
334	check_produces(SDHCI_MM, SDHCI);
335	qos_add_test(REGISTER_TEST, SDHCI, testfunct, NULL);
336	qos_print_graph();
337	check_leaf_discovered(2);
338	qos_graph_destroy();
339	}
340
341	static void test_cycle(void)
342	{
343	qos_graph_init();
344	check_machine(MACHINE_RASPI2);
345	check_driver("B");
346	check_driver("C");
347	check_driver("D");
348	check_contains(MACHINE_RASPI2, "B");
349	check_contains("B", "C");
350	check_contains("C", "D");
351	check_contains("D", MACHINE_RASPI2);
352	check_leaf_discovered(0);
353	qos_print_graph();
354	qos_graph_destroy();
355	}
356
357	static void test_two_test_same_interface(void)
358	{
359	qos_graph_init();
360	check_machine(MACHINE_RASPI2);
361	check_produces(MACHINE_RASPI2, "B");
362	qos_add_test("C", "B", testfunct, NULL);
363	qos_add_test("D", "B", testfunct, NULL);
364	check_contains(MACHINE_RASPI2, "B");
365	check_leaf_discovered(4);
366	qos_print_graph();
367	qos_graph_destroy();
368	}
369
370	static void test_test_in_path(void)
371	{
372	qos_graph_init();
373	check_machine(MACHINE_RASPI2);
374	check_produces(MACHINE_RASPI2, "B");
375	qos_add_test("C", "B", testfunct, NULL);
376	check_driver("D");
377	check_consumes("D", "B");
378	check_produces("D", "E");
379	qos_add_test("F", "E", testfunct, NULL);
380	check_leaf_discovered(2);
381	qos_print_graph();
382	qos_graph_destroy();
383	}
384
385	static void test_double_edge(void)
386	{
387	qos_graph_init();
388	check_machine(MACHINE_RASPI2);
389	check_produces("B", "C");
390	qos_node_consumes("C", "B", NULL);
391	qos_add_test("D", "C", testfunct, NULL);
392	check_contains(MACHINE_RASPI2, "B");
393	qos_print_graph();
394	qos_graph_destroy();
395	}
396
397	int main(int argc, char **argv)
398	{
399	g_test_init(&argc, &argv, NULL);
400	g_test_add_func("/qgraph/init_nop", init_nop);
401	g_test_add_func("/qgraph/test_machine", test_machine);
402	g_test_add_func("/qgraph/test_contains", test_contains);
403	g_test_add_func("/qgraph/test_multiple_contains", test_multiple_contains);
404	g_test_add_func("/qgraph/test_produces", test_produces);
405	g_test_add_func("/qgraph/test_multiple_produces", test_multiple_produces);
406	g_test_add_func("/qgraph/test_consumes", test_consumes);
407	g_test_add_func("/qgraph/test_multiple_consumes",
408	test_multiple_consumes);
409	g_test_add_func("/qgraph/test_driver", test_driver);
410	g_test_add_func("/qgraph/test_test", test_test);
411	g_test_add_func("/qgraph/test_machine_contains_driver",
412	test_machine_contains_driver);
413	g_test_add_func("/qgraph/test_driver_contains_driver",
414	test_driver_contains_driver);
415	g_test_add_func("/qgraph/test_machine_produces_interface",
416	test_machine_produces_interface);
417	g_test_add_func("/qgraph/test_driver_produces_interface",
418	test_driver_produces_interface);
419	g_test_add_func("/qgraph/test_machine_consumes_interface",
420	test_machine_consumes_interface);
421	g_test_add_func("/qgraph/test_driver_consumes_interface",
422	test_driver_consumes_interface);
423	g_test_add_func("/qgraph/test_test_consumes_interface",
424	test_test_consumes_interface);
425	g_test_add_func("/qgraph/test_full_sample", test_full_sample);
426	g_test_add_func("/qgraph/test_full_sample_raspi", test_full_sample_raspi);
427	g_test_add_func("/qgraph/test_cycle", test_cycle);
428	g_test_add_func("/qgraph/test_two_test_same_interface",
429	test_two_test_same_interface);
430	g_test_add_func("/qgraph/test_test_in_path", test_test_in_path);
431	g_test_add_func("/qgraph/test_double_edge", test_double_edge);
432
433	g_test_run();
434	return 0;
435	}