[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
	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;
	125	char *full_name = g_strdup_printf("%s-tests/%s", interface, test);
	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);
	141	g_free(full_name);
	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	}