test/test_queue_priority.c

   1 #include "queue.h"
   2 #include "song.h"
   3
   4 void
   5 song_free(G_GNUC_UNUSED struct song *song)
   6 {
   7 }
   8
   9 G_GNUC_UNUSED
  10 static void
  11 dump_order(const struct queue *queue)
  12 {
  13         g_printerr("queue length=%u, order:\n", queue_length(queue));
  14         for (unsigned i = 0; i < queue_length(queue); ++i)
  15                 g_printerr("  [%u] -> %u (prio=%u)\n", i, queue->order[i],
  16                            queue->items[queue->order[i]].priority);
  17 }
  18
  19 static void
  20 check_descending_priority(G_GNUC_UNUSED const struct queue *queue,
  21                          unsigned start_order)
  22 {
  23         assert(start_order < queue_length(queue));
  24
  25         uint8_t last_priority = 0xff;
  26         for (unsigned order = start_order; order < queue_length(queue); ++order) {
  27                 unsigned position = queue_order_to_position(queue, order);
  28                 uint8_t priority = queue->items[position].priority;
  29                 assert(priority <= last_priority);
  30                 (void)last_priority;
  31                 last_priority = priority;
  32         }
  33 }
  34
  35 int
  36 main(G_GNUC_UNUSED int argc, G_GNUC_UNUSED char **argv)
  37 {
  38         struct song songs[16];
  39
  40         struct queue queue;
  41         queue_init(&queue, 32);
  42
  43         for (unsigned i = 0; i < G_N_ELEMENTS(songs); ++i)
  44                 queue_append(&queue, &songs[i]);
  45
  46         assert(queue_length(&queue) == G_N_ELEMENTS(songs));
  47
  48         /* priority=10 for 4 items */
  49
  50         queue_set_priority_range(&queue, 4, 8, 10, -1);
  51
  52         queue.random = true;
  53         queue_shuffle_order(&queue);
  54         check_descending_priority(&queue, 0);
  55
  56         for (unsigned i = 0; i < 4; ++i) {
  57                 assert(queue_position_to_order(&queue, i) >= 4);
  58         }
  59
  60         for (unsigned i = 4; i < 8; ++i) {
  61                 assert(queue_position_to_order(&queue, i) < 4);
  62         }
  63
  64         for (unsigned i = 8; i < G_N_ELEMENTS(songs); ++i) {
  65                 assert(queue_position_to_order(&queue, i) >= 4);
  66         }
  67
  68         /* priority=50 one more item */
  69
  70         queue_set_priority_range(&queue, 15, 16, 50, -1);
  71         check_descending_priority(&queue, 0);
  72
  73         assert(queue_position_to_order(&queue, 15) == 0);
  74
  75         for (unsigned i = 0; i < 4; ++i) {
  76                 assert(queue_position_to_order(&queue, i) >= 4);
  77         }
  78
  79         for (unsigned i = 4; i < 8; ++i) {
  80                 assert(queue_position_to_order(&queue, i) >= 1 &&
  81                        queue_position_to_order(&queue, i) < 5);
  82         }
  83
  84         for (unsigned i = 8; i < 15; ++i) {
  85                 assert(queue_position_to_order(&queue, i) >= 5);
  86         }
  87
  88         /* priority=20 for one of the 4 priority=10 items */
  89
  90         queue_set_priority_range(&queue, 3, 4, 20, -1);
  91         check_descending_priority(&queue, 0);
  92
  93         assert(queue_position_to_order(&queue, 3) == 1);
  94         assert(queue_position_to_order(&queue, 15) == 0);
  95
  96         for (unsigned i = 0; i < 3; ++i) {
  97                 assert(queue_position_to_order(&queue, i) >= 5);
  98         }
  99
 100         for (unsigned i = 4; i < 8; ++i) {
 101                 assert(queue_position_to_order(&queue, i) >= 2 &&
 102                        queue_position_to_order(&queue, i) < 6);
 103         }
 104
 105         for (unsigned i = 8; i < 15; ++i) {
 106                 assert(queue_position_to_order(&queue, i) >= 6);
 107         }
 108
 109         /* priority=20 for another one of the 4 priority=10 items;
 110            pass "after_order" (with priority=10) and see if it's moved
 111            after that one */
 112
 113         unsigned current_order = 4;
 114         unsigned current_position =
 115                 queue_order_to_position(&queue, current_order);
 116
 117         unsigned a_order = 3;
 118         unsigned a_position = queue_order_to_position(&queue, a_order);
 119         assert(queue.items[a_position].priority == 10);
 120         queue_set_priority(&queue, a_position, 20, current_order);
 121
 122         current_order = queue_position_to_order(&queue, current_position);
 123         assert(current_order == 3);
 124
 125         a_order = queue_position_to_order(&queue, a_position);
 126         assert(a_order == 4);
 127
 128         check_descending_priority(&queue, current_order + 1);
 129
 130         /* priority=70 for one of the last items; must be inserted
 131            right after the current song, before the priority=20 one we
 132            just created */
 133
 134         unsigned b_order = 10;
 135         unsigned b_position = queue_order_to_position(&queue, b_order);
 136         assert(queue.items[b_position].priority == 0);
 137         queue_set_priority(&queue, b_position, 70, current_order);
 138
 139         current_order = queue_position_to_order(&queue, current_position);
 140         assert(current_order == 3);
 141
 142         b_order = queue_position_to_order(&queue, b_position);
 143         assert(b_order == 4);
 144
 145         check_descending_priority(&queue, current_order + 1);
 146
 147         /* priority=60 for the old prio50 item; must not be moved,
 148            because it's before the current song, and it's status
 149            hasn't changed (it was already higher before) */
 150
 151         unsigned c_order = 0;
 152         unsigned c_position = queue_order_to_position(&queue, c_order);
 153         assert(queue.items[c_position].priority == 50);
 154         queue_set_priority(&queue, c_position, 60, current_order);
 155
 156         current_order = queue_position_to_order(&queue, current_position);
 157         assert(current_order == 3);
 158
 159         c_order = queue_position_to_order(&queue, c_position);
 160         assert(c_order == 0);
 161
 162         /* move the prio=20 item back */
 163
 164         a_order = queue_position_to_order(&queue, a_position);
 165         assert(a_order == 5);
 166         assert(queue.items[a_position].priority == 20);
 167         queue_set_priority(&queue, a_position, 5, current_order);
 168
 169
 170         current_order = queue_position_to_order(&queue, current_position);
 171         assert(current_order == 3);
 172
 173         a_order = queue_position_to_order(&queue, a_position);
 174         assert(a_order == 6);
 175 }