static int destroy_queues(void)
{
int i, j, prios;
prios = odp_schedule_num_prio();
for (i = 0; i < prios; i++) {
for (j = 0; j < QUEUES_PER_PRIO; j++) {
char name[32];
snprintf(name, sizeof(name), "sched_%d_%d_n", i, j);
if (destroy_queue(name) != 0)
return -1;
snprintf(name, sizeof(name), "sched_%d_%d_a", i, j);
if (destroy_queue(name) != 0)
return -1;
snprintf(name, sizeof(name), "sched_%d_%d_o", i, j);
if (destroy_queue(name) != 0)
return -1;
snprintf(name, sizeof(name), "plain_%d_%d_o", i, j);
if (destroy_queue(name) != 0)
return -1;
}
}
if (odp_pool_destroy(queue_ctx_pool) != 0) {
fprintf(stderr, "error: failed to destroy queue ctx pool\n");
return -1;
}
return 0;
}
void
test_AppendQueues(void) {
queue* q1 = create_queue();
queue* q2 = create_queue();
queue* q3 = create_queue();
queue* q4 = create_queue();
queue* q5 = create_queue();
// append empty queue to empty queue
append_queue(q1, q2);
element *e1_ptr, *e2_ptr, *e3_ptr, *e4_ptr, *e5_ptr, *e6_ptr;
e1_ptr = (element*)debug_get_node(sizeof(element));
e2_ptr = (element*)debug_get_node(sizeof(element));
e3_ptr = (element*)debug_get_node(sizeof(element));
e4_ptr = (element*)debug_get_node(sizeof(element));
e5_ptr = (element*)debug_get_node(sizeof(element));
e6_ptr = (element*)debug_get_node(sizeof(element));
enqueue(q1, e1_ptr);
enqueue(q1, e2_ptr);
enqueue(q1, e3_ptr);
// append empty queue to non empty queue
append_queue(q1, q3);
TEST_ASSERT_EQUAL(3, get_no_of_elements(q1));
// append non empty queue to empty queue
append_queue(q4, q1);
TEST_ASSERT_EQUAL(3, get_no_of_elements(q4));
enqueue(q5, e4_ptr);
enqueue(q5, e5_ptr);
// append non empty queue to non empty queue
append_queue(q4, q5);
TEST_ASSERT_EQUAL(5, get_no_of_elements(q4));
dequeue(q4);
dequeue(q4);
dequeue(q4);
dequeue(q4);
dequeue(q4);
free_node(e1_ptr);
free_node(e2_ptr);
free_node(e3_ptr);
free_node(e4_ptr);
free_node(e5_ptr);
TEST_ASSERT_EQUAL(0, get_no_of_elements(q4));
destroy_queue(q1);
destroy_queue(q2);
destroy_queue(q3);
destroy_queue(q4);
}
Alert get_alert(XmlElement xml_alert)
{
Alert alert = malloc(sizeof(struct Alert));
Queue alert_info = xml_element_children(xml_alert);
while (!queue_empty(alert_info))
{
XmlElement el = queue_dequeue(alert_info);
const char *element = xml_element_name(el);
if (str_equals(element, "summary")) {
alert->summary = strdup(xml_element_content(el));
} else if (str_equals(element, "description")) {
alert->description = strdup(xml_element_content(el));
} else if (str_equals(element, "location")) {
alert->location = strdup(xml_element_content(el));
}
free_xml_element(el);
}
destroy_queue(alert_info);
return alert;
}// End of get_alert method
int judge()//判断失败与否
{
LinkList p;
if(snake.length >= MAX_FOOD){
system("cls");
gotoxy(4,20);
puts("恭喜你,赢了!!!");
exit(0);
}
//碰到自身
p = snake.front->next;
while(snake.rear != p){
if(snake.rear->x == p->x && snake.rear->y == p->y){ break; }
else{ p = p->next; }
}
if(snake.rear == p){
//碰到边界
if(snake.rear->x >= 1 && snake.rear->y >= 1 && snake.rear->x < MAX__X && snake.rear->y < MAX__Y){
return 1;
}
}
system("cls");
gotoxy(4,20);
puts("GAME OVER!!!");
destroy_queue();
getch();
exit(0);
}
int main()
{
int data_de = 0; //用来保存出队的元素值
//创建队列并进行入队测试
PQUEUE pS = create_queue();
en_queue(pS,2);
en_queue(pS,4);
en_queue(pS,6);
traverse_queue(pS);
//出队测试
if(de_queue(pS,&data_de))
printf("delete succeed,the deleted data is: %d\n",data_de);
else
printf("queue is empty! delete falied!\n");
traverse_queue(pS);
//销毁队列测试
destroy_queue(pS);
printf("queue destroyed!\n");
traverse_queue(pS);
return 0;
}
int
main(void)
{
int i, r;
c_queue *q = init_queue(5);
int items[] = {1,2,3,4,5,6};
for(i = 0; i < 5; i++) {
enqueue(q, (queue_data_t)&items[i]);
}
r = enqueue(q, (queue_data_t)&items[5]);
if(r != 1) {
return 1;
}
for(i = 0; i < 3; i++) {
r = *((int *)dequeue(q));
printf("item=%d\n", r);
}
for(i = 0; i < 3; i++) {
enqueue(q, (queue_data_t)&items[i]);
}
r = enqueue(q, (queue_data_t)&items[5]);
if(r != 1) {
return 1;
}
destroy_queue(q);
return 0;
}
void
test_OneElementQueue(void) {
queue* q = create_queue();
TEST_ASSERT_NOT_NULL(q);
element e = {"string", 3};
element* e_ptr = debug_get_node(sizeof(element));
enqueue(q, e_ptr);
*e_ptr = e;
TEST_ASSERT_FALSE(empty(q));
TEST_ASSERT_NOT_NULL(queue_head(q));
TEST_ASSERT_EQUAL(1, get_no_of_elements(q));
element* e_ptr_returned = dequeue(q);
TEST_ASSERT_NOT_NULL(e_ptr_returned);
TEST_ASSERT_EQUAL_STRING(e_ptr_returned->str, "string");
TEST_ASSERT_EQUAL_PTR(e_ptr_returned, e_ptr);
TEST_ASSERT_EQUAL(0, get_no_of_elements(q));
TEST_ASSERT_TRUE(empty(q));
TEST_ASSERT_NULL(dequeue(q));
destroy_queue(q);
}
int
main() {
queue_t *q;
item_t t;
int i,j;
q = create_queue(3);
i = 0;
while( fscanf(stdin, "%d", &t) == 1 ) {
if( ! t ) {
if( ! i ) fprintf(stderr, "queue is alread empty\n");
else {
fprintf(stdout, "%d\n", dequeue(q));
i--;
}
} else {
enqueue(q, t);
i++;
}
}
for( j = 0; j < i; j++ ) {
fprintf(stdout, "%d\n", dequeue(q));
}
destroy_queue(q);
return 0;
}
int main()
{
int msg_id = creat_msg_queue();
if(msg_id <0)
{
printf("%d : %s\n",errno,strerror(errno));
return 1;
}
char buf[_SIZE_];
while(1)
{
memset(buf,'\0',sizeof(buf));
recv_msg(msg_id,client_type,buf);
printf("client:%s\n",buf);
if(strcasecmp(buf,"quit") == 0)
{
break;
}
printf("client say done,Please Enter# ");
fflush(stdout);
ssize_t _s = read(0,buf,sizeof(buf)-1);
if(_s > 0)
{
buf[_s - 1] = '\0';
}
send_msg(msg_id,server_type,buf);
}
destroy_queue(msg_id);
return 0;
}
int main(void)
{
struct queue queue;
int i;
init_queue(&queue);
for (i = 0; i < MAX_QUEUE_SIZE; i++) {
enqueue(&queue, i);
}
print_queue(&queue);
if (1 != is_queue_full(&queue))
enqueue(&queue, 10);
print_queue(&queue);
fprintf(stdout, "front :%d, rear :%d\n",
queue.front, queue.rear);
int data;
fprintf(stdout, "dequeue\n");
dequeue(&queue, &data);
fprintf(stdout, "data :%d\n", data);
enqueue(&queue, 11);
fprintf(stdout, "front :%d, rear :%d\n",
queue.front, queue.rear);
print_queue(&queue);
destroy_queue(&queue);
return 0;
}
void test_empty() {
queue *q = create_queue();
assert(empty(q));
destroy_queue(q);
}
void destroy_game(void) {
destroy_blockmap(impl.bm);
destroy_canvas(impl.cvs);
destroy_canvas(impl.pnl);
destroy_shapebuf(impl.sb);
destroy_queue(impl.queue);
destroy_ui();
}
void
destroy_block_queue(block_queue *p)
{
pthread_mutex_destroy(&(p->lock));
pthread_cond_destroy(&(p->notEmpty));
pthread_cond_destroy(&(p->notFull));
destroy_queue(p->queue);
free(p);
}
/* Define a function to append a queue onto another.
* Note: there is a faster way (O(1) as opposed to O(n))
* to do this for simple (FIFO) queues, but we can't rely on
* that for priority queues. (Given the current representation)
*
* I don't anticipate this to be a problem. If it does turn
* out to be a bottleneck, I will consider replacing the
* current implementation with a binomial or fibonacci heap.
*/
void append_queue(
queue *q1,
queue *q2
)
{
while (!empty(q2))
enqueue(q1, dequeue(q2));
destroy_queue(q2);
}
void
expect_new_queues_to_not_be_null() {
Queue *q = new_queue();
assert(q != NULL);
assert(q->in != NULL);
assert(q->out != NULL);
destroy_queue(q);
}
void
test_CustomOrderQueue(void) {
queue* q = debug_create_priority_queue(compare_elements);
element *e1_ptr, *e2_ptr, *e3_ptr, *e4_ptr, *e5_ptr, *e6_ptr;
e1_ptr = (element*)debug_get_node(sizeof(element));
e2_ptr = (element*)debug_get_node(sizeof(element));
e3_ptr = (element*)debug_get_node(sizeof(element));
e4_ptr = (element*)debug_get_node(sizeof(element));
e5_ptr = (element*)debug_get_node(sizeof(element));
e6_ptr = (element*)debug_get_node(sizeof(element));
e1_ptr->number = 1;
e2_ptr->number = 1;
e3_ptr->number = 10;
e4_ptr->number = 10;
e5_ptr->number = 100;
e6_ptr->number = 100;
enqueue(q, e3_ptr);
enqueue(q, e5_ptr);
enqueue(q, e2_ptr);
enqueue(q, e1_ptr);
enqueue(q, e4_ptr);
enqueue(q, e6_ptr);
TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 100);
TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 100);
TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 100);
TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 100);
TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 10);
TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 10);
TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 10);
TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 10);
TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 1);
TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 1);
TEST_ASSERT_EQUAL(((element*)queue_head(q))->number, 1);
TEST_ASSERT_EQUAL(((element*)dequeue(q))->number, 1);
TEST_ASSERT_TRUE(empty(q));
destroy_queue(q);
free_node(e1_ptr);
free_node(e2_ptr);
free_node(e3_ptr);
free_node(e4_ptr);
free_node(e5_ptr);
free_node(e6_ptr);
}
int pomme_tp_distroy(pomme_tpool_t *ptp)
{
int ret = 0;
assert( ptp != NULL );
if( ptp->stoped != 1)
{
ptp->stop(ptp);
}
destroy_queue(ptp->workers);
destroy_queue(ptp->finished);
free(ptp->tids);
ret = sem_destroy(&ptp->sem);
memset(ptp, 0, sizeof(ptp));
return ret;
}
void
test_EmptyQueue(void) {
queue* q = create_queue();
TEST_ASSERT_NOT_NULL(q);
TEST_ASSERT_TRUE(empty(q));
TEST_ASSERT_NULL(queue_head(q));
TEST_ASSERT_NULL(dequeue(q));
TEST_ASSERT_EQUAL(0, get_no_of_elements(q));
destroy_queue(q);
}
void
expect_queue_to_accept_many_elements(int n_elements) {
int i;
Queue *q = new_queue();
for (i = 0; i < n_elements; i++) {
assert(push_queue(q, i) == 0);
}
for (i = 0; i < n_elements; i++) {
assert(pop_queue(q) == i);
}
destroy_queue(q);
}
int main()
{
Queue q = create_queue(2);
enqueue(q, 'a');
enqueue(q, 'b');
enqueue(q, 'c');
printf("dequeue:%c\n", dequeue(q));
printf("dequeue:%c\n", dequeue(q));
printf("dequeue:%c\n", dequeue(q));
destroy_queue(q);
return 0;
}
void test_all() {
queue *q = create_queue();
enqueue(q, 100);
assert(empty(q) == false);
assert(dequeue(q) == 100);
enqueue(q, 200);
enqueue(q, 300);
enqueue(q, 400);
assert(dequeue(q) == 200);
assert(dequeue(q) == 300);
assert(dequeue(q) == 400);
assert(empty(q));
destroy_queue(q);
}
void snake_move()//实现玩家控制蛇的移动
{
char c,pause;
static char temp = 0;//静态局部变量
pause = 0;
if( !temp){//一开始的时候让蛇先自动移动
temp = 'd';
snake_auto_move(temp);
}
while(1){
c = getch();
if(c == ESC){//退出
system("cls");
puts("游戏退出成功!");
system("pause");
destroy_queue();
exit(0);
}
if(pause == SPACE){
if(c == SPACE){//再按下空格键继续游戏
pause = 0;
gotoxy(6,20);
printf(" ");//消除~~Pause~~:
snake_auto_move(temp);
}
continue;
}
if(c == SPACE){//按空格键暂停游戏
pause = SPACE;
gotoxy(6,20);
printf("~~Pause~~:");
continue;
}
if(c == 'w' || c == 'a' || c == 's' || c == 'd'){
if((temp == 'w' && c == 's') || (temp == 's' && c == 'w') || (temp == 'd' && c == 'a') || (temp == 'a' && c == 'd')){//不允许连续的两次内按相反的键
snake_auto_move(temp);
continue;
}
break;
}
snake_auto_move(temp);
}
temp = c;
snake_auto_move(temp);
}
void destroy_supervisor(supervisor_thread_t *thiz) {
if(thiz) {
int w = 0;
for(w = 0; w < thiz->config->num_workers; w++) {
destroy_worker(thiz->worker_threads[w]);
}
thiz->worker_threads = NULL;
destroy_rate_limiter(thiz->rate_limiter);
destroy_queue(thiz->queue);
destroy_config(thiz->config);
destroy_worker_array();
TESR_LOG_FREE(thiz, supervisor_thread_t);
free(thiz);
thiz = NULL;
} else {
LOG_ERROR("can not free supervisor_thread_t* as it is NULL");
}
}
/*
get_alerts(filename) Loads the alerts from file.
*/
Queue get_alerts(const char *filename)
{
XmlDocument doc = load_xml_document(filename);
XmlElement root = xml_document_root_node(doc);
Queue xml_alerts = xml_element_children(root);
Queue alerts = create_queue(destroy_alert);
while (!queue_empty(xml_alerts))
{
XmlElement el_alert = queue_dequeue(xml_alerts);
queue_queue(alerts, get_alert(el_alert));
free_xml_element(el_alert);
}// End of while
destroy_queue(xml_alerts);
return alerts;
}// End of get_alerts method
int tp_destroy_thread_pool(struct thread_pool *pool) // , struct work_queue* wq )
{
int i = 0;
/* /// tell all threads to exit
for(i=0; i<pool->num_threads; i++){
pool->arg1[i] = arg_invalid; // pass an invalid args, tell thread i to terminate
sem_post( &pool->sem[i] ); // awake thread i
//dbg(" resume thread %d\n", i);
}
*/
printf("start to destroy thread_pool \"%s\" ...\n", pool->name);
for (i = 0; i < pool->num_threads; i++) {
workqueue_enqueue(pool->queue, NULL, 0, arg_invalid, arg_invalid);
}
/// wait for all thread to terminate
for (i = 0; i < pool->num_threads; i++) {
pthread_join(pool->thread[i], NULL);
//dbg(" join thread %d\n", i);
}
///////// mutex and bitmap are not necessary now
pthread_mutex_destroy(&pool->mutex);
//bmp_destroy( & pool->bitmap);
///////////////
for (i = 0; i < pool->num_threads; i++) {
//sem_destroy( &pool->sem[i] );
}
if (pool->queue) {
destroy_queue(pool->queue);
pool->queue = NULL;
}
free(pool);
printf("thread_pool \"%s\" released...\n", pool->name);
return i; // return num of threads terminated
}
int main(void)
{
// Setup modules
setup_xml();
Queue alerts = get_alerts("test.xml");
while(!queue_empty(alerts))
{
Alert alert = queue_dequeue(alerts);
printf("%s\n", alert->summary);
printf(" For: %s\n", alert->location);
printf(" %s\n", alert->description);
}// End of while
destroy_queue(alerts);
// Cleanup modules
cleanup_xml();
}// End of main method
void
expect_push_queue_and_pop_queue_to_work_consistently() {
Queue *q = new_queue();
assert(push_queue(q, 1) == 0);
assert(push_queue(q, 2) == 0);
assert(push_queue(q, 3) == 0);
assert(push_queue(q, 4) == 0);
assert(push_queue(q, 5) == 0);
assert(pop_queue(q) == 1);
assert(pop_queue(q) == 2);
assert(pop_queue(q) == 3);
assert(pop_queue(q) == 4);
assert(pop_queue(q) == 5);
assert(pop_queue(q) == -1);
destroy_queue(q);
}
int main()
{
queue_t *q1 = mk_queue();
printf("%d\n", get_len(q1));
printf("%d\n", is_queue_empty(q1));
enqueue(q1, mk_task(f1,(void *) 5));
enqueue(q1, mk_task(f2, (void *)7));
printf("%d\n", get_len(q1));
printf("%d\n", is_queue_empty(q1));
enqueue(q1, mk_task(f2, (void *)2));
enqueue(q1, mk_task(f1, (void *)9));
printf("%d\n", get_len(q1));
printf("%d\n", is_queue_empty(q1));
run_task(dequeue(q1));
run_task(dequeue(q1));
printf("%d\n", get_len(q1));
printf("%d\n", is_queue_empty(q1));
run_task(dequeue(q1));
run_task(dequeue(q1));
printf("%d\n", get_len(q1));
printf("%d\n", is_queue_empty(q1));
empty_queue(q1);
enqueue(q1, mk_task(f2, (void *)2));
enqueue(q1, mk_task(f1, (void *)9));
printf("%d\n", get_len(q1));
printf("%d\n", is_queue_empty(q1));
destroy_queue(q1);
}
void
test_DestroyNonEmptyQueue(void) {
queue* q = create_queue();
element *e1_ptr, *e2_ptr, *e3_ptr, *e4_ptr, *e5_ptr, *e6_ptr;
e1_ptr = (element*)debug_get_node(sizeof(element));
e2_ptr = (element*)debug_get_node(sizeof(element));
e3_ptr = (element*)debug_get_node(sizeof(element));
e4_ptr = (element*)debug_get_node(sizeof(element));
e5_ptr = (element*)debug_get_node(sizeof(element));
e6_ptr = (element*)debug_get_node(sizeof(element));
enqueue(q, e3_ptr);
enqueue(q, e2_ptr);
enqueue(q, e4_ptr);
enqueue(q, e1_ptr);
enqueue(q, e6_ptr);
enqueue(q, e5_ptr);
destroy_queue(q);
}
void
test_MultipleElementQueue(void) {
queue* q = create_queue();
TEST_ASSERT_NOT_NULL(q);
element *e1_ptr, *e2_ptr, *e3_ptr;
e1_ptr = (element*)debug_get_node(sizeof(element));
e2_ptr = (element*)debug_get_node(sizeof(element));
e3_ptr = (element*)debug_get_node(sizeof(element));
enqueue(q, e1_ptr);
enqueue(q, e2_ptr);
enqueue(q, e3_ptr);
TEST_ASSERT_EQUAL(3, get_no_of_elements(q));
dequeue(q);
enqueue(q, e1_ptr);
TEST_ASSERT_EQUAL(3, get_no_of_elements(q));
dequeue(q);
dequeue(q);
enqueue(q, e3_ptr);
enqueue(q, e2_ptr);
TEST_ASSERT_EQUAL_PTR(dequeue(q), e1_ptr);
TEST_ASSERT_EQUAL_PTR(dequeue(q), e3_ptr);
TEST_ASSERT_EQUAL_PTR(dequeue(q), e2_ptr);
TEST_ASSERT_EQUAL(0, get_no_of_elements(q));
TEST_ASSERT_NULL(dequeue(q));
destroy_queue(q);
}
