lunaix-os/tests/units/device-tree/test-fdt-iter.c

   1 #include "common.h"
   2 #include <testing/basic.h>
   3
   4 static void
   5 test_fdt_basic_iter(ptr_t dtb)
   6 {
   7     struct fdt_blob fdt;
   8     fdt_loc_t loc;
   9     int depth = 0;
  10
  11     fdt_load(&fdt, dtb);
  12     loc = fdt.root;
  13
  14     testcase("iter-child1", {
  15         loc = fdt_next_token(loc, &depth);
  16
  17         expect_int(depth, 1);
  18         expect_int(loc.token->token, FDT_NOD_BEGIN);
  19         expect_str(loc.node->name, "child@1");
  20     });
  21
  22     testcase("iter-child1-prop", {
  23         loc = fdt_next_token(loc, &depth);
  24
  25         expect_int(depth, 1);
  26         expect_true(fdt_prop(loc.token));
  27         expect_str(fdt_prop_key(&fdt, loc), "prop-child1");
  28     });
  29
  30     testcase("iter-child1-end", {
  31         loc = fdt_next_token(loc, &depth);
  32
  33         expect_int(depth, 0);
  34         expect_true(fdt_node_end(loc.token));
  35     });
  36
  37     testcase("iter-step-out", {
  38         loc = fdt_next_token(loc, &depth);
  39
  40         expect_int(depth, -1);
  41         expect_true(fdt_node(loc.token));
  42         expect_str(loc.node->name, "child@2");
  43     });
  44 }
  45
  46 static void
  47 test_fdt_sibling_iter(ptr_t dtb)
  48 {
  49     struct fdt_blob fdt;
  50     fdt_loc_t loc;
  51     int depth = 0;
  52
  53     fdt_load(&fdt, dtb);
  54     loc = fdt.root;
  55
  56     loc = fdt_descend_into(loc);
  57
  58     testcase("sibling-iter-1", {
  59         expect_int(loc.token->token, FDT_NOD_BEGIN);
  60         expect_str(loc.node->name, "child@1");
  61     });
  62
  63     testcase("sibling-iter-2", {
  64         expect_true(fdt_next_sibling(loc, &loc));
  65
  66         expect_int(loc.token->token, FDT_NOD_BEGIN);
  67         expect_str(loc.node->name, "child@2");
  68     });
  69
  70     testcase("sibling-iter-3", {
  71         expect_true(fdt_next_sibling(loc, &loc));
  72
  73         expect_int(loc.token->token, FDT_NOD_BEGIN);
  74         expect_str(loc.node->name, "child@3");
  75     });
  76
  77     testcase("sibling-iter-3", {
  78         expect_false(fdt_next_sibling(loc, &loc));
  79
  80         expect_true(fdt_node_end(loc.token));
  81     });
  82 }
  83
  84 static void
  85 test_fdt_descend_ascend(ptr_t dtb)
  86 {
  87     struct fdt_blob fdt;
  88     fdt_loc_t loc;
  89     int depth = 0;
  90
  91     fdt_load(&fdt, dtb);
  92     loc = fdt.root;
  93
  94     testcase("descend-to-child1", {
  95         loc = fdt_descend_into(loc);
  96
  97         expect_int(loc.token->token, FDT_NOD_BEGIN);
  98         expect_str(loc.node->name, "child@1");
  99     });
 100
 101     testcase("goto-child2", {
 102         expect_true(fdt_next_sibling(loc, &loc));
 103
 104         expect_int(loc.token->token, FDT_NOD_BEGIN);
 105         expect_str(loc.node->name, "child@2");
 106
 107         loc = fdt_descend_into(loc);
 108
 109         expect_int(loc.token->token, FDT_PROP);
 110         expect_str(fdt_prop_key(&fdt, loc), "prop-child2");
 111     });
 112
 113     testcase("descend-on-prop", {
 114         loc = fdt_descend_into(loc);
 115
 116         expect_true(loc.ptr == loc.ptr);
 117         expect_int(loc.token->token, FDT_PROP);
 118         expect_str(fdt_prop_key(&fdt, loc), "prop-child2");
 119     });
 120
 121     testcase("descend-to-child21", {
 122         expect_true(fdt_next_sibling(loc, &loc));
 123
 124         expect_int(loc.token->token, FDT_NOD_BEGIN);
 125         expect_str(loc.node->name, "child@21");
 126     });
 127
 128     testcase("ascend", {
 129         loc = fdt_ascend_from(loc);
 130
 131         expect_int(loc.token->token, FDT_NOD_BEGIN);
 132         expect_str(loc.node->name, "child@3");
 133     });
 134
 135     testcase("ascend-to-root", {
 136         loc = fdt_ascend_from(loc);
 137
 138         expect_true(fdt_node_end(loc.token));
 139     });
 140 }
 141
 142
 143 static void
 144 test_find_prop(ptr_t dtb)
 145 {
 146     struct fdt_blob fdt;
 147     fdt_loc_t loc;
 148     struct dtp_val val;
 149     int depth = 0;
 150
 151     fdt_load(&fdt, dtb);
 152     loc = fdt.root;
 153
 154     testcase("prop-find-child1", {
 155         loc = fdt_descend_into(loc);
 156         expect_int(loc.token->token, FDT_NOD_BEGIN);
 157         expect_str(loc.node->name, "child@1");
 158
 159         expect_true(fdt_find_prop(&fdt, loc, "prop-child1", &val));
 160         expect_int(val.size, 0);
 161
 162         expect_false(fdt_find_prop(&fdt, loc, "prop-child2", &val));
 163     });
 164 }
 165
 166 void
 167 run_test(int argc, const char* argv[])
 168 {
 169     ptr_t dtb = load_fdt();
 170
 171     test_fdt_basic_iter(dtb);
 172     test_fdt_descend_ascend(dtb);
 173     test_fdt_sibling_iter(dtb);
 174     test_find_prop(dtb);
 175 }