コード例 #1
0
ファイル: strstr_test.c プロジェクト: nsf/lib99
END_TEST

START_TEST(test_str_ltrim)
{
	str_t *str = str_from_cstr(" 	\n\r123");
	str_ltrim(str);
	CHECK_STR(str, >= 3, == 3, "123");
	str_free(str);

	str = str_new(0);
	str_ltrim(str);
	CHECK_STR(str, == STR_DEFAULT_CAPACITY, == 0, "");
	str_free(str);
}
コード例 #2
0
ファイル: stem.c プロジェクト: abhayprakash/zettair-0.9.3
int main(int argc, char **argv) {
    struct stem_cache *stem = stem_cache_new(stem_porters, NULL, 200);
    char buf[BUFSIZ + 1];
    unsigned int i;

    buf[BUFSIZ] = '\0';

    if (!stem) {
        return EXIT_FAILURE;
    }

    if (argc == 1) {
        while (fgets(buf, BUFSIZ, stdin)) {
            char *start;

            str_rtrim(buf);
            start = (char *) str_ltrim(buf);
            stem_cache_stem(stem, start);
            printf("%s\n", start);
        }
    } else {
        for (i = 1; i < argc; i++) {
            FILE *input = fopen(argv[i], "rb+");

            if (!input) {
                fprintf(stderr, "failed to open file %s: %s\n", argv[i], 
                  strerror(errno));
                stem_cache_delete(stem);
                return EXIT_FAILURE;
            }

            while (fgets(buf, BUFSIZ, input)) {
                char *start;

                str_rtrim(buf);
                start = (char *) str_ltrim(buf);
                stem_cache_stem(stem, start);
                printf("%s\n", start);
            }
    
            fclose(input);
        }
    }

    stem_cache_delete(stem);

    return EXIT_SUCCESS;
}
コード例 #3
0
ファイル: es_server.c プロジェクト: inherited/gravctf
static int server_try_setclientname(int client_id, const char *name)
{
	int i;
	char trimmed_name[64];

	/* trim the name */
	str_copy(trimmed_name, str_ltrim(name), sizeof(trimmed_name));
	str_rtrim(trimmed_name);
	dbg_msg("", "'%s' -> '%s'", name, trimmed_name);
	name = trimmed_name;
	
	
	/* check for empty names */
	if(!name[0])
		return -1;
	
	/* make sure that two clients doesn't have the same name */
	for(i = 0; i < MAX_CLIENTS; i++)
		if(i != client_id && clients[i].state >= SRVCLIENT_STATE_READY)
		{
			if(strcmp(name, clients[i].name) == 0)
				return -1;
		}

	/* set the client name */
	str_copy(clients[client_id].name, name, MAX_NAME_LENGTH);
	return 0;
}
コード例 #4
0
ファイル: oldnetBandwidthMon.c プロジェクト: selecli/squid
void getSquidConf()
{
    FILE* confFile;
    FILE* squidFile;
    char line[BUFSIZ];

    if ((confFile = fopen("../etc/monitor.conf", "r")) == NULL)
    {
        perror("monitor.conf");
        exit(1);
    }

    while (fgets(line, BUFSIZ, confFile) != NULL)
    {
        str_ltrim(line, "\t ");
        str_rtrim(line, "\t\r\n ");
        if (!strncmp(conf_deviceName, line, strlen(conf_deviceName)))
        {
            int i = 0;
            while (conf_device[i] = line[i + 1 + strlen(conf_deviceName)])
            {
                i++;
            }
            //printf("%s\n", conf_device);
        }
    }
}
コード例 #5
0
ファイル: macro.c プロジェクト: dleonard0/state
void
macro_ltrim(macro **mp)
{
        macro *m;

	while ((m = *mp)) {
            if (m->type != MACRO_STR)
	        break;
	    str_ltrim(&m->str);
	    if (m->str)
		break;
	    *mp = m->next;
            m->next = 0;
	    macro_free(m);
        }
}
コード例 #6
0
void
ConfigFile::_open(void)
{
	std::ifstream	ifs(_filename);

	_sections.clear();
	if (not ifs.is_open())
		return ;

	std::string		section;
	std::string		line;
	std::size_t		idx;

	while (std::getline(ifs, line))
	{
		str_trim(line);
		if (line.empty())
			continue ;
		if(line.front() == '[' and line.back() == ']')
		{
			section = line.substr(1, line.size() - 2);
			str_trim(section);
		}
		else if ((idx = line.find("=")) != std::string::npos)
		{
			std::string	key(line.substr(0, idx - 1));
			std::string	value(line.substr(idx + 1));
			_sections[section][str_rtrim(key)] = str_ltrim(value);
		}
		else
		{
			warn(std::string("In `") + _filename + "`: badly formated: `" + line + "`");
		}
	}
	ifs.close();
}
コード例 #7
0
char * str_trim(char *str) {
  char *ptr;
  ptr = str_rtrim(str);
  str = str_ltrim(ptr);
  return str;
}
コード例 #8
0
ファイル: easystring.c プロジェクト: vbextreme/EasyFramework
CHAR* str_trim(register CHAR* s)
{
	s = str_ltrim(s);
	return str_rtrim(s);
}
コード例 #9
0
ファイル: string.c プロジェクト: Codnect/uniq
/*
 * strim, karakter dizisinin sagindaki ve solundaki 
 * bosluklari kaldirir.
 *
 * @param s : karakter dizisi
 */
char *strim(char *s){

	return str_ltrim(str_rtrim(s));
	
}
コード例 #10
0
ファイル: bucket_1.c プロジェクト: abhayprakash/zettair-0.9.3
int test_file(FILE *fp, int argc, char **argv) {
    char buf[65535 + 1];
    char *pos;
    unsigned int strategy = 0;  /* what bucketing strategy we're 
                                          using */
    void *ptr = NULL;
    unsigned int bucketsize = 0;
    struct params params = {0};
    struct chash *hash = NULL;
    char name[256];

    if (!parse_params(argc, argv, &params)) {
        fprintf(stderr, "failed to parse params\n");
        return 0;
    }

    while (fgets((char *) buf, 65535, fp)) {
        str_rtrim(buf);
        pos = (char *) str_ltrim(buf);

        if (!str_casecmp(pos, "new")) {

            /* creating a new bucket */
            unsigned int size = -1;

            if (ptr) {
                chash_delete(hash);
                free(ptr);
            }

            /* read parameters */
            if ((fscanf(fp, "%255s %u %u", name, &strategy, &size) == 3)
              && (size <= 65535) 
              && (bucketsize = size)
              && (ptr = malloc(size))
              && (hash = chash_ptr_new(1, 2.0, 
                /* some fn pointer casting dodginess */
                (unsigned int (*)(const void *)) str_len, 
                (int (*)(const void *, const void *)) str_cmp))
              && (bucket_new(ptr, bucketsize, strategy))) {
                /* succeeded, do nothing */
                if (params.verbose) {
                    printf("%s: new bucket with size %u strategy %u\n", name, 
                      size, strategy);
                }
            } else {
                fprintf(stderr, "%s: failed to create bucket\n", name);
                return 0;
            }
        } else if (!str_casecmp(pos, "add")) {
            /* adding a term to the bucket */
            void *ret;
            unsigned int veclen,
                         succeed,
                         len;
            int toobig;

            if (!ptr) { return 0; }

            /* read parameters */
            if ((fscanf(fp, "%65535s %u %u", buf, &veclen, &succeed) == 3) 
              && (veclen <= 65535)) {

                len = str_len(buf);
                if ((((ret = bucket_alloc(ptr, bucketsize, strategy, buf, len, 
                        veclen, &toobig, NULL))
                      && succeed)
                    || (!ret && !succeed))) {
                    /* do nothing */
                    if (params.verbose) {
                        printf("%s: added term '%s'\n", name, buf);
                    }
                } else if (succeed) {
                    fprintf(stderr, "%s: failed to add '%s' to bucket\n", 
                      name, buf);
                    return 0;
                } else if (!succeed) {
                    fprintf(stderr, "%s: add '%s' succeeded but shouldn't "
                      "have\n", name, buf);
                    return 0;
                }
            } else {
                fprintf(stderr, "%s: failed to add\n", name);
                return 0;
            }
        } else if (!str_casecmp(pos, "ls")) {
            /* matching stuff in the bucket */
            unsigned int numterms,
                         i,
                         len,
                         veclen,
                         veclen2,
                         state;
            void *addr;
            struct chash *tmphash;
            const char *term;
            void **tmpptr,
                  *tmp;

            if (!ptr) { return 0; }

            if (!(tmphash = chash_ptr_new(1, 2.0, 
              /* some fn pointer casting dodginess */
              (unsigned int (*)(const void *)) str_len, 
              (int (*)(const void *, const void *)) str_cmp))) {
                fprintf(stderr, "%s: failed to init hashtable\n", name);
                return 0;
            }

            /* first, fill hashtable with all terms from bucket */
            state = 0;
            while ((term 
              = bucket_next_term(ptr, bucketsize, strategy,
                  &state, &len, &addr, &veclen))) {

                if (!((term = str_ndup(term, len)) 
                  && (chash_ptr_ptr_insert(tmphash, term, (void*) term) 
                      == CHASH_OK))) {

                    fprintf(stderr, "%s: failed to init hashtable\n", name);
                    return 0;
                }
            }

            /* now, take terms from file, comparing them with hashtable 
             * entries */
            if (fscanf(fp, "%u", &numterms)) {
                for (i = 0; i < numterms; i++) {
                    if (fscanf(fp, "%65535s %u ", buf, &veclen)) {
                        if (params.verbose) {
                            printf("%s: ls checking %s\n", name, buf);
                        }
                        
                        if ((addr = bucket_find(ptr, bucketsize, strategy,
                            buf, str_len(buf), &veclen2, NULL))
                          /* remove it from hashtable */
                          && chash_ptr_ptr_find(tmphash, buf, &tmpptr) 
                            == CHASH_OK
                          && chash_ptr_ptr_remove(tmphash, *tmpptr, &tmp) 
                            == CHASH_OK
                          && (free(tmp), 1)
                          && (veclen <= 65535)
                          && (veclen2 == veclen)
                          && fread(buf, veclen, 1, fp)
                          && ((buf[veclen] = '\0'), 1)
                          && (!params.verbose 
                            || printf("%s: ls check read '%s'\n", name, buf))
                          && !memcmp(buf, addr, veclen)) {
                            /* do nothing */
                        } else {
                            unsigned int j;

                            fprintf(stderr, "%s: ls failed cmp '%s' with '", 
                              name, buf);
                            for (j = 0; j < veclen; j++) {
                                putc(((char *) addr)[j], stderr);
                            }
                            fprintf(stderr, "'\n");
                            return 0;
                        }
                    } else {
                        fprintf(stderr, "%s: ls failed\n", name);
                        return 0;
                    }
                }

                if (chash_size(tmphash)) {
                    fprintf(stderr, "%s: ls failed\n", name);
                    return 0;
                }
            } else {
                fprintf(stderr, "%s: ls failed\n", name);
                return 0;
            }

            chash_delete(tmphash);

            if (params.verbose) {
                printf("%s: matched all (%u) entries\n", name, numterms);
            }
        } else if (!str_casecmp(pos, "set")) {
            /* setting the vector for a term in the bucket */
            unsigned int veclen,
                        reallen;
            void *addr;

            if (!ptr) { return 0; }

            /* read parameters */
            if ((fscanf(fp, "%65535s %u ", buf, &veclen) == 2) 
              && (veclen <= 65535)) {

                addr = bucket_find(ptr, bucketsize, strategy, buf, 
                  str_len(buf), &reallen, NULL);

                if (addr && (reallen == veclen) 
                  && fread(addr, 1, veclen, fp)) {
                    /* do nothing */
                    if (params.verbose) {
                        unsigned int j;

                        printf("%s: set term '%s' to '", name, buf);
                        for (j = 0; j < reallen; j++) {
                            putc(((char *) addr)[j], stdout);
                        }
                        printf("'\n");
                    }
                } else {
                    fprintf(stderr, "%s: failed to set!\n", name);
                    return 0;
                }
            } else {
                fprintf(stderr, "%s: failed to set\n", name);
                return 0;
            }
        } else if (!str_casecmp(pos, "realloc")) {
            /* reallocating a term in the bucket */
            unsigned int veclen,
                         succeed;
            int toobig;

            if (!ptr) { return 0; }

            /* read parameters */
            if ((fscanf(fp, "%65535s %u %u", buf, &veclen, &succeed) == 3) 
              && (veclen <= 65535)) {

                if (!bucket_realloc(ptr, bucketsize, strategy, buf, 
                  str_len(buf), veclen, &toobig)) {
                    fprintf(stderr, "%s: failed to realloc!\n", name);
                    return 0;
                }
            } else {
                fprintf(stderr, "%s: failed to realloc\n", name);
                return 0;
            }

            if (params.verbose) {
                printf("%s: realloc'd term '%s'\n", name, buf);
            }
        } else if (!str_casecmp(pos, "rm")) {
            /* removing something from the bucket */
            unsigned int succeed;

            if (!ptr) { return 0; }

            if (fscanf(fp, "%65535s %u", buf, &succeed) == 2) {
                if (succeed) {

                    if (!(bucket_remove(ptr, bucketsize, strategy, buf, 
                      str_len(buf)))) {
                        fprintf(stderr, "%s: failed to rm '%s'\n", name, 
                          buf);
                        return 0;
                    } else if (params.verbose) {
                        printf("%s: rm term '%s'\n", name, buf);
                    }
                } else if (succeed) {
                    fprintf(stderr, "%s: failed to rm\n", name);
                    return 0;
                }
            } else {
                fprintf(stderr, "%s: failed to rm\n", name);
                return 0;
            }
        } else if (!str_casecmp(pos, "print")) {
            /* printing out the bucket contents */
            unsigned int state = 0,
                         len,
                         veclen;
            const char *term;
            char format[100];
            void *addr;

            if (!ptr) { 
                printf("can't print, no bucket\n");
            } else {
                do {
                    term 
                      = bucket_next_term(ptr, bucketsize, strategy, &state, 
                        &len, &addr, &veclen);
                } while (term 
                  && memcpy(buf, term, len)
                  && ((buf[len] = '\0') || 1)
                  && snprintf(format, 100, "%%.%us (%%u): '%%.%us' (%%u) "
                    "(off %%u)\n", len, veclen) 
                  && printf(format, term, len, (char*) addr, veclen, 
                    ((char *) addr) - (char *) ptr));

                if (!state) {
                    printf("(empty)\n");
                }

                printf("%u entries, %u data, %u string, %u overhead, %u free\n", 
                  bucket_entries(ptr, bucketsize, strategy), 
                  bucket_utilised(ptr, bucketsize, strategy), 
                  bucket_string(ptr, bucketsize, strategy), 
                  bucket_overhead(ptr, bucketsize, strategy),
                  bucket_unused(ptr, bucketsize, strategy));
            }
        } else if (!str_casecmp(pos, "match")) {
            unsigned int veclen,
                         veclen2;
            void *addr;

            if (fscanf(fp, "%65535s %u ", buf, &veclen)) {
                if ((addr = bucket_find(ptr, bucketsize, strategy,
                    buf, str_len(buf), &veclen2, NULL))
                  && (veclen <= 65535)
                  && (veclen2 >= veclen)
                  && (!params.verbose 
                    || printf("%s: match on '%s' ", name, buf))
                  && fread(buf, veclen, 1, fp)
                  && !memcmp(buf, addr, veclen)) {
                    if (params.verbose) {
                        printf("content succeeded\n");
                    }
                } else {
                    fprintf(stderr, "%s: match failed (%s vs %s)\n", name, buf,
                      (char *) addr);
                    return 0;
                }
            } else {
                fprintf(stderr, "%s: match failed\n", name);
                return 0;
            }
        } else if ((*pos != '#') && str_len(pos)) {
            fprintf(stderr, "%s: unknown command '%s'\n", name, pos);
            return 0;
        }
    }

    if (ptr) {
        chash_delete(hash);
        free(ptr);
    }

    return 1;
}
コード例 #11
0
ファイル: str.c プロジェクト: jerryxgh/c-conf
/**
 * Removes leading and trailing characters from the specified character string

 *
 * @param str
 *   [IN/OUT] string for processing
 * @param charlist
 *   [IN] null terminated list of characters
 */
void
str_lrtrim(char *str, const char *charlist)
{
    str_rtrim(str, charlist);
    str_ltrim(str, charlist);
}
コード例 #12
0
ファイル: str_util.c プロジェクト: impegoraro/tagtool
void str_trim(char *str)
{
	str_rtrim(str);
	str_ltrim(str);
}
コード例 #13
0
ファイル: css_util.c プロジェクト: zhifeichen/libcapture
int str_trim(char* str)
{
	str_ltrim(str);
	str_rtrim(str);
	return 0;
}
コード例 #14
0
ファイル: oldnetBandwidthMon.c プロジェクト: selecli/squid
main(int argc, char** argv)
{
	int filedes1[2], filedes2[2];
	int pid;
	FILE* ifTestFile;
	char line[BUFSIZ];
	int ethNum = 0;
	int RxNum = 0;
	time_t updateTime;
	FILE* poolFile;
	FILE* RxTxFile;
	char strLine[BUFSIZ];
    unsigned long dataCount = 0;
    float timeCount = 0.0;
    float inBandSpeed = 0.0;
    float outBandSpeed = 0.0;

	const char* ethName = "eth";
	const char* RxBytesName = "RX bytes:";

	char RxBytes[BUFSIZ];
	char TxBytes[BUFSIZ];
	
	char newUpdateTime[BUFSIZ];
	char oldRxBytes[BUFSIZ];
	char oldTxBytes[BUFSIZ];
	char oldUpdateTime[BUFSIZ];

	getSquidConf();

	if (pipe(filedes1) == -1)
	{
		perror ("pipe");
		exit(1);
	}

	if (pipe(filedes2) == -1)
	{
		perror ("pipe");
		exit(1);
	}

	if ((pid = fork()) == 0)
	{
		dup2(filedes1[0], fileno(stdin)); /* Copy the reading end of the pipe. */
		dup2(filedes2[1], fileno(stdout)); /* Copy the writing end of the pipe */

		/* Uncomment this if you want stderr sent too.
  
		dup2(filedes2[1], fileno(stderr));
  
		*/

		/* If execl() returns at all, there was an error. */

		if (execl("/sbin/ifconfig", "ifconfig","-a", (char*)0))
		{
			perror("execl");
			exit(128);
		}
	} else if (pid == -1)
	{
		perror("fork");
		exit(128);
	} else
	{
		FILE *program_input, *program_output, *output_file;
		int c;

		if ((program_input = fdopen(filedes1[1], "w")) == NULL)
		{
			perror("fdopen");
			exit(1);
		}

		if ((program_output = fdopen(filedes2[0], "r")) == NULL)
		{
			perror("fdopen");
			exit(1);
		}


		if ((output_file = fopen("/tmp/ifconfig.test", "w+")) == NULL)
		{
			perror ("ifconfig.test");
			exit(1);
		}

		//fputs(argv[2], program_input); /* Write the string */

		while ( (c = getc(program_output)) != EOF)
		{
			fputc(c, output_file);
			//printf("%c",c);
			close(filedes2[0]);
		}

		fclose(output_file);

		//Process ifconfig.test file
		if ((ifTestFile = fopen("/tmp/ifconfig.test", "r")) == NULL)
		{
			perror("ifTestFile");
			exit(1);
		}

		while (fgets(line, BUFSIZ, ifTestFile) != NULL)
		{
			str_ltrim(line, "\t\r\n ");		//include"  "(space) to trim left space
			str_rtrim(line, "\t\r\n");
			//if (!strncmp(ethName, line, strlen(ethName)))
			if (!strncmp(conf_device, line, strlen(conf_device)))
			{
				ethNum += 1;
			}

			if (!strncmp(RxBytesName, line, strlen(RxBytesName)))
			{
				RxNum += 1;
				if (ethNum == RxNum && RxNum == 1)
				{
					int i = 0;
					char* p;
					while ((RxBytes[i] = line[i +  strlen(RxBytesName)]) != ' ')
					{
						i++;
					}
					str_ltrim(RxBytes, " ");
					str_rtrim(RxBytes, " ");
					//printf("%s\n", RxBytes);

					p = strrchr(line, ':');
					i = 0;
					while ((TxBytes[i] = p[i + 1]) != ' ')
					{
						i++;
					}
					str_ltrim(TxBytes, " ");
					str_rtrim(TxBytes, " ");
					//printf("%s\n", TxBytes);

					//****************************************************
					//Get UpdateTime
					updateTime = time(NULL);

					//*******************************************************
					// Read old Rx, Tx data

					if ((RxTxFile = fopen("/tmp/netBandwidth.dat", "r")) == NULL)
					{
						//perror("RxTx.dat");
						//exit(1);
					}
                    else
					{
					while (fgets(line, BUFSIZ, RxTxFile) != NULL)
					{
						str_ltrim(line, "\t ");
						str_rtrim(line, "\t\r\n ");
						if (!strncmp("RX", line, strlen("RX")))
						{
							int i = 0;
							while (oldRxBytes[i] = line[i + strlen("RX")])
							{
								i++;
							}
							//printf("%s\n", oldRxBytes);
						}
						if (!strncmp("TX", line, strlen("TX")))
						{
							int i = 0;
							while (oldTxBytes[i] = line[i + strlen("TX")])
							{
								i++;
							}
							//printf("%s\n", oldTxBytes);
						}
						if (!strncmp("UT", line, strlen("UT")))
						{
							int i = 0;
							while (oldUpdateTime[i] = line[i + strlen("UT")])
							{
								i++;
							}
							//printf("%s\n", oldUpdateTime);
						}
					}
					fclose(RxTxFile);
					}

					//*******************************************************
					//Write To the RxTx.dat
					if ((RxTxFile = fopen("/tmp/netBandwidth.dat", "w+")) == NULL)
					{
						perror("RxTx.dat");
						exit(1);
					}
					sprintf(strLine,"RX");
					fputs(strLine, RxTxFile);
					sprintf(strLine, "%s\n",  RxBytes);
					fputs(strLine, RxTxFile);

					sprintf(strLine, "TX");
					fputs(strLine, RxTxFile);
					sprintf(strLine, "%s\n", TxBytes);
					fputs(strLine, RxTxFile);

					sprintf(strLine,"UT");
					fputs(strLine, RxTxFile);
					sprintf(strLine, "%ld\n", updateTime);
					fputs(strLine, RxTxFile);

					fclose(RxTxFile);

					//*******************************************************
					//Write To the netBandwidthMon.pool
					if ((poolFile = fopen("../pool/netBandwidthMon.pool", "w+")) == NULL)
					{
						perror("netBandwidthMon.pool");
						exit(1);
					}

					//printf("%s",RxBytes);
					//printf("%s\n",oldRxBytes);
					//unsigned long  temp =atoll(RxBytes);
					//printf("%u\n",temp);
					dataCount = atoll(RxBytes)-atoll(oldRxBytes);
					//printf("%u\n",dataCount);
                    sprintf(strLine,"%ld\n",updateTime);
                    //printf("%ld\n",updateTime);
					//printf("%d\n",atoi(strLine)-atoi(oldUpdateTime));
                    timeCount = atoi(strLine)-atoi(oldUpdateTime);
                    if(timeCount > 0)
                    {
                        inBandSpeed = dataCount / timeCount / 1024;
                    }
                    else
                    {
                        inBandSpeed = 0;
                    }
                    //printf("%f\n", inBandSpeed);

                    dataCount = atoll(TxBytes)-atoll(oldTxBytes);
					if(timeCount > 0)
					{
					    outBandSpeed = dataCount / timeCount / 1024;
					}
					else
					{
					    outBandSpeed = 0;
					}

                    sprintf(strLine, "%.2f\n", inBandSpeed);
					fputs(strLine, poolFile);

					sprintf(strLine, "%.2f\n", outBandSpeed);
					fputs(strLine, poolFile);

					sprintf(strLine, "%ld\n", updateTime);
					fputs(strLine, poolFile);

					fclose(poolFile);

				}//if (ethNum == RxNum)
			}
		}

//        exit(0);
	}

}
コード例 #15
0
ファイル: str.c プロジェクト: Distrotech/nut
char	*str_trim(char *string, const char character)
{
	return str_rtrim(str_ltrim(string, character), character);
}
コード例 #16
0
ファイル: strfuncs.c プロジェクト: bechtoldt/dovecot-core
const char *p_str_ltrim(pool_t pool, const char *str, const char *chars)
{
	return p_strdup(pool, str_ltrim(str, chars));
}
コード例 #17
0
ファイル: strfuncs.c プロジェクト: bechtoldt/dovecot-core
const char *t_str_ltrim(const char *str, const char *chars)
{
	return t_strdup(str_ltrim(str, chars));
}
コード例 #18
0
ファイル: css_util.c プロジェクト: zhifeichen/libcapture
void test_css_util_other()
{
	char str[24];
	char test[10];
	char* s = NULL;
	char* t = NULL;
	assert(strcmp("922337203685477587",lltoa(922337203685477587,str,10)) == 0);

	strcpy(test," abc");
	str_trim(test);
	assert( 0 == strcmp(test,"abc"));

	strcpy(test," abc ");
	str_trim(test);
	assert( 0 == strcmp(test,"abc"));

	strcpy(test,"abc ");
	str_trim(test);
	assert( 0 == strcmp(test,"abc"));

	strcpy(test,"  a b c ");
	str_trim(test);
	assert( 0 == strcmp(test,"a b c"));

	strcpy(test,"   ");
	str_trim(test);
	assert( 0 == strcmp(test,""));

	strcpy(test," abc");
	str_ltrim(test);
	assert( 0 == strcmp(test,"abc"));

	strcpy(test," abc ");
	str_rtrim(test);
	assert( 0 == strcmp(test," abc"));

	strcpy(test," abc ");
	str_ltrim(test);
	assert( 0 == strcmp(test,"abc "));

	strcpy(test,"  a b c ");
	str_ltrim(test);
	assert( 0 == strcmp(test,"a b c "));

	strcpy(test,"   ");
	str_ltrim(test);
	assert( 0 == strcmp(test,""));

	strcpy(test,"   ");
	str_rtrim(test);
	assert( 0 == strcmp(test,""));

	memset(test,' ',10);
	strcpy(test,"a=b");
	get_split_str(test,"=",1,&s);
	assert( 0 == strcmp(s,"b"));
	FREE(s);
	get_split_str(test,"=",0,&s);
	assert( 0 == strcmp(s,"a"));
	FREE(s);
	get_split_strs(test,"=",&s,&t);
	assert( 0 == strcmp(s,"a"));
	assert( 0 == strcmp(t,"b"));
	FREE(s);
	FREE(t);

	memset(test,' ',10);
	strcpy(test," a = b ");
	get_split_str(test,"=",1,&s);
	str_trim(s);
	assert( 0 == strcmp(s,"b"));
	FREE(s);

	get_split_str(test,"=",0,&s);
	str_trim(s);
	assert( 0 == strcmp(s,"a"));
	FREE(s);

	get_split_strs(test,"=",&s,&t);
	str_trim(s);
	str_trim(t);
	assert( 0 == strcmp(s,"a"));
	assert( 0 == strcmp(t,"b"));
	FREE(s);
	FREE(t);

	assert(0 == ensure_dir("./test/dir"));
	assert(0 == ensure_dir("./test/dir/"));
}