tests/test-qgraph.c

   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     const 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 }
 142
 143 static void count_each_test(QOSGraphNode *path, int len)
 144 {
 145     npath++;
 146 }
 147
 148 static void check_leaf_discovered(int n)
 149 {
 150     npath = 0;
 151     qos_graph_foreach_test_path(count_each_test);
 152     g_assert_cmpint(n, ==, npath);
 153 }
 154
 155 /* G_Test functions */
 156
 157 static void init_nop(void)
 158 {
 159     qos_graph_init();
 160     qos_graph_destroy();
 161 }
 162
 163 static void test_machine(void)
 164 {
 165     qos_graph_init();
 166     check_machine(MACHINE_PC);
 167     qos_graph_destroy();
 168 }
 169
 170 static void test_contains(void)
 171 {
 172     qos_graph_init();
 173     check_contains(MACHINE_PC, I440FX);
 174     g_assert_null(qos_graph_get_machine(MACHINE_PC));
 175     g_assert_null(qos_graph_get_machine(I440FX));
 176     g_assert_null(qos_graph_get_node(MACHINE_PC));
 177     g_assert_null(qos_graph_get_node(I440FX));
 178     qos_graph_destroy();
 179 }
 180
 181 static void test_multiple_contains(void)
 182 {
 183     qos_graph_init();
 184     check_contains(MACHINE_PC, I440FX);
 185     check_contains(MACHINE_PC, PCIBUS_PC);
 186     qos_graph_destroy();
 187 }
 188
 189 static void test_produces(void)
 190 {
 191     qos_graph_init();
 192     check_produces(MACHINE_PC, I440FX);
 193     g_assert_null(qos_graph_get_machine(MACHINE_PC));
 194     g_assert_null(qos_graph_get_machine(I440FX));
 195     g_assert_null(qos_graph_get_node(MACHINE_PC));
 196     g_assert_nonnull(qos_graph_get_node(I440FX));
 197     qos_graph_destroy();
 198 }
 199
 200 static void test_multiple_produces(void)
 201 {
 202     qos_graph_init();
 203     check_produces(MACHINE_PC, I440FX);
 204     check_produces(MACHINE_PC, PCIBUS_PC);
 205     qos_graph_destroy();
 206 }
 207
 208 static void test_consumes(void)
 209 {
 210     qos_graph_init();
 211     check_consumes(I440FX, SDHCI);
 212     g_assert_null(qos_graph_get_machine(I440FX));
 213     g_assert_null(qos_graph_get_machine(SDHCI));
 214     g_assert_null(qos_graph_get_node(I440FX));
 215     g_assert_nonnull(qos_graph_get_node(SDHCI));
 216     qos_graph_destroy();
 217 }
 218
 219 static void test_multiple_consumes(void)
 220 {
 221     qos_graph_init();
 222     check_consumes(I440FX, SDHCI);
 223     check_consumes(PCIBUS_PC, SDHCI);
 224     qos_graph_destroy();
 225 }
 226
 227 static void test_driver(void)
 228 {
 229     qos_graph_init();
 230     check_driver(I440FX);
 231     qos_graph_destroy();
 232 }
 233
 234 static void test_test(void)
 235 {
 236     qos_graph_init();
 237     check_test(REGISTER_TEST, SDHCI);
 238     qos_graph_destroy();
 239 }
 240
 241 static void test_machine_contains_driver(void)
 242 {
 243     qos_graph_init();
 244     check_machine(MACHINE_PC);
 245     check_driver(I440FX);
 246     check_contains(MACHINE_PC, I440FX);
 247     qos_graph_destroy();
 248 }
 249
 250 static void test_driver_contains_driver(void)
 251 {
 252     qos_graph_init();
 253     check_driver(PCIBUS_PC);
 254     check_driver(I440FX);
 255     check_contains(PCIBUS_PC, I440FX);
 256     qos_graph_destroy();
 257 }
 258
 259 static void test_machine_produces_interface(void)
 260 {
 261     qos_graph_init();
 262     check_machine(MACHINE_PC);
 263     check_produces(MACHINE_PC, SDHCI);
 264     qos_graph_destroy();
 265 }
 266
 267 static void test_driver_produces_interface(void)
 268 {
 269     qos_graph_init();
 270     check_driver(I440FX);
 271     check_produces(I440FX, SDHCI);
 272     qos_graph_destroy();
 273 }
 274
 275 static void test_machine_consumes_interface(void)
 276 {
 277     qos_graph_init();
 278     check_machine(MACHINE_PC);
 279     check_consumes(MACHINE_PC, SDHCI);
 280     qos_graph_destroy();
 281 }
 282
 283 static void test_driver_consumes_interface(void)
 284 {
 285     qos_graph_init();
 286     check_driver(I440FX);
 287     check_consumes(I440FX, SDHCI);
 288     qos_graph_destroy();
 289 }
 290
 291 static void test_test_consumes_interface(void)
 292 {
 293     qos_graph_init();
 294     check_test(REGISTER_TEST, SDHCI);
 295     qos_graph_destroy();
 296 }
 297
 298 static void test_full_sample(void)
 299 {
 300     qos_graph_init();
 301     check_machine(MACHINE_PC);
 302     check_contains(MACHINE_PC, I440FX);
 303     check_driver(I440FX);
 304     check_driver(PCIBUS_PC);
 305     check_contains(I440FX, PCIBUS_PC);
 306     check_produces(PCIBUS_PC, PCIBUS);
 307     check_driver(SDHCI_PCI);
 308     qos_node_consumes(SDHCI_PCI, PCIBUS, NULL);
 309     check_produces(SDHCI_PCI, SDHCI);
 310     check_driver(SDHCI_MM);
 311     check_produces(SDHCI_MM, SDHCI);
 312     qos_add_test(REGISTER_TEST, SDHCI, testfunct, NULL);
 313     check_leaf_discovered(1);
 314     qos_print_graph();
 315     qos_graph_destroy();
 316 }
 317
 318 static void test_full_sample_raspi(void)
 319 {
 320     qos_graph_init();
 321     check_machine(MACHINE_PC);
 322     check_contains(MACHINE_PC, I440FX);
 323     check_driver(I440FX);
 324     check_driver(PCIBUS_PC);
 325     check_contains(I440FX, PCIBUS_PC);
 326     check_produces(PCIBUS_PC, PCIBUS);
 327     check_driver(SDHCI_PCI);
 328     qos_node_consumes(SDHCI_PCI, PCIBUS, NULL);
 329     check_produces(SDHCI_PCI, SDHCI);
 330     check_machine(MACHINE_RASPI2);
 331     check_contains(MACHINE_RASPI2, SDHCI_MM);
 332     check_driver(SDHCI_MM);
 333     check_produces(SDHCI_MM, SDHCI);
 334     qos_add_test(REGISTER_TEST, SDHCI, testfunct, NULL);
 335     qos_print_graph();
 336     check_leaf_discovered(2);
 337     qos_graph_destroy();
 338 }
 339
 340 static void test_cycle(void)
 341 {
 342     qos_graph_init();
 343     check_machine(MACHINE_RASPI2);
 344     check_driver("B");
 345     check_driver("C");
 346     check_driver("D");
 347     check_contains(MACHINE_RASPI2, "B");
 348     check_contains("B", "C");
 349     check_contains("C", "D");
 350     check_contains("D", MACHINE_RASPI2);
 351     check_leaf_discovered(0);
 352     qos_print_graph();
 353     qos_graph_destroy();
 354 }
 355
 356 static void test_two_test_same_interface(void)
 357 {
 358     qos_graph_init();
 359     check_machine(MACHINE_RASPI2);
 360     check_produces(MACHINE_RASPI2, "B");
 361     qos_add_test("C", "B", testfunct, NULL);
 362     qos_add_test("D", "B", testfunct, NULL);
 363     check_contains(MACHINE_RASPI2, "B");
 364     check_leaf_discovered(4);
 365     qos_print_graph();
 366     qos_graph_destroy();
 367 }
 368
 369 static void test_test_in_path(void)
 370 {
 371     qos_graph_init();
 372     check_machine(MACHINE_RASPI2);
 373     check_produces(MACHINE_RASPI2, "B");
 374     qos_add_test("C", "B", testfunct, NULL);
 375     check_driver("D");
 376     check_consumes("D", "B");
 377     check_produces("D", "E");
 378     qos_add_test("F", "E", testfunct, NULL);
 379     check_leaf_discovered(2);
 380     qos_print_graph();
 381     qos_graph_destroy();
 382 }
 383
 384 static void test_double_edge(void)
 385 {
 386     qos_graph_init();
 387     check_machine(MACHINE_RASPI2);
 388     check_produces("B", "C");
 389     qos_node_consumes("C", "B", NULL);
 390     qos_add_test("D", "C", testfunct, NULL);
 391     check_contains(MACHINE_RASPI2, "B");
 392     qos_print_graph();
 393     qos_graph_destroy();
 394 }
 395
 396 int main(int argc, char **argv)
 397 {
 398     g_test_init(&argc, &argv, NULL);
 399     g_test_add_func("/qgraph/init_nop", init_nop);
 400     g_test_add_func("/qgraph/test_machine", test_machine);
 401     g_test_add_func("/qgraph/test_contains", test_contains);
 402     g_test_add_func("/qgraph/test_multiple_contains", test_multiple_contains);
 403     g_test_add_func("/qgraph/test_produces", test_produces);
 404     g_test_add_func("/qgraph/test_multiple_produces", test_multiple_produces);
 405     g_test_add_func("/qgraph/test_consumes", test_consumes);
 406     g_test_add_func("/qgraph/test_multiple_consumes",
 407                     test_multiple_consumes);
 408     g_test_add_func("/qgraph/test_driver", test_driver);
 409     g_test_add_func("/qgraph/test_test", test_test);
 410     g_test_add_func("/qgraph/test_machine_contains_driver",
 411                     test_machine_contains_driver);
 412     g_test_add_func("/qgraph/test_driver_contains_driver",
 413                     test_driver_contains_driver);
 414     g_test_add_func("/qgraph/test_machine_produces_interface",
 415                     test_machine_produces_interface);
 416     g_test_add_func("/qgraph/test_driver_produces_interface",
 417                     test_driver_produces_interface);
 418     g_test_add_func("/qgraph/test_machine_consumes_interface",
 419                     test_machine_consumes_interface);
 420     g_test_add_func("/qgraph/test_driver_consumes_interface",
 421                     test_driver_consumes_interface);
 422     g_test_add_func("/qgraph/test_test_consumes_interface",
 423                     test_test_consumes_interface);
 424     g_test_add_func("/qgraph/test_full_sample", test_full_sample);
 425     g_test_add_func("/qgraph/test_full_sample_raspi", test_full_sample_raspi);
 426     g_test_add_func("/qgraph/test_cycle", test_cycle);
 427     g_test_add_func("/qgraph/test_two_test_same_interface",
 428                     test_two_test_same_interface);
 429     g_test_add_func("/qgraph/test_test_in_path", test_test_in_path);
 430     g_test_add_func("/qgraph/test_double_edge", test_double_edge);
 431
 432     g_test_run();
 433     return 0;
 434 }