pkg: use a blob buffer in pkg_t to store variable fields
[oweals/opkg-lede.git] / tests / opkg_active_list_test.c
1 /* opkg_active_list.c - the opkg package management system
2
3    Tick Chen <tick@openmoko.com>
4
5    Copyright (C) 2008 Openmoko
6
7    This program is free software; you can redistribute it and/or
8    modify it under the terms of the GNU General Public License as
9    published by the Free Software Foundation; either version 2, or (at
10    your option) any later version.
11
12    This program is distributed in the hope that it will be useful, but
13    WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    General Public License for more details.
16 */
17
18 #include <stdlib.h>
19 #include <libopkg/active_list.h>
20 #include <active_list.h>
21 #include <stdio.h>
22
23 struct active_test {
24         char *str;
25         struct active_list list;
26 };
27
28 struct active_test *active_test_new(char *str)
29 {
30         struct active_test *ans =
31             (struct active_test *)calloc(1, sizeof(struct active_test));
32         ans->str = str;
33         active_list_init(&ans->list);
34         return ans;
35 }
36
37 void active_test_add(struct active_list *head, struct active_test *node)
38 {
39         active_list_add(head, &node->list);
40 }
41
42 void active_test_add_depend(struct active_test *A, struct active_test *B)
43 {
44         active_list_add_depend(&A->list, &B->list);
45 }
46
47 /*
48 .--A---B----C----D-----E----F
49     |             |__k---L
50     |                    |_ N
51     |__ G ---H ---I---J
52              |_M      |_O
53
54 Then the sequence will be
55 +: G M H I O J A B K N L C D E F
56 -: F E D C L N K B A J O I H M G
57 */
58 void make_list(struct active_list *head)
59 {
60         struct active_test *A = active_test_new("A");
61         struct active_test *B = active_test_new("B");
62         struct active_test *C = active_test_new("C");
63         struct active_test *D = active_test_new("D");
64         struct active_test *E = active_test_new("E");
65         struct active_test *F = active_test_new("F");
66         struct active_test *G = active_test_new("G");
67         struct active_test *H = active_test_new("H");
68         struct active_test *I = active_test_new("I");
69         struct active_test *J = active_test_new("J");
70         struct active_test *K = active_test_new("K");
71         struct active_test *L = active_test_new("L");
72         struct active_test *M = active_test_new("M");
73         struct active_test *N = active_test_new("N");
74         struct active_test *O = active_test_new("O");
75
76         active_test_add(head, A);
77         active_test_add(head, B);
78         active_test_add(head, C);
79         active_test_add(head, D);
80         active_test_add(head, E);
81         active_test_add(head, F);
82         active_test_add(head, G);
83         active_test_add(head, H);
84         active_test_add(head, I);
85         active_test_add(head, J);
86         active_test_add(head, K);
87         active_test_add(head, L);
88         active_test_add(head, M);
89         active_test_add(head, N);
90         active_test_add(head, O);
91         active_test_add_depend(H, M);
92         active_test_add_depend(A, G);
93         active_test_add_depend(A, H);
94         active_test_add_depend(A, I);
95         active_test_add_depend(A, J);
96         active_test_add_depend(J, O);
97         active_test_add_depend(C, K);
98         active_test_add_depend(C, L);
99         active_test_add_depend(L, N);
100 }
101
102 int active_test_compare(const void *a, const void *b)
103 {
104         struct active_list *first = (struct active_list *)a;
105         struct active_list *second = (struct active_list *)b;
106         return strcmp(list_entry(first, struct active_test, list),
107                       list_entry(second, struct active_test, list));
108 }
109
110 void show_list(struct active_list *head)
111 {
112         struct active_list *ptr;
113         struct active_test *test;
114         for (ptr = active_list_next(head, NULL); ptr;
115              ptr = active_list_next(head, ptr)) {
116                 test = list_entry(ptr, struct active_test, list);
117                 printf("%s ", test->str);
118         }
119         printf("\n");
120 }
121
122 int main(void)
123 {
124         struct active_list head;
125         struct active_list *ptr;
126         struct active_test *test;
127         active_list_init(&head);
128         make_list(&head);
129
130         printf("pos order: ");
131         show_list(&head);
132 /*    for(ptr = active_list_next(&head, &head); ptr ;ptr = active_list_next(&head, ptr)) {
133         test = list_entry(ptr, struct active_test, list);
134         printf ("%s ",test->str);
135     }*/
136         printf("neg order: ");
137         for (ptr = active_list_prev(&head, &head); ptr;
138              ptr = active_list_prev(&head, ptr)) {
139                 test = list_entry(ptr, struct active_test, list);
140                 printf("%s ", test->str);
141         }
142         printf("\npos order after sort: ");
143         active_list_sort(&head, &active_test_compare);
144         show_list(&head);
145
146         printf("after clear: ");
147         active_list_clear(&head);
148         for (ptr = active_list_next(&head, NULL); ptr;
149              ptr = active_list_next(&head, ptr)) {
150                 test = list_entry(ptr, struct active_test, list);
151                 printf("%s ", test->str);
152         }
153         printf("\n");
154
155 }