/[LeafOK_CVS]/lbbs/src/test_section_list.c
ViewVC logotype

Diff of /lbbs/src/test_section_list.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.18 by sysadm, Sat May 24 03:32:32 2025 UTC Revision 1.46 by sysadm, Sat Jan 3 10:27:14 2026 UTC
# Line 1  Line 1 
1  /***************************************************************************  /* SPDX-License-Identifier: GPL-3.0-or-later */
2                                          file_section_list.c  -  description  /*
3                                                           -------------------   * test_section_list
4          Copyright            : (C) 2004-2025 by Leaflet   *   - tester for data models and basic operations of section and article
5          Email                : leaflet@leafok.com   *
6   ***************************************************************************/   * Copyright (C) 2004-2026  Leaflet <leaflet@leafok.com>
7     */
8  /***************************************************************************  
9   *                                                                         *  #ifdef HAVE_CONFIG_H
10   *   This program is free software; you can redistribute it and/or modify  *  #include "config.h"
11   *   it under the terms of the GNU General Public License as published by  *  #endif
  *   the Free Software Foundation; either version 3 of the License, or     *  
  *   (at your option) any later version.                                   *  
  *                                                                         *  
  ***************************************************************************/  
12    
 #include "section_list.h"  
13  #include "bbs.h"  #include "bbs.h"
14  #include "log.h"  #include "log.h"
15    #include "section_list.h"
16    #include "trie_dict.h"
17    #include "user_list.h"
18    #include <errno.h>
19  #include <stdio.h>  #include <stdio.h>
20  #include <unistd.h>  #include <unistd.h>
 #include <errno.h>  
21    
22  #define ARTICLE_BLOCK_SHM_FILE "~article_block_shm.dat"  static const char ARTICLE_BLOCK_SHM_FILE[] = "~article_block_shm.dat";
23  #define SECTION_LIST_SHM_FILE "~section_list_shm.dat"  static const char SECTION_LIST_SHM_FILE[] = "~section_list_shm.dat";
24    static const char TRIE_DICT_SHM_FILE[] = "~trie_dict_shm.dat";
25    static const char USER_LIST_SHM_FILE[] = "~user_list_shm.dat";
26    
27  const char *sname[] = {  const char *sname[] = {
28          "Test",          "Test",
# Line 31  const char *sname[] = { Line 31  const char *sname[] = {
31    
32  const char *stitle[] = {  const char *stitle[] = {
33          " Test Section ",          " Test Section ",
34          "ĸABC",          "字母组合ABC",
35          "__123"};          "_数字_123"};
36    
37  const char *master_name[] = {  const char *master_name[] = {
38          "sysadm",          "sysadm",
# Line 68  int main(int argc, char *argv[]) Line 68  int main(int argc, char *argv[])
68                  return -1;                  return -1;
69          }          }
70    
71          log_std_redirect(STDOUT_FILENO);          log_common_redir(STDOUT_FILENO);
72          log_err_redirect(STDERR_FILENO);          log_error_redir(STDERR_FILENO);
73    
74          // - 1 to make blocks allocated is less than required, to trigger error handling          // - 1 to make blocks allocated is less than required, to trigger error handling
75          block_count = BBS_article_limit_per_section * BBS_max_section / ARTICLE_PER_BLOCK;          block_count = BBS_article_limit_per_section * BBS_max_section / BBS_article_count_per_block;
76    
77          if ((fp = fopen(ARTICLE_BLOCK_SHM_FILE, "w")) == NULL)          if ((fp = fopen(ARTICLE_BLOCK_SHM_FILE, "w")) == NULL)
78          {          {
79                  log_error("fopen(%s) error\n", ARTICLE_BLOCK_SHM_FILE);                  log_error("fopen(%s) error", ARTICLE_BLOCK_SHM_FILE);
80                  return -1;                  return -1;
81          }          }
82          fclose(fp);          fclose(fp);
83    
84          if ((fp = fopen(SECTION_LIST_SHM_FILE, "w")) == NULL)          if ((fp = fopen(SECTION_LIST_SHM_FILE, "w")) == NULL)
85          {          {
86                  log_error("fopen(%s) error\n", SECTION_LIST_SHM_FILE);                  log_error("fopen(%s) error", SECTION_LIST_SHM_FILE);
87                  return -1;                  return -1;
88          }          }
89          fclose(fp);          fclose(fp);
90    
91            if ((fp = fopen(TRIE_DICT_SHM_FILE, "w")) == NULL)
92            {
93                    log_error("fopen(%s) error", TRIE_DICT_SHM_FILE);
94                    return -1;
95            }
96            fclose(fp);
97    
98            if ((fp = fopen(USER_LIST_SHM_FILE, "w")) == NULL)
99            {
100                    log_error("fopen(%s) error", USER_LIST_SHM_FILE);
101                    return -1;
102            }
103            fclose(fp);
104    
105            if (trie_dict_init(TRIE_DICT_SHM_FILE, TRIE_NODE_PER_POOL) < 0)
106            {
107                    printf("trie_dict_init failed\n");
108                    return -1;
109            }
110    
111          if (article_block_init(ARTICLE_BLOCK_SHM_FILE, block_count) < 0)          if (article_block_init(ARTICLE_BLOCK_SHM_FILE, block_count) < 0)
112          {          {
113                  log_error("article_block_init(%s, %d) error\n", ARTICLE_BLOCK_SHM_FILE, block_count);                  log_error("article_block_init(%s, %d) error", ARTICLE_BLOCK_SHM_FILE, block_count);
114                    return -2;
115            }
116    
117            if (section_list_init(SECTION_LIST_SHM_FILE) < 0)
118            {
119                    log_error("section_list_pool_init(%s) error", SECTION_LIST_SHM_FILE);
120                  return -2;                  return -2;
121          }          }
122    
123          if (section_list_pool_init(SECTION_LIST_SHM_FILE) < 0)          // Load user_list and online_user_list
124            if (user_list_pool_init(USER_LIST_SHM_FILE) < 0)
125          {          {
126                  log_error("section_list_pool_init(%s) error\n", SECTION_LIST_SHM_FILE);                  log_error("user_list_pool_init() error");
127                  return -2;                  return -2;
128          }          }
129    
# Line 104  int main(int argc, char *argv[]) Line 131  int main(int argc, char *argv[])
131    
132          last_aid = 0;          last_aid = 0;
133    
134            if (section_list_rw_lock(NULL) < 0)
135            {
136                    printf("section_list_rw_lock(sid = %d) error\n", 0);
137            }
138    
139          for (i = 0; i < section_count; i++)          for (i = 0; i < section_count; i++)
140          {          {
141                  sid = i * 3 + 1;                  sid = i * 3 + 1;
# Line 113  int main(int argc, char *argv[]) Line 145  int main(int argc, char *argv[])
145                                                                                     master_name[i % section_conf_count]);                                                                                     master_name[i % section_conf_count]);
146                  if (p_section[i] == NULL)                  if (p_section[i] == NULL)
147                  {                  {
148                          log_error("section_list_create(i = %d) error\n", i);                          printf("section_list_create(i = %d) error\n", i);
149                            return -3;
150                    }
151    
152                    if (get_section_index(p_section[i]) != i)
153                    {
154                            printf("get_section_index(i = %d) error\n", i);
155                          return -3;                          return -3;
156                  }                  }
157          }          }
# Line 130  int main(int argc, char *argv[]) Line 168  int main(int argc, char *argv[])
168          for (i = 0; i < section_count; i++)          for (i = 0; i < section_count; i++)
169          {          {
170                  sid = i * 3 + 1;                  sid = i * 3 + 1;
171                  if (section_list_find_by_sid(sid) == NULL)                  if (section_list_find_by_sid(sid) == NULL || section_list_find_by_sid(sid)->sid != sid)
172                  {                  {
173                          printf("section_list_find_by_sid(%d) error\n", sid);                          printf("section_list_find_by_sid(%d) error\n", sid);
174                          return -3;                          return -3;
175                  }                  }
176          }          }
177    
178            if (section_list_rw_unlock(NULL) < 0)
179            {
180                    printf("section_list_rw_unlock(sid = %d) error\n", 0);
181            }
182    
183          for (j = 0; j < BBS_article_limit_per_section; j++)          for (j = 0; j < BBS_article_limit_per_section; j++)
184          {          {
185                  for (i = 0; i < section_count; i++)                  for (i = 0; i < section_count; i++)
# Line 148  int main(int argc, char *argv[]) Line 191  int main(int argc, char *argv[])
191                          article.tid = 0;                          article.tid = 0;
192                          article.sid = i * 3 + 1;                          article.sid = i * 3 + 1;
193                          article.cid = article.aid;                          article.cid = article.aid;
194                          article.uid = 1; // TODO: randomize                          article.uid = 1;
195                          article.visible = 1;                          article.visible = 1;
196                          article.excerption = 0;                          article.excerption = 0;
197                          article.ontop = 0;                          article.ontop = 0;
198                          article.lock = 0;                          article.lock = 0;
199                            article.transship = 0;
200    
201                            if (section_list_rw_lock(p_section[i]) < 0)
202                            {
203                                    printf("section_list_rw_lock(sid = %d) error\n", p_section[i]->sid);
204                                    break;
205                            }
206    
207                          if (section_list_append_article(p_section[i], &article) < 0)                          if (section_list_append_article(p_section[i], &article) < 0)
208                          {                          {
209                                  printf("append article (aid = %d) error at section %d index %d\n", article.aid, i, j);                                  printf("append article (aid = %d) error at section %d index %d\n", article.aid, i, j);
210                                  break;                                  break;
211                          }                          }
212    
213                            if (section_list_rw_unlock(p_section[i]) < 0)
214                            {
215                                    printf("section_list_rw_unlock(sid = %d) error %d\n", p_section[i]->sid, errno);
216                                    break;
217                            }
218                  }                  }
219          }          }
220    
# Line 167  int main(int argc, char *argv[]) Line 223  int main(int argc, char *argv[])
223                  // printf("Loaded %d articles into section %d\n", p_section[i]->article_count, i);                  // printf("Loaded %d articles into section %d\n", p_section[i]->article_count, i);
224          }          }
225    
226            if (last_aid != article_block_last_aid())
227            {
228                    printf("last_aid != %d\n", article_block_last_aid());
229            }
230    
231            if (article_block_article_count() != section_count * BBS_article_limit_per_section)
232            {
233                    printf("article_block_article_count() error %d != %d * %d\n",
234                               article_block_article_count(), section_count, BBS_article_limit_per_section);
235            }
236    
237          last_aid = 0;          last_aid = 0;
238    
239          for (j = 0; j < BBS_article_limit_per_section; j++)          for (j = 0; j < BBS_article_limit_per_section; j++)
# Line 181  int main(int argc, char *argv[]) Line 248  int main(int argc, char *argv[])
248                                  printf("article_block_find_by_aid() at section %d index %d, %d != %d\n", i, j, p_article->aid, last_aid);                                  printf("article_block_find_by_aid() at section %d index %d, %d != %d\n", i, j, p_article->aid, last_aid);
249                          }                          }
250    
251                            if (section_list_rw_lock(p_section[i]) < 0)
252                            {
253                                    printf("section_list_rw_lock(sid = %d) error\n", p_section[i]->sid);
254                                    break;
255                            }
256    
257                          if (section_list_set_article_visible(p_section[i], p_article->aid, 0) != 1)                          if (section_list_set_article_visible(p_section[i], p_article->aid, 0) != 1)
258                          {                          {
259                                  printf("section_list_set_article_visible(aid = %d) error\n", p_article->aid);                                  printf("section_list_set_article_visible(aid = %d) error\n", p_article->aid);
260                          }                          }
261    
262                            if (section_list_rw_unlock(p_section[i]) < 0)
263                            {
264                                    printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
265                                    break;
266                            }
267                  }                  }
268    
269                  // printf("Verified %d articles in section %d\n", p_section[i]->article_count, i);                  // printf("Verified %d articles in section %d\n", p_section[i]->article_count, i);
# Line 192  int main(int argc, char *argv[]) Line 271  int main(int argc, char *argv[])
271    
272          printf("Testing #2 ...\n");          printf("Testing #2 ...\n");
273    
274            if (section_list_rw_lock(NULL) < 0)
275            {
276                    printf("section_list_rw_lock(sid = %d) error\n", 0);
277            }
278    
279          if (article_block_reset() != 0)          if (article_block_reset() != 0)
280          {          {
281                  log_error("article_block_reset() error\n");                  log_error("article_block_reset() error");
282                  return -4;                  return -4;
283          }          }
284    
# Line 203  int main(int argc, char *argv[]) Line 287  int main(int argc, char *argv[])
287                  section_list_reset_articles(p_section[i]);                  section_list_reset_articles(p_section[i]);
288          }          }
289    
290            if (section_list_rw_unlock(NULL) < 0)
291            {
292                    printf("section_list_rw_unlock(sid = %d) error\n", 0);
293            }
294    
295          last_aid = 0;          last_aid = 0;
296    
297          for (i = 0; i < section_count; i++)          for (i = 0; i < section_count; i++)
298          {          {
299                  section_first_aid = last_aid + 1;                  section_first_aid = last_aid + 1;
300    
301                    if (section_list_rw_lock(p_section[i]) < 0)
302                    {
303                            printf("section_list_rw_lock(sid = %d) error\n", p_section[i]->sid);
304                            break;
305                    }
306    
307                  for (j = 0; j < BBS_article_limit_per_section; j++)                  for (j = 0; j < BBS_article_limit_per_section; j++)
308                  {                  {
309                          last_aid++;                          last_aid++;
# Line 219  int main(int argc, char *argv[]) Line 314  int main(int argc, char *argv[])
314                          article.tid = ((article.aid < section_first_aid + group_count) ? 0 : (section_first_aid + j % group_count));                          article.tid = ((article.aid < section_first_aid + group_count) ? 0 : (section_first_aid + j % group_count));
315                          article.sid = i * 3 + 1;                          article.sid = i * 3 + 1;
316                          article.cid = article.aid;                          article.cid = article.aid;
317                          article.uid = 1; // TODO: randomize                          article.uid = 1;
318                          article.visible = 1;                          article.visible = 1;
319                          article.excerption = 0;                          article.excerption = 0;
320                          article.ontop = 0;                          article.ontop = 0;
321                          article.lock = 0;                          article.lock = 0;
322                            article.transship = 0;
323    
324                          if (section_list_append_article(p_section[i], &article) < 0)                          if (section_list_append_article(p_section[i], &article) < 0)
325                          {                          {
# Line 232  int main(int argc, char *argv[]) Line 328  int main(int argc, char *argv[])
328                          }                          }
329                  }                  }
330    
331                    if (section_list_rw_unlock(p_section[i]) < 0)
332                    {
333                            printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
334                            break;
335                    }
336    
337                  // printf("Loaded %d articles into section %d\n", p_section[i]->article_count, i);                  // printf("Loaded %d articles into section %d\n", p_section[i]->article_count, i);
338          }          }
339    
# Line 245  int main(int argc, char *argv[]) Line 347  int main(int argc, char *argv[])
347                  article_count = 0;                  article_count = 0;
348                  last_aid = 0;                  last_aid = 0;
349    
350                    if (section_list_rd_lock(p_section[i]) < 0)
351                    {
352                            printf("section_list_rd_lock(sid = %d) error\n", p_section[i]->sid);
353                            break;
354                    }
355    
356                  p_article = p_section[i]->p_article_head;                  p_article = p_section[i]->p_article_head;
357    
358                  do                  do
# Line 267  int main(int argc, char *argv[]) Line 375  int main(int argc, char *argv[])
375                          break;                          break;
376                  }                  }
377    
378                    if (section_list_rd_unlock(p_section[i]) < 0)
379                    {
380                            printf("section_list_rd_unlock(sid = %d) error\n", p_section[i]->sid);
381                            break;
382                    }
383    
384                  // printf("Verified %d articles in section %d\n", group_count, i);                  // printf("Verified %d articles in section %d\n", group_count, i);
385          }          }
386    
# Line 277  int main(int argc, char *argv[]) Line 391  int main(int argc, char *argv[])
391                          continue;                          continue;
392                  }                  }
393    
394                    if (section_list_rd_lock(p_section[i]) < 0)
395                    {
396                            printf("section_list_rd_lock(sid = %d) error\n", p_section[i]->sid);
397                            break;
398                    }
399    
400                  if (p_section[i]->topic_count != group_count)                  if (p_section[i]->topic_count != group_count)
401                  {                  {
402                          printf("Inconsistent topic count in section %d, %d != %d\n", i, p_section[i]->topic_count, group_count);                          printf("Inconsistent topic count in section %d, %d != %d\n", i, p_section[i]->topic_count, group_count);
# Line 338  int main(int argc, char *argv[]) Line 458  int main(int argc, char *argv[])
458                          }                          }
459                  }                  }
460    
461                    if (section_list_rd_unlock(p_section[i]) < 0)
462                    {
463                            printf("section_list_rd_unlock(sid = %d) error\n", p_section[i]->sid);
464                            break;
465                    }
466    
467                  // printf("Verified %d topics in section %d\n", group_count, i);                  // printf("Verified %d topics in section %d\n", group_count, i);
468          }          }
469    
# Line 347  int main(int argc, char *argv[]) Line 473  int main(int argc, char *argv[])
473          {          {
474                  last_aid = 0;                  last_aid = 0;
475    
476                    if (section_list_rd_lock(p_section[i]) < 0)
477                    {
478                            printf("section_list_rd_lock(sid = %d) error\n", p_section[i]->sid);
479                            break;
480                    }
481    
482                  for (j = 0; j < p_section[i]->page_count; j++)                  for (j = 0; j < p_section[i]->page_count; j++)
483                  {                  {
484                          if (p_section[i]->p_page_first_article[j]->aid <= last_aid)                          if (p_section[i]->p_page_first_article[j]->aid <= last_aid)
# Line 371  int main(int argc, char *argv[]) Line 503  int main(int argc, char *argv[])
503                                  }                                  }
504                          }                          }
505                  }                  }
506    
507                    if (section_list_rd_unlock(p_section[i]) < 0)
508                    {
509                            printf("section_list_rd_unlock(sid = %d) error\n", p_section[i]->sid);
510                            break;
511                    }
512          }          }
513    
514          printf("Testing #4 ...\n");          printf("Testing #4 ...\n");
515    
516          for (i = 0; i < section_count; i++)          for (i = 0; i < section_count; i++)
517          {          {
518                    if (section_list_rw_lock(p_section[i]) < 0)
519                    {
520                            printf("section_list_rw_lock(sid = %d) error\n", p_section[i]->sid);
521                            break;
522                    }
523    
524                  step = i % 10 + 1;                  step = i % 10 + 1;
525                  for (j = group_count; j < BBS_article_limit_per_section; j += step)                  for (j = group_count; j < BBS_article_limit_per_section; j += step)
526                  {                  {
# Line 414  int main(int argc, char *argv[]) Line 558  int main(int argc, char *argv[])
558                                  (p_section[i]->visible_article_count % BBS_article_limit_per_page ? 1 : 0) !=                                  (p_section[i]->visible_article_count % BBS_article_limit_per_page ? 1 : 0) !=
559                          p_section[i]->page_count)                          p_section[i]->page_count)
560                  {                  {
561                          printf("Inconsistent page count in section %d offset %d, %d != %d, "                          printf("#1 Inconsistent page count in section %d offset %d, %d != %d, "
562                                     "visible_article_count = %d, last_page_visible_count = %d\n",                                     "visible_article_count = %d, last_page_visible_count = %d\n",
563                                     i, j,                                     i, j,
564                                     p_section[i]->visible_article_count / BBS_article_limit_per_page +                                     p_section[i]->visible_article_count / BBS_article_limit_per_page +
# Line 497  int main(int argc, char *argv[]) Line 641  int main(int argc, char *argv[])
641                                  (p_section[i]->visible_article_count % BBS_article_limit_per_page ? 1 : 0) !=                                  (p_section[i]->visible_article_count % BBS_article_limit_per_page ? 1 : 0) !=
642                          p_section[i]->page_count)                          p_section[i]->page_count)
643                  {                  {
644                          printf("Inconsistent page count in section %d offset %d, %d != %d, "                          printf("#2 Inconsistent page count in section %d offset %d, %d != %d, "
645                                     "visible_article_count = %d, last_page_visible_count = %d\n",                                     "visible_article_count = %d, last_page_visible_count = %d\n",
646                                     i, j,                                     i, j,
647                                     p_section[i]->visible_article_count / BBS_article_limit_per_page +                                     p_section[i]->visible_article_count / BBS_article_limit_per_page +
# Line 506  int main(int argc, char *argv[]) Line 650  int main(int argc, char *argv[])
650                                     p_section[i]->last_page_visible_article_count);                                     p_section[i]->last_page_visible_article_count);
651                          break;                          break;
652                  }                  }
653    
654                    if (section_list_rw_unlock(p_section[i]) < 0)
655                    {
656                            printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
657                            break;
658                    }
659          }          }
660    
661          for (i = 0; i < BBS_max_section; i++)          for (i = 0; i < BBS_max_section; i++)
662          {          {
663                    if (section_list_rw_lock(p_section[i]) < 0)
664                    {
665                            printf("section_list_rw_lock(sid = %d) error\n", p_section[i]->sid);
666                            break;
667                    }
668    
669                  affected_count = 0;                  affected_count = 0;
670    
671                  for (j = 0; j < BBS_article_limit_per_section; j += 1)                  for (j = 0; j < BBS_article_limit_per_section; j += 1)
# Line 554  int main(int argc, char *argv[]) Line 710  int main(int argc, char *argv[])
710                                  (p_section[i]->visible_article_count % BBS_article_limit_per_page ? 1 : 0) !=                                  (p_section[i]->visible_article_count % BBS_article_limit_per_page ? 1 : 0) !=
711                          p_section[i]->page_count)                          p_section[i]->page_count)
712                  {                  {
713                          printf("Inconsistent page count in section %d offset %d, %d != %d, "                          printf("#3 Inconsistent page count in section %d offset %d, %d != %d, "
714                                     "visible_article_count = %d, last_page_visible_count = %d\n",                                     "visible_article_count = %d, last_page_visible_count = %d\n",
715                                     i, j,                                     i, j,
716                                     p_section[i]->visible_article_count / BBS_article_limit_per_page +                                     p_section[i]->visible_article_count / BBS_article_limit_per_page +
# Line 563  int main(int argc, char *argv[]) Line 719  int main(int argc, char *argv[])
719                                     p_section[i]->last_page_visible_article_count);                                     p_section[i]->last_page_visible_article_count);
720                          break;                          break;
721                  }                  }
722    
723                    if (section_list_rw_unlock(p_section[i]) < 0)
724                    {
725                            printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
726                            break;
727                    }
728          }          }
729    
730          printf("Testing #5 ...\n");          printf("Testing #5 ...\n");
731    
732            if (section_list_rw_lock(NULL) < 0)
733            {
734                    printf("section_list_rw_lock(sid = %d) error\n", 0);
735            }
736    
737          if (article_block_reset() != 0)          if (article_block_reset() != 0)
738          {          {
739                  log_error("article_block_reset() error\n");                  log_error("article_block_reset() error");
740                  return -4;                  return -4;
741          }          }
742    
# Line 578  int main(int argc, char *argv[]) Line 745  int main(int argc, char *argv[])
745                  section_list_reset_articles(p_section[i]);                  section_list_reset_articles(p_section[i]);
746          }          }
747    
748            if (section_list_rw_unlock(NULL) < 0)
749            {
750                    printf("section_list_rw_unlock(sid = %d) error\n", 0);
751            }
752    
753          last_aid = 0;          last_aid = 0;
754    
755          for (i = 0; i < section_count / 2; i++)          for (i = 0; i < section_count / 2; i++)
756          {          {
757                    if (section_list_rw_lock(p_section[i]) < 0)
758                    {
759                            printf("section_list_rw_lock(sid = %d) error\n", p_section[i]->sid);
760                            break;
761                    }
762    
763                  section_first_aid = last_aid + 1;                  section_first_aid = last_aid + 1;
764    
765                  for (j = 0; j < BBS_article_limit_per_section; j++)                  for (j = 0; j < BBS_article_limit_per_section; j++)
# Line 594  int main(int argc, char *argv[]) Line 772  int main(int argc, char *argv[])
772                          article.tid = ((article.aid < section_first_aid + group_count) ? 0 : (section_first_aid + j % group_count));                          article.tid = ((article.aid < section_first_aid + group_count) ? 0 : (section_first_aid + j % group_count));
773                          article.sid = i * 3 + 1;                          article.sid = i * 3 + 1;
774                          article.cid = article.aid;                          article.cid = article.aid;
775                          article.uid = 1; // TODO: randomize                          article.uid = 1;
776                          article.visible = 1;                          article.visible = 1;
777                          article.excerption = 0;                          article.excerption = 0;
778                          article.ontop = 0;                          article.ontop = 0;
779                          article.lock = 0;                          article.lock = 0;
780                            article.transship = 0;
781    
782                          if (section_list_append_article(p_section[i], &article) < 0)                          if (section_list_append_article(p_section[i], &article) < 0)
783                          {                          {
# Line 607  int main(int argc, char *argv[]) Line 786  int main(int argc, char *argv[])
786                          }                          }
787                  }                  }
788    
789                    if (section_list_rw_unlock(p_section[i]) < 0)
790                    {
791                            printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
792                            break;
793                    }
794    
795                  // printf("Loaded %d articles into section %d\n", p_section[i]->article_count, i);                  // printf("Loaded %d articles into section %d\n", p_section[i]->article_count, i);
796          }          }
797    
798          for (i = 0; i < section_count / 2; i++)          for (i = 0; i < section_count / 2; i++)
799          {          {
800                    if (section_list_rw_lock(p_section[i]) < 0)
801                    {
802                            printf("section_list_rw_lock(sid = %d) error\n", p_section[i]->sid);
803                            break;
804                    }
805    
806                  section_first_aid = p_section[i]->p_article_head->aid;                  section_first_aid = p_section[i]->p_article_head->aid;
807    
808                  for (j = 0; j < group_count; j += 2)                  for (j = 0; j < group_count; j += 2)
# Line 629  int main(int argc, char *argv[]) Line 820  int main(int argc, char *argv[])
820                                  printf("section_list_set_article_visible(aid = %d) error\n", p_article->aid);                                  printf("section_list_set_article_visible(aid = %d) error\n", p_article->aid);
821                          }                          }
822                  }                  }
823    
824                    if (section_list_rw_unlock(p_section[i]) < 0)
825                    {
826                            printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
827                            break;
828                    }
829          }          }
830    
831          for (i = 0; i < section_count / 2; i++)          for (i = 0; i < section_count / 2; i++)
832          {          {
833                    if (section_list_rw_lock(p_section[i]) < 0)
834                    {
835                            printf("section_list_rw_lock(sid = %d) error\n", p_section[i]->sid);
836                            break;
837                    }
838    
839                    if (section_list_rw_lock(p_section[section_count / 2 + i]) < 0)
840                    {
841                            printf("section_list_rw_lock(sid = %d) error\n", p_section[section_count / 2 + i]->sid);
842    
843                            if (section_list_rw_unlock(p_section[i]) < 0)
844                            {
845                                    printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
846                            }
847                            break;
848                    }
849    
850                  section_first_aid = p_section[i]->p_article_head->aid;                  section_first_aid = p_section[i]->p_article_head->aid;
851    
852                  for (j = 0; j < group_count; j++)                  for (j = 0; j < group_count; j++)
# Line 653  int main(int argc, char *argv[]) Line 867  int main(int argc, char *argv[])
867                                  // break;                                  // break;
868                          }                          }
869                  }                  }
870    
871                    if (section_list_rw_unlock(p_section[i]) < 0)
872                    {
873                            printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
874                            break;
875                    }
876    
877                    if (section_list_rw_unlock(p_section[section_count / 2 + i]) < 0)
878                    {
879                            printf("section_list_rw_unlock(sid = %d) error\n", p_section[section_count / 2 + i]->sid);
880    
881                            if (section_list_rw_unlock(p_section[i]) < 0)
882                            {
883                                    printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
884                            }
885                            break;
886                    }
887          }          }
888    
889          for (i = 0; i < section_count; i++)          for (i = 0; i < section_count; i++)
890          {          {
891                    if (section_list_rd_lock(p_section[i]) < 0)
892                    {
893                            printf("section_list_rd_lock(sid = %d) error\n", p_section[i]->sid);
894                            break;
895                    }
896    
897                  if (p_section[i]->topic_count != (i < section_count / 2 ? 0 : group_count))                  if (p_section[i]->topic_count != (i < section_count / 2 ? 0 : group_count))
898                  {                  {
899                          printf("Topic count error in section %d, %d != %d\n", i,                          printf("Topic count error in section %d, %d != %d\n", i,
# Line 691  int main(int argc, char *argv[]) Line 928  int main(int argc, char *argv[])
928                                     p_section[i]->page_count, (i < section_count / 2 ? 0 : BBS_article_limit_per_section / 2 / BBS_article_limit_per_page));                                     p_section[i]->page_count, (i < section_count / 2 ? 0 : BBS_article_limit_per_section / 2 / BBS_article_limit_per_page));
929                          break;                          break;
930                  }                  }
931    
932                    if (section_list_rd_unlock(p_section[i]) < 0)
933                    {
934                            printf("section_list_rd_unlock(sid = %d) error\n", p_section[i]->sid);
935                            break;
936                    }
937            }
938    
939            printf("Testing #6 ...\n");
940    
941            for (i = 0; i < section_count; i++)
942            {
943                    if (section_list_rd_lock(p_section[i]) < 0)
944                    {
945                            printf("section_list_rd_lock(sid = %d) error\n", p_section[i]->sid);
946                            break;
947                    }
948            }
949    
950            printf("Try rw_lock for 5 sec...\n");
951            if (section_list_try_rw_lock(NULL, 5) == 0)
952            {
953                    printf("section_list_try_rw_lock(sid = %d) error, expectation is timeout\n", p_section[i]->sid);
954            }
955    
956            for (i = 0; i < section_count; i++)
957            {
958                    if (section_list_rd_unlock(p_section[i]) < 0)
959                    {
960                            printf("section_list_rd_unlock(sid = %d) error\n", p_section[i]->sid);
961                            break;
962                    }
963            }
964    
965            if (section_list_try_rw_lock(NULL, 5) < 0)
966            {
967                    printf("section_list_rd_lock(sid = %d) error\n", p_section[i]->sid);
968            }
969    
970            for (i = 0; i < section_count; i++)
971            {
972                    if (section_list_try_rd_lock(p_section[i], 0) == 0)
973                    {
974                            printf("section_list_try_rd_lock(sid = %d) error, expectation is timeout\n", p_section[i]->sid);
975                            break;
976                    }
977            }
978    
979            if (section_list_rw_unlock(NULL) < 0)
980            {
981                    printf("section_list_rw_unlock(sid = %d) error\n", p_section[i]->sid);
982          }          }
983    
984          printf("Press ENTER to exit...");          printf("Press ENTER to exit...");
985          getchar();          getchar();
986    
987            user_list_pool_cleanup();
988            section_list_cleanup();
989          article_block_cleanup();          article_block_cleanup();
990          section_list_pool_cleanup();          trie_dict_cleanup();
991    
992            if (unlink(USER_LIST_SHM_FILE) < 0)
993            {
994                    log_error("unlink(%s) error", USER_LIST_SHM_FILE);
995                    return -1;
996            }
997    
998            if (unlink(TRIE_DICT_SHM_FILE) < 0)
999            {
1000                    log_error("unlink(%s) error", TRIE_DICT_SHM_FILE);
1001                    return -1;
1002            }
1003    
1004          if (unlink(ARTICLE_BLOCK_SHM_FILE) < 0)          if (unlink(ARTICLE_BLOCK_SHM_FILE) < 0)
1005          {          {
1006                  log_error("unlink(%s) error\n", ARTICLE_BLOCK_SHM_FILE);                  log_error("unlink(%s) error", ARTICLE_BLOCK_SHM_FILE);
1007                  return -1;                  return -1;
1008          }          }
1009    
1010          if (unlink(SECTION_LIST_SHM_FILE) < 0)          if (unlink(SECTION_LIST_SHM_FILE) < 0)
1011          {          {
1012                  log_error("unlink(%s) error\n", SECTION_LIST_SHM_FILE);                  log_error("unlink(%s) error", SECTION_LIST_SHM_FILE);
1013                  return -1;                  return -1;
1014          }          }
1015    

Legend:
Removed lines/characters  
Changed lines/characters
  Added lines/characters
webmaster@leafok.com
 ViewVC Help
Powered by ViewVC 1.3.0-beta1