예제 #1
0
long TMAVectorOrdered::addElement(PMAObject obj)
{
    // Si no hay elementos, insertamos directamente.
    //
    if (size()==0) return add_element(obj,0);
    
    // En otro caso ordenamos.
    //
    long index_izq=0,index_der=il_count-1,index=0;
    
    while (index_izq<=index_der)
    {
        index = (index_izq + index_der)/2;
        PMAObject obj1 = CItems[index];
        switch (io_comp->compare(*obj,*obj1))
        {
            case -1: // obj<obj1
                index_der=index-1;
                break;
                
            case 0: // obj=obj1
                index_izq=index+1;
                break;
                
            case 1: // obj>obj1
                index_izq=index+1;
                break;
        }        
    }        
    if (index>il_count) index=il_count;
    if (index<0) index=0;
    
    return add_element(obj,index);
}
예제 #2
0
파일: parser.c 프로젝트: bsansouci/c-server
struct LList *parse(char *source, char *deliminator){
	char buffer[strlen(source)+1];
	unsigned long delim_len = strlen(deliminator);
	struct LList *list = new_list();
	char *tmp;
	char c;
	int i, j, k=0, index;

	for (i=0; i < strlen(source); i++){
		if (source[i] == deliminator[0]){
			index = i;
			for (j=0; source[index+j] == deliminator[j]; j++){
				if (j+1 == delim_len){
					buffer[k] = '\0';
					tmp = malloc(sizeof(char)*strlen(buffer)+1);
					strcpy(tmp, buffer);
					add_element(tmp, list);
					k = 0;
					i += delim_len;
					break;
				}
			}
		}
		c = source[i];
		buffer[k] = c;
		k++;
	}
	buffer[k] = '\0';
	tmp = malloc(sizeof(char)*strlen(buffer)+1);
	strcpy(tmp, buffer);
	add_element(tmp, list);
	return list;
}
예제 #3
0
파일: Scene.cpp 프로젝트: lonnell/trick
int main(int argc, char* argv[]) {

    glutInit(&argc, argv);

    display_init();

    comm_initialize();

   /* Call backs */
    glutDisplayFunc( display);
    glutReshapeFunc( reshape);
    glutKeyboardFunc( keyboard);
    glutIdleFunc( comm_read);

    satellite = add_element("Satellite");
    satellite_camera = new Camera();
    current_camera = satellite_camera;

    planet = add_element("Ball");
    for (int ii=0; ii<3 ; ii++) { planet->pos[ii] = 0.0; }

    glutMainLoop();

    return 0;

}
static int handle_boolean(void *ctx, int boolVal)
{
  state_t *st = (state_t *)ctx;
  if (boolVal) {
    add_element(st, enif_make_atom(st->env, "true"));
  } else {
    add_element(st, enif_make_atom(st->env, "false"));
  }
  return 1;
}
void bfs(lptr svd)                //creates dictionary in disk
{
 qptr q;
 FILE *dic;
 lptr l1,l2,l3;//
 q=(qptr)malloc(sizeof(struct queue));
 initialize(q);
 add_element(q,svd);
 dic=fopen("dictionary","wb+");
 //printf("%s\n",svd->key);                                 //WRITE IN FILE
 fwrite(svd,sizeof(struct node),1,dic); 
 
 while(!empty(q))
 {
  l1=remove_element(q);
  l1->visited=1;
  if(l1->lchild!=NULL)
  {
   if(l1->lchild->visited!=1)
   {
    add_element(q,l1->lchild);
    //printf("%s \n",l1->lchild->key);
    fwrite(l1->lchild,sizeof(struct node),1,dic); 
   }
   else
   {
    //printf("%s \n",l1->lchild->key);
    fwrite(l1->lchild,sizeof(struct node),1,dic); 
   } 
  }
  if(l1->rchild!=NULL)
  {
   if(l1->rchild->visited!=1)
   {
    add_element(q,l1->rchild);
    //printf("%s \n",l1->rchild->key);
    fwrite(l1->rchild,sizeof(struct node),1,dic); 
   }
   else
   {
    //printf("%s \n",l1->rchild->key); 
    fwrite(l1->rchild,sizeof(struct node),1,dic);     
   }
  } 
 }
 fclose(dic);
 dic=fopen("dictionary","rb");
 printf("--------Dictionary contents--------\n");
 while(fread(l1,sizeof(struct node),1,dic))
 printf("\n%s",l1->key);
 printf("\n--------------------------------\n");
 //reconstruct();
 fclose(dic); 
}  
예제 #6
0
ErrorStack ArrayMetadataSerializer::save(tinyxml2::XMLElement* element) const {
  CHECK_ERROR(save_base(element));
  CHECK_ERROR(add_element(element, "payload_size_", "", data_casted_->payload_size_));
  CHECK_ERROR(add_element(
    element,
    "snapshot_drop_volatile_pages_threshold_",
    "",
    data_casted_->snapshot_drop_volatile_pages_threshold_));
  CHECK_ERROR(add_element(element, "array_size_", "", data_casted_->array_size_));
  return kRetOk;
}
예제 #7
0
파일: prstat.c 프로젝트: andreiw/polaris
static void
fill_table(table_t *table, char *arg, char option)
{
	char *p = strtok(arg, ", ");

	if (p == NULL)
		Die(gettext("invalid argument for -%c\n"), option);

	add_element(table, (long)Atoi(p));
	while (p = strtok(NULL, ", "))
		add_element(table, (long)Atoi(p));
}
예제 #8
0
    void filter::build_index()
    {
        index_.clear();
        tools::substring all(&values_[0], &values_[0] + values_.size());

        for ( tools::substring sub; tools::split(all, ',', sub, all); )
        {
            add_element(sub.begin(), sub.end());
        }

        add_element(all.begin(), all.end());

        std::sort(index_.begin(), index_.end(), sort_caseless());
    }
예제 #9
0
파일: mempool.c 프로젝트: 19Dan01/linux
/**
 * mempool_resize - resize an existing memory pool
 * @pool:       pointer to the memory pool which was allocated via
 *              mempool_create().
 * @new_min_nr: the new minimum number of elements guaranteed to be
 *              allocated for this pool.
 *
 * This function shrinks/grows the pool. In the case of growing,
 * it cannot be guaranteed that the pool will be grown to the new
 * size immediately, but new mempool_free() calls will refill it.
 * This function may sleep.
 *
 * Note, the caller must guarantee that no mempool_destroy is called
 * while this function is running. mempool_alloc() & mempool_free()
 * might be called (eg. from IRQ contexts) while this function executes.
 */
int mempool_resize(mempool_t *pool, int new_min_nr)
{
	void *element;
	void **new_elements;
	unsigned long flags;

	BUG_ON(new_min_nr <= 0);
	might_sleep();

	spin_lock_irqsave(&pool->lock, flags);
	if (new_min_nr <= pool->min_nr) {
		while (new_min_nr < pool->curr_nr) {
			element = remove_element(pool);
			spin_unlock_irqrestore(&pool->lock, flags);
			pool->free(element, pool->pool_data);
			spin_lock_irqsave(&pool->lock, flags);
		}
		pool->min_nr = new_min_nr;
		goto out_unlock;
	}
	spin_unlock_irqrestore(&pool->lock, flags);

	/* Grow the pool */
	new_elements = kmalloc_array(new_min_nr, sizeof(*new_elements),
				     GFP_KERNEL);
	if (!new_elements)
		return -ENOMEM;

	spin_lock_irqsave(&pool->lock, flags);
	if (unlikely(new_min_nr <= pool->min_nr)) {
		/* Raced, other resize will do our work */
		spin_unlock_irqrestore(&pool->lock, flags);
		kfree(new_elements);
		goto out;
	}
	memcpy(new_elements, pool->elements,
			pool->curr_nr * sizeof(*new_elements));
	kfree(pool->elements);
	pool->elements = new_elements;
	pool->min_nr = new_min_nr;

	while (pool->curr_nr < pool->min_nr) {
		spin_unlock_irqrestore(&pool->lock, flags);
		element = pool->alloc(GFP_KERNEL, pool->pool_data);
		if (!element)
			goto out;
		spin_lock_irqsave(&pool->lock, flags);
		if (pool->curr_nr < pool->min_nr) {
			add_element(pool, element);
		} else {
			spin_unlock_irqrestore(&pool->lock, flags);
			pool->free(element, pool->pool_data);	/* Raced */
			goto out;
		}
	}
out_unlock:
	spin_unlock_irqrestore(&pool->lock, flags);
out:
	return 0;
}
예제 #10
0
파일: libprob1.c 프로젝트: pepecortes/mit-C
/* store_result() - store record from database in B-tree
 * this function is also a valid callback for use with sqlite3_exec()
 * pextra is again unused
 *
 * needs to return zero (nonzero aborts SQL query)
 */
int store_result(void * pextra, int nfields, char ** arrvalues, char ** arrfieldnames) {
    int n;

    /* allocate record on heap */
    struct s_record * prec = alloc_record();


    prec->irecord = record_count+1;
    for (n = 0; n < nfields; n++) {
        if (strcasecmp(arrfieldnames[n], "MovieTitle") == 0)
            prec->name = strdup(arrvalues[n]); /* key */
        else if (strcasecmp(arrfieldnames[n], "MovieCategory") == 0)
            prec->category = strdup(arrvalues[n]);
        else if (strcasecmp(arrfieldnames[n], "ProductionYear") == 0)
            prec->year = atoi(arrvalues[n]);
        else if (strcasecmp(arrfieldnames[n], "Format") == 0)
            prec->format = strdup(arrvalues[n]);
        else if (strcasecmp(arrfieldnames[n], "Language") == 0)
            prec->language = strdup(arrvalues[n]);
        else if (strcasecmp(arrfieldnames[n], "Web") == 0)
            prec->url = strdup(arrvalues[n]);
    }

    /* add record to B-tree */
    if (add_element(prec->name, prec) != NULL) {
        /* element already exists -- don't add record */
        printf("Duplicate record exists: "); /* diagnostic value only */
        display_record(prec, stdout);
        free_record(prec);
    }

    return 0;
}
예제 #11
0
/**
 * mempool_fill - fill a memory pool
 *  <at> pool:	memory pool to fill
 *  <at> gfp_mask:	allocation mask to use
 *
 * Allocate new elements with  <at> gfp_mask and fill  <at> pool so that it has
 *  <at> pool->min_nr elements.  Returns 0 on success, -errno on failure.
 */
static int mempool_fill(mempool_t *pool, gfp_t gfp_mask)
{
	/*
	 * If curr_nr == min_nr is visible, we're correct regardless of
	 * locking.
	 */
	while (pool->curr_nr < pool->min_nr) {
		void *elem;
		unsigned long flags;

		elem = pool->alloc(gfp_mask, pool->pool_data);
		if (unlikely(!elem))
			return -ENOMEM;

		spin_lock_irqsave(&pool->lock, flags);
		if (pool->curr_nr < pool->min_nr) {
			add_element(pool, elem);
			elem = NULL;
		}
		spin_unlock_irqrestore(&pool->lock, flags);

		if (elem) {
			pool->free(elem, pool->pool_data);
			return 0;
		}
	}
	return 0;
}
/* _VMKLNX_CODECHECK_: mempool_free */
void mempool_free(void *element, mempool_t *pool)
{
	unsigned long flags;

#if defined(__VMKLNX__)
	VMK_ASSERT(vmk_PreemptionIsEnabled() == VMK_FALSE);
#endif
	smp_mb();
	if (pool->curr_nr < pool->min_nr) {
		spin_lock_irqsave(&pool->lock, flags);
		if (pool->curr_nr < pool->min_nr) {
			add_element(pool, element);
			spin_unlock_irqrestore(&pool->lock, flags);
			wake_up(&pool->wait);
			return;
		}
		spin_unlock_irqrestore(&pool->lock, flags);
	}
#if defined(__VMKLNX__)
        VMKAPI_MODULE_CALL_VOID(pool->module_id, pool->free,
                                element, pool->pool_data);
#else /* !defined(__VMKLNX__) */
        pool->free(element, pool->pool_data);   
#endif /* defined(__VMKLNX__) */
}
예제 #13
0
파일: memcache.c 프로젝트: JustXxx/shark
/*
    @obj_size       :缓存对象大小
    @max_cache_size :最多缓存元素个数
    memcache原理:
    初始化时缓存max_cache_size/2个元素, 后续分配从cache中分, 如果超过cache部分,
    则malloc释放回来的时候, 也最多装满max_cache_size个元素, 多的部分free掉
    max_cache_size的选择应该选择大部分时候使用的量, 不要选择极端情形下的内存数字
*/
struct memcache *memcache_create(size_t obj_size, int max_cache_size)
{
    struct memcache *cache;
    size_t size = sizeof(struct memcache) + max_cache_size * sizeof(void *);

    assert(max_cache_size >= 2);

    cache = (struct memcache *)malloc(size);
    if (NULL == cache)
        return NULL;

    cache->elements = (void **)((char *)cache + sizeof(struct memcache));
    cache->obj_size = obj_size;
    cache->cache_size = max_cache_size;
    cache->curr = 0;

    max_cache_size >>= 2;
    while (cache->curr < max_cache_size)
    {
        void *element = malloc(cache->obj_size);
        if (NULL == element)
        {
            free_pool(cache);
            return NULL;
        }

        add_element(cache, element);
    }

    return cache;
}
예제 #14
0
mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn,
			mempool_free_t *free_fn, void *pool_data, int node_id)
{
	mempool_t *pool;
	pool = kmalloc_node(sizeof(*pool), GFP_KERNEL | __GFP_ZERO, node_id);
	if (!pool)
		return NULL;
	pool->elements = kmalloc_node(min_nr * sizeof(void *),
					GFP_KERNEL, node_id);
	if (!pool->elements) {
		kfree(pool);
		return NULL;
	}
	spin_lock_init(&pool->lock);
	pool->min_nr = min_nr;
	pool->pool_data = pool_data;
	init_waitqueue_head(&pool->wait);
	pool->alloc = alloc_fn;
	pool->free = free_fn;

	/*
	 * First pre-allocate the guaranteed number of buffers.
	 */
	while (pool->curr_nr < pool->min_nr) {
		void *element;

		element = pool->alloc(GFP_KERNEL, pool->pool_data);
		if (unlikely(!element)) {
			free_pool(pool);
			return NULL;
		}
		add_element(pool, element);
	}
	return pool;
}
예제 #15
0
	bool RStarTreeNode::insert(const BoundedObjectPtr element)
	{
		Uint32 i;

		if (get_leaf())
		{
			return add_element(element);
		}
		else
		{
			for (i = 0; i < get_count(); i++)
			{
				if (get_element_bounding_box(i).contains(
					element->get_bounding_box()))
				{
					if (get_node(i)->insert(element))
					{
						return true;
					}
				}
			}

			return false;
		}
	}
/* Function to read in a file of entrants */
void read_entrants(FILE *file, event *e) {
    entrant *entrant_data;
    list_node *new_element;
    course *course;
    int status;
    
    while (!feof(file)) {
        entrant_data = malloc(sizeof(entrant));
 
        new_element = malloc(sizeof(list_node));
        status = fscanf(file, "%d %c %[a-zA-Z ]\n", &entrant_data->number,
                &entrant_data->course, entrant_data->name);
        
        if(status != EOF) {
            entrant_data->state.type = NOT_STARTED;
            entrant_data->start_time = 0;
            entrant_data->end_time = 0;

            course = find_course(e->courselist, entrant_data->course);
            entrant_data->current_track = course->tracks.head;

            entrant_data->state.nodes_visited = 0;
            entrant_data->state.location_ref = 0;
            entrant_data->state.type = NOT_STARTED;
            entrant_data->state.late = 0;
            entrant_data->mc_time_delay = 0;
            
            new_element->data = entrant_data;
            new_element->next = NULL;
            add_element(&e->entrantlist, new_element);
        }
    } 
}
예제 #17
0
파일: send.c 프로젝트: Ankirama/Epitech
/*
** @brief create a list from a string
**
** It will store our string converted in our mwrite_buffer struct with fd
**
** @param server main structure
** @param fd file descriptor
** @return 0 if no error else 1
*/
static int	_split_msg_list(t_server *server, int fd, char *msg)
{
  int		begin;
  int		len;
  char		*tmp;
  int		error;

  begin = 0;
  error = 0;
  len = strlen(msg);
  while (begin < len && error == 0)
    {
      if (!(tmp = strndup(&msg[begin], MAX_MSG)))
	error = 1;
      if (add_element(&(server->write_buffer[fd]), my_strdup(tmp), strlen(tmp)))
	error = 2;
      free(tmp);
      begin += MAX_MSG;
    }
  if (error == 0)
    return (0);
  else if (error == 2)
    free(tmp);
  return (1);
}
예제 #18
0
/**
 * Inserts new element in the list.  If the index is past the end of
 * the list
 * it creates the list and add the element as first element of list.
 * @param new_element the element to be add in the list.
 * @return 32-bit integer on the success returns 1.
 */
OSCL_EXPORT_REF int32 Oscl_Linked_List_Base::insert_element(const OsclAny* new_element, int index)
{
    if (index >= num_elements)
    {
        return add_element(new_element);
    }
    else if (index == 0)
    {
        return add_to_front(new_element);
    }
    else
    {
        OsclAny *tmp, *next, *newelem;
        int32 ii;
        if (index < 0)
            return 0;
        for (tmp = head, ii = 0; ii < index - 1; ++ii, tmp = pOpaqueType->get_next(tmp))
            { }

        next = pOpaqueType->get_next(tmp);
        newelem = pOpaqueType->allocate(sizeof_T);
        if (newelem == NULL)
            return 0;
        pOpaqueType->construct(newelem, new_element);
        pOpaqueType->set_next(tmp, newelem);
        pOpaqueType->set_next(newelem, next);
        ++num_elements;
        return 1;
    }
    return 0;
}
예제 #19
0
void* ecriture(void* arg) {
	pthread_t tid = pthread_self () ;
  	srand ((int) tid) ;

	// on effectue soit un ajout soit une suppression
  	int val = rand()%2;
  	if (val) {
  		val = rand()%2 + 1;

  		printf("Rédacteur %lu, ajoute la valeur %d dans la liste\n", (unsigned long) tid, val);

  		struct linked_list *l;
  		l = malloc(sizeof(struct linked_list));
  		l->nb = val;
  		l->next = NULL;

  		add_element(&liste, l);
  	} else {
  		val = rand()%2 + 1;

  		struct linked_list *l;
  		if ((l = remove_element(&liste, val)) != NULL) {
  			printf("Rédacteur %lu, supprime la valeur %d dans la liste si elle existe : réussi\n", (unsigned long) tid, val);
  			free(l);
  		} else {
  			printf("Rédacteur %lu, supprime la valeur %d dans la liste si elle existe : raté\n", (unsigned long) tid, val);
  		}
  	}

	return NULL;
}
TEST(molecular_mass_test_case, molecular_mass_test)
{
    auto subs = ChemicalSubstance::from_string("H2");
    ASSERT_NEAR(subs.get_molecular_mass(), 2., 0.1);

    subs.add_element(Element(2), 3);
    ASSERT_NEAR(subs.get_molecular_mass(), 14., 0.1);
}
예제 #21
0
void TMAVectorBase::fillEmpty(long numelems)
{
    while (numelems>0)
    {
        add_element(NULL,il_count);
        numelems--;
    }
}
ErrorStack MasstreeMetadataSerializer::save(tinyxml2::XMLElement* element) const {
  CHECK_ERROR(save_base(element));
  CHECK_ERROR(add_element(
    element, "border_early_split_threshold_", "", data_casted_->border_early_split_threshold_));
  CHECK_ERROR(add_element(
    element,
    "snapshot_drop_volatile_pages_layer_threshold_",
    "",
    data_casted_->snapshot_drop_volatile_pages_layer_threshold_));
  CHECK_ERROR(add_element(
    element,
    "snapshot_drop_volatile_pages_btree_levels_",
    "",
    data_casted_->snapshot_drop_volatile_pages_btree_levels_));
  CHECK_ERROR(add_element(element, "min_layer_hint_", "", data_casted_->min_layer_hint_));
  return kRetOk;
}
예제 #23
0
void fancy_set::add_elements(INT *elts, INT nb)
{
	INT i;
	
	for (i = 0; i < nb; i++) {
		add_element(elts[i]);
		}
}
예제 #24
0
파일: hashtest2.c 프로젝트: mtulio/mtulio
static void *hashtest(void *data)
{
	int my_els_removed = 0;
	int my_els_added = 0;
	int my_els_lookedup = 0;
	int my_els_found = 0;
	int my_els_traversals = 0;
	int my_testno = testno++;
	int its;
	
	/* data will be a random number == use as a seed for random numbers */
	unsigned long seed = (unsigned long)data;
	printf("hashtest thread created... test beginning\n");
	
	/* main test routine-- a global hashtab exists, pound it like crazy  */
	for(its=0;its<100000;its++)
	{
		void *seed2 = &seed;
		int op = my_rand(0,100, seed2);
		if (op<60) {
			my_els_lookedup++;
#ifdef DEBUG
			printf("%d[%d]: LOOKUP\n", my_testno, its);
#endif			
			if ((my_els_lookedup%1000)==0) {
				printf(".");
				fflush(stdout);
			}
			if (lookup_element(seed2))
				my_els_found++;
		} else if (op < 61) { /* make this 61 and it'll take 16 minutes to run */
#ifdef DEBUG
			printf("%d[%d]: TRAVERSE\n", my_testno, its);
#endif
			traverse_elements();
			my_els_traversals++;
			
		} else if (op < 80) {
#ifdef DEBUG
			printf("%d[%d]: REMOVE\n", my_testno, its);
#endif
			if (del_element(seed2))
				my_els_removed++;
		} else {
			my_els_added++;
#ifdef DEBUG
			printf("%d[%d]: ADD\n", my_testno, its);
#endif
			add_element();
		}
	}
	printf("\nhashtest thread %d exiting.... lookups=%d/%d, added=%d, removed=%d, traversals=%d;\n",
		   my_testno, my_els_found, my_els_lookedup, my_els_added, my_els_removed, my_els_traversals);
	printf("\ntotals..................... lookups=%d/%d, added=%d, removed=%d; traversals=%d\n",
		   els_found, els_lookedup, els_added, els_removed, els_traversals);
	pthread_exit(0);
	return NULL;
}
void reset(lptr svd)                //make visited to 0
{
 qptr q;
 FILE *dic;
 lptr l1,l2,l3;//
 q=(qptr)malloc(sizeof(struct queue));
 initialize(q);
 add_element(q,svd);
 
 
 while(!empty(q))
 {
  l1=remove_element(q);
  l1->visited=0;
  if(l1->lchild!=NULL)
  {
   if(l1->lchild->visited!=0)
   {
    add_element(q,l1->lchild);
    //printf("%s \n",l1->lchild->key);
    //fwrite(l1->lchild,sizeof(struct node),1,dic); 
   }
   else
   {
    //printf("%s \n",l1->lchild->key);
    //fwrite(l1->lchild,sizeof(struct node),1,dic); 
   } 
  }
  if(l1->rchild!=NULL)
  {
   if(l1->rchild->visited!=0)
   {
    add_element(q,l1->rchild);
    //printf("%s \n",l1->rchild->key);
    //fwrite(l1->rchild,sizeof(struct node),1,dic); 
   }
   else
   {
    //printf("%s \n",l1->rchild->key); 
    //fwrite(l1->rchild,sizeof(struct node),1,dic);     
   }
  } 
 }
 
}  
예제 #26
0
void Metalink4Writer::write_file(const MetalinkFile& file)
{
    start(wxT("file"));
    add_attr(wxT("name"), file.get_filename());
    close_start();
    add_element(wxT("identity"), file.get_identity());
    add_element(wxT("description"), file.get_description());
    add_element(wxT("version"), file.get_version());
    add_element(wxT("size"), file.get_size());
    write_hashes(file);
    write_piece_hash(file);
    const std::vector<MetalinkSource>& sources = file.get_sources();
    for(std::vector<MetalinkSource>::const_iterator i = sources.begin(),
            eoi = sources.end(); i != eoi; ++i) {
        write_source(*i);
    }
    end(wxT("file"));
}
예제 #27
0
static char * test_is_ignored_file_ko()
{
    struct search_t *search;
    search = create_search();
    add_element(&search->ignore, "rules");
    mu_assert("test_is_ignored_file_ko failed", is_ignored_file(search, "Rules") == 0);
    free_search(search);
    return 0;
}
static int handle_end(void *ctx, int array)
{
  state_t *st = (state_t *)ctx;
  container_t *c = st->c;
  /* unlink container struct from state */
  st->c = c->next;
  /* create and add container term */
  if (array) {
    add_element(st, enif_make_tuple_from_array(st->env, c->array,
                                               c->count));
  } else {
    add_element(st, enif_make_list_from_array(st->env, c->array,
                                              c->count));
  }
  /* decallocate used container struct */
  enif_free(st->env, c);
  return 1;
}
예제 #29
0
static char * test_is_extension_good_ko()
{
    struct search_t *search;
    search = create_search();
    add_element(&search->extension, ".cpp");
    mu_assert("test_is_extension_good_ko failed", is_ignored_file(search, "file.c") == 0);
    free_search(search);
    return 0;
}
예제 #30
0
static char * test_is_specific_file_ko()
{
    struct search_t *search;
    search = create_search();
    add_element(&search->specific_file, "Makefile");
    mu_assert("test_is_specific_file_ko failed", is_specific_file(search, "makefile") == 0);
    free_search(search);
    return 0;
}