void test_getToken_will_identify_equal_and_equal_to()
{
String * testTokenizer = stringCreate("5=2+3");
Token *testToken ;
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(10,opeToken->precedence);
free(opeToken);
free(testTokenizer);
testTokenizer = stringCreate("6==5");
free(getToken(testTokenizer));
testToken = getToken(testTokenizer); //==
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(EQUAL_TO,opeToken->id);
TEST_ASSERT_EQUAL(40,opeToken->precedence);
free(opeToken);
free(testTokenizer);
}
void test_getToken_will_differentiate_greater__greater_or_equal__right_shift_and_right_shift_set_equal()
{
String * testTokenizer = stringCreate("456>123");
Token * testToken;
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(GREATER_THAN,opeToken->id);
TEST_ASSERT_EQUAL(40,opeToken->precedence);
free(opeToken);
free(testTokenizer);
testTokenizer = stringCreate("3>=3>>=456>>1");
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(GREATER_EQUAL_THAN,opeToken->id);
TEST_ASSERT_EQUAL(40,opeToken->precedence);
free(opeToken);
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(RIGHT_SHIFT_SET_EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(10,opeToken->precedence);
free(opeToken);
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(RIGHT_SHIFT,opeToken->id);
TEST_ASSERT_EQUAL(50,opeToken->precedence);
free(opeToken);
free(testTokenizer);
}
void test_getToken_should_detect_not_sign()
{
String *testTokenizer = stringCreate("2+3+!3");
//Since the program already can detect 2,+ and 3.
Token *testToken;
free(getToken(testTokenizer));
free(getToken(testTokenizer));
free(getToken(testTokenizer));
free(getToken(testTokenizer));
testToken = getToken(testTokenizer); //+
//This testToken should be not NULL
TEST_ASSERT_NOT_NULL(testToken);
//With operator type.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(LOGIC_NOT,opeToken->id);
TEST_ASSERT_EQUAL(80,opeToken->precedence);
free(testTokenizer);
free(opeToken);
//getToken should diffrentiate NOT and not equal
testTokenizer = stringCreate("2+3!=5");
//Since the program already can detect 2,+ and 3.
free(getToken(testTokenizer));
free(getToken(testTokenizer));
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
//This testToken should be not NULL
TEST_ASSERT_NOT_NULL(testToken);
//With operator type.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(NOT_EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(40,opeToken->precedence);
//The tokenizer should updated to...
TEST_ASSERT_EQUAL(5,testTokenizer->startIndex);
TEST_ASSERT_EQUAL(1,testTokenizer->length);
testToken = getToken(testTokenizer);
//Try to get the last token and check the status of tokenizer.
TEST_ASSERT_EQUAL(6,testTokenizer->startIndex);
TEST_ASSERT_EQUAL(0,testTokenizer->length);
free(testTokenizer);
free(opeToken);
}
void rdbu_initLoginInfo (char *filename) {
/**
Looks in the following places for user/password\@database
info needed for logging into database in this order
1. a file named .login_db in the user's home directory
2. a file named .login_db in the current directory
3. a file named 'filename' (optional input parameter)
4. arguments 'dbuser', 'dbpassword', 'dbname' present the command line
Syntax of the files:
- only the first line is read
- this line must have the form user/password\@dbname
- each of these fields can be '-'; in this case the value
of this field is not changed. E.g. if $HOME/.login_db contains
-/-\@testdb
and 'filename' contains
scott/-@-
and on the command line there is an argument
-dbpassword tiger
then username will be scott, password will be tiger and
database will be testdb
optional: if arg_init() was called before then the command line will be
considered; else the command line is ignored
Postcondition: rdbu_user() etc can be called
*/
Stringa fn;
char *home = getenv ("HOME");
if (user != NULL)
die ("rdbu_getLoginInfo() twice");
user = stringCreate(10);
password = stringCreate(10);
database = stringCreate(10);
if (home != NULL) {
fn = stringCreate (100);
stringPrintf (fn,"%s/.login_db",home);
readUserInfoFile (string (fn));
stringDestroy (fn);
}
readUserInfoFile (".login_db");
if (filename != NULL && *filename != '\0')
readUserInfoFile (filename);
if (arg_isInit ()) {
if (arg_present ("dbuser"))
stringCpy (user,arg_get ("dbuser"));
if (arg_present ("dbpassword"))
stringCpy (password,arg_get ("dbpassword"));
if (arg_present ("dbname"))
stringCpy (database,arg_get ("dbname"));
}
}
char* getEntryNumber( int number, int pairType, int readNum ) {
int flag=0;
Stringa str=stringCreate(10);
switch ( pairType ) {
case GFR_PAIR_TYPE_EXONIC_EXONIC:
case GFR_PAIR_TYPE_EXONIC_INTRONIC:
case GFR_PAIR_TYPE_INTRONIC_EXONIC:
case GFR_PAIR_TYPE_INTRONIC_INTRONIC:
break;
case GFR_PAIR_TYPE_INTRONIC_JUNCTION:
case GFR_PAIR_TYPE_EXONIC_JUNCTION:
if( readNum==2 ) flag=1;
break;
case GFR_PAIR_TYPE_JUNCTION_EXONIC:
case GFR_PAIR_TYPE_JUNCTION_INTRONIC:
if( readNum==1 ) flag=1;
break;
case GFR_PAIR_TYPE_JUNCTION_JUNCTION:
flag=1;
}
if( flag==1 ) {
int rem = number % 2;
if( rem == 0 )
stringPrintf(str, "%d right", number/2);
else
stringPrintf(str, "left %d", number/2+1);
} else {
stringPrintf(str, "%d", number);
}
return string(str);
}
SEXP r_cgiParameters() {
int i;
char *name;
Stringa value=stringCreate(16);
Texta keys=textCreate(8);
Texta values=textCreate(8);
SEXP r_keys, r_values;
cgiGetInit();
while(name = cgiGetNext(value)) {
textAdd(keys, name);
textAdd(values, string(value));
}
int n=arrayMax(keys);
PROTECT(r_keys=allocVector(STRSXP, n));
PROTECT(r_values=allocVector(STRSXP, n));
for(i=0; i<n; ++i) {
SET_STRING_ELT(r_keys, i, mkChar(textItem(keys,i)));
SET_STRING_ELT(r_values, i, mkChar(textItem(values,i)));
}
setNames(r_values, r_keys);
stringDestroy(value);
textDestroy(keys);
textDestroy(values);
UNPROTECT(2);
return(r_values);
}
SEXP r_cgiParam(SEXP r_param, SEXP ignore_case, SEXP r_default) {
if(r_param == R_NilValue) return(R_NilValue);
char* name;
Stringa value=stringCreate(16);
char *param=cStr(r_param);
char *str=NULL;
SEXP res;
int (*fPtr)(char*, char*);
fPtr=cBool(ignore_case) ? &myStrCaseEqual : &myStrEqual;
cgiGetInit();
while(name = cgiGetNext(value)) {
if((*fPtr)(name, param)) {
str=hlr_strdup(string(value));
break;
}
}
stringDestroy(value);
if(str) {
return mkString(str);
} else {
return r_default;
}
}
void test_getToken_should_detect_parenthesis_sign()
{
String *testTokenizer = stringCreate("(2+3)");
Token *testToken = getToken(testTokenizer);
//This testToken should be not NULL
TEST_ASSERT_NOT_NULL(testToken);
//With operator type.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(LEFT_PARENTHESIS,opeToken->id);
TEST_ASSERT_EQUAL(1,opeToken->precedence);
//Read out the 2 , + and 3
free(getToken(testTokenizer));
free(getToken(testTokenizer));
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
//This testToken should be not NULL
TEST_ASSERT_NOT_NULL(testToken);
//With operator type.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(RIGHT_PARENTHESIS,opeToken->id);
TEST_ASSERT_EQUAL(2,opeToken->precedence);
free(testTokenizer);
free(opeToken);
}
int main (int argc, char *argv[])
{
LineStream ls;
char *line;
char *pos;
Stringa buffer;
if (argc != 2) {
usage ("%s <file.intraOffsets>");
}
TH1 *his = new TH1D ("","Intra-read distribution",1000,0,1000);
TCanvas *canv = new TCanvas("","canvas",1200,400);
ls = ls_createFromFile (argv[1]);
while (line = ls_nextLine (ls)) {
his->Fill (atoi (line));
}
ls_destroy (ls);
his->Draw();
his->GetXaxis()->SetLabelSize (0.04);
his->GetYaxis()->SetLabelSize (0.04);
buffer = stringCreate (100);
pos = strchr (argv[1],'.');
if (pos == NULL) {
die ("Expected <file.intraOffsets>: %s",argv[1]);
}
*pos = '\0';
stringPrintf (buffer,"%s_intraDistribution.jpg",argv[1]);
canv->Print (string (buffer),"jpg");
stringDestroy (buffer);
return 0;
}
void test_getToken_will_identify_BITWISE_XOR_and_XOR_SET_EQUAL()
{
String * testTokenizer = stringCreate("2+1^0^=1" );
Token *testToken;
free(getToken(testTokenizer));
free(getToken(testTokenizer));
free(getToken(testTokenizer));
testToken = getToken(testTokenizer); //^
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(BITWISE_XOR,opeToken->id);
TEST_ASSERT_EQUAL(30,opeToken->precedence);
free(opeToken);
free(getToken(testTokenizer));
testToken = getToken(testTokenizer); //^=
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(XOR_SET_EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(10,opeToken->precedence);
free(opeToken);
free(testTokenizer);
}
void test_stringCreate_will_update_based_number_to_base_10_number()
{
String * testTokenizer = stringCreate("0x1234");
TEST_ASSERT_NOT_NULL(testTokenizer);
TEST_ASSERT_EQUAL_STRING("4660",testTokenizer->rawString);
TEST_ASSERT_EQUAL(4,testTokenizer->length);
TEST_ASSERT_EQUAL(0,testTokenizer->startIndex);
free(testTokenizer);
}
int main (int argc, char *argv[])
{
GfrEntry *currGE;
int count;
int countRemoved;
int i;
if (argc != 3) {
usage ("%s <offsetCutoff> <minNumUniqueReads>",argv[0]);
}
count = 0;
countRemoved = 0;
int offsetCutOff = atoi (argv[1]);
int minNumUniqueReads = atoi (argv[2]);
gfr_init ("-");
puts (gfr_writeHeader ());
while (currGE = gfr_nextEntry ()) {
Array starts = arrayCreate( 100, int);
for (i = 0; i < arrayMax( currGE->interReads ); i++) {
int currStart = arrp(currGE->interReads, i, GfrInterRead)->readStart1 + arrp(currGE->interReads, i, GfrInterRead)->readStart2;
array(starts, arrayMax(starts), int) = currStart;
}
arraySort( starts, (ARRAYORDERF) arrayIntcmp );
arrayUniq( starts, NULL, (ARRAYORDERF) arrayIntcmp ) ;
int numUniqeOffsets = arrayMax( starts );
arrayDestroy( starts );
if (arrayMax( currGE->readsTranscript1 ) != arrayMax( currGE->readsTranscript2 ) )
die( "The two ends have a different number of reads");
Texta reads = textCreate(arrayMax(currGE->readsTranscript1));
for (i = 0; i < arrayMax(currGE->readsTranscript1); i++) {
Stringa strA = stringCreate( strlen(textItem( currGE->readsTranscript1, i) ) * 2 + 1);
stringAppendf( strA, textItem( currGE->readsTranscript1,i));
stringAppendf( strA, textItem( currGE->readsTranscript2,i));
textAdd( reads, string(strA));
stringDestroy( strA );
}
textUniqKeepOrder( reads );
int numRemaining = arrayMax( reads );
textDestroy ( reads );
if (numRemaining <= minNumUniqueReads || numUniqeOffsets <= offsetCutOff) {
countRemoved++;
continue;
}
puts (gfr_writeGfrEntry (currGE));
count++;
}
gfr_deInit ();
warn("%s_PCRFilter: offset=%d minNumUniqueReads=%d",
argv[0],offsetCutOff, minNumUniqueReads);
warn("%s_numRemoved: %d",argv[0],countRemoved);
warn("%s_numGfrEntries: %d",argv[0],count);
return 0;
}
void test_stringCreate_should_initiate_and_return_a_tokenizer_properly()
{
//Initiate a new tokenizer which will contain the data of 2+3
String *testTokenizer = stringCreate("2+3");
TEST_ASSERT_NOT_NULL(testTokenizer);
TEST_ASSERT_EQUAL_STRING("2+3", testTokenizer->rawString);
TEST_ASSERT_EQUAL(0,testTokenizer->startIndex);
TEST_ASSERT_EQUAL(3,testTokenizer->length);
free(testTokenizer);
//Try a longer expression
testTokenizer = stringCreate("2+3*8+8");
TEST_ASSERT_NOT_NULL(testTokenizer);
TEST_ASSERT_EQUAL_STRING("2+3*8+8", testTokenizer->rawString);
TEST_ASSERT_EQUAL(0,testTokenizer->startIndex);
TEST_ASSERT_EQUAL(7,testTokenizer->length);
free(testTokenizer);
}
static char* getBreakPointSequence (char *tileCoordinate1, char *tileCoordinate2)
{
Stringa buffer;
Stringa targetsFile;
FILE *fp;
Array targetSeqs;
int i;
Seq *currSeq;
static Stringa sequence = NULL;
buffer = stringCreate (100);
targetsFile = stringCreate (100);
stringPrintf (targetsFile,"targets_%d.txt",getpid ());
if (!(fp = fopen (string (targetsFile),"w")) ){
die ("Unable to open target file: %s",string (targetsFile));
}
fprintf (fp,"%s\n%s",tileCoordinate1,tileCoordinate2);
fclose (fp);
stringPrintf (buffer,"%s %s/%s stdout -noMask -seqList=%s",
confp_get(Conf, "BLAT_TWO_BIT_TO_FA"),
confp_get(Conf, "BLAT_DATA_DIR"),
confp_get(Conf, "BLAT_TWO_BIT_DATA_FILENAME"),
string (targetsFile));
fasta_initFromPipe (string (buffer));
targetSeqs = fasta_readAllSequences (0);
fasta_deInit ();
if (arrayMax (targetSeqs) != 2) {
die ("Expected only two target sequences");
}
stringCreateClear (sequence,100);
for (i = 0; i < arrayMax (targetSeqs); i++) {
currSeq = arrp (targetSeqs,i,Seq);
stringAppendf (sequence,"%s",currSeq->sequence);
hlr_free (currSeq->name);
hlr_free (currSeq->sequence);
}
arrayDestroy (targetSeqs);
stringPrintf (buffer,"rm -rf %s",string (targetsFile));
hlr_system (string (buffer),0);
stringDestroy (targetsFile);
stringDestroy (buffer);
return string (sequence);
}
void test_getToken_will_identify_MULTIPLY_DIVIDE_and_MODULUS_SET_EQUAL()
{
String * testTokenizer = stringCreate("234*=0" );
Token *testToken;
free(getToken(testTokenizer));
testToken = getToken(testTokenizer); //*=
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(MULTIPLY_SET_EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(10,opeToken->precedence);
free(opeToken);
free(testTokenizer);
testTokenizer = stringCreate("234235%=0" );
free(getToken(testTokenizer));
testToken = getToken(testTokenizer); //%=
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(MODULUS_SET_EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(10,opeToken->precedence);
free(opeToken);
free(testTokenizer);
testTokenizer = stringCreate("2342344235/=0" );
free(getToken(testTokenizer));
testToken = getToken(testTokenizer); ///=
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(DIVIDE_SET_EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(10,opeToken->precedence);
free(opeToken);
free(testTokenizer);
}
void test_stringCreate_will_update_based_number_to_base_10_number_if_there_is_some_expression_before_it()
{
char *name = "o";
String * testTokenizer = stringCreate("3+o'1234'");
TEST_ASSERT_NOT_NULL(testTokenizer);
TEST_ASSERT_EQUAL_STRING("3+668",testTokenizer->rawString);
TEST_ASSERT_EQUAL(5,testTokenizer->length);
TEST_ASSERT_EQUAL(0,testTokenizer->startIndex);
free(testTokenizer);
}
void test_stringCreate_will_update_based_number_to_base_10_number_if_the_based_number_is_being_in_middle()
{
char *name = "o";
String * testTokenizer = stringCreate("3+h'abcd'/100");
TEST_ASSERT_NOT_NULL(testTokenizer);
TEST_ASSERT_EQUAL_STRING("3+43981/100",testTokenizer->rawString);
TEST_ASSERT_EQUAL(11,testTokenizer->length);
TEST_ASSERT_EQUAL(0,testTokenizer->startIndex);
free(testTokenizer);
}
void test_getToken_should_return_the_token_by_sequence()
{
Number *testNum;
Operator *testOpe;
Token *testToken=NULL;
String *testTokenizer = stringCreate("2+3");
//Get the first token which is 2 and test the length and startIndex of tokenizer.
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(2,testTokenizer->length);
TEST_ASSERT_EQUAL(1,testTokenizer->startIndex);
//Cast the returned token type address to the respective type and test the data contained.
TEST_ASSERT_EQUAL(NUMBER,*testToken);
testNum = (Number *) testToken;
TEST_ASSERT_EQUAL(NUMBER,testNum->type);
TEST_ASSERT_EQUAL(2,testNum->value);
free(testNum);
//Get the second token which is + and test the length and startIndex.
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(1,testTokenizer->length);
TEST_ASSERT_EQUAL(2,testTokenizer->startIndex);
//Test the token type that accepted and cast it back to it respective type and test.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
testOpe = (Operator *) testToken;
TEST_ASSERT_EQUAL(OPERATOR,testOpe->type);
TEST_ASSERT_EQUAL(ADD,testOpe->id);
free(testOpe);
//Get the last token which is 3 an1d test the length and startIndex.
testToken=getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(0,testTokenizer->length);
TEST_ASSERT_EQUAL(3,testTokenizer->startIndex);
//Test the returned token type.
TEST_ASSERT_EQUAL(NUMBER, *testToken);
testNum = (Number*)testToken;
TEST_ASSERT_EQUAL(NUMBER,testNum->type);
TEST_ASSERT_EQUAL(3,testNum->value);
free(testNum);
//Continue getToken even the token all been retrieved
testToken=getToken(testTokenizer);
TEST_ASSERT_NULL(testToken);
TEST_ASSERT_EQUAL(0,testTokenizer->length);
TEST_ASSERT_EQUAL(3,testTokenizer->startIndex);
free(testTokenizer);
}
/**
* writes circos configuration file
*/
int write_circosConf (char* prefix,
Locus locus,
Array regions,
Chrdata_t *chromosomes,
SVCfg_t *settings)
{
float rpos = 0.99;
FILE *fp;
Stringa buffer = stringCreate(50);
int scale = getScale (regions);
stringPrintf (buffer, "%s/test/circos_%s_%s_%d_%d.conf",
confp_get(Conf, "WEB_CIRCOS_DIR"),
prefix,
locus.chromosome,
locus.start,
locus.end);
if (!(fp = fopen (string (buffer), "w"))) {
die ("Unable to open target file");
return -1;
};
printf ("<h2>%i</h2>", scale);
// write conf file
conf_printHeader (fp,
confp_get(Conf, "WEB_CIRCOS_DIR"),
confp_get(Conf, "WEB_DATA_DIR"),
confp_get(Conf, "WEB_SDATA_DIR"),
chromosomes,
prefix,
locus,
scale);
conf_printUnits (fp, regions, chromosomes, scale);
if (scale <= 10000) {
conf_printDataTracks (fp,
prefix,
locus,
confp_get(Conf, "WEB_SDATA_DIR"),
confp_get(Conf, "WEB_DATA_DIR"),
&rpos,
regions,
chromosomes,
settings);
}
conf_printLinks (fp, confp_get(Conf, "WEB_DATA_DIR"), &rpos, prefix, locus, settings->readlim);
conf_printFooter (fp);
fclose (fp);
stringDestroy (buffer);
return 0;
}
void test_getToken_will_detect_BITWISE_LOGICAL_AND_AND_and_AND_SET_EQUAL()
{
String * testTokenizer = stringCreate("4&5&&1");
Token *testToken;
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator * opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(BITWISE_AND,opeToken->id);
TEST_ASSERT_EQUAL(30,opeToken->precedence);
free(opeToken);
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(LOGICAL_AND,opeToken->id);
TEST_ASSERT_EQUAL(20,opeToken->precedence);
free(opeToken);
free(testTokenizer);
testTokenizer = stringCreate("345&=23423");
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(AND_SET_EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(10,opeToken->precedence);
free(opeToken);
free(testTokenizer);
}
void test_getToken_should_detect_current_program_counter_sign()
{
String *testTokenizer = stringCreate("2+$");
//Since the program already can detect 2 and +.
Token *testToken;
free(getToken(testTokenizer));
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
//This testToken should be not NULL
TEST_ASSERT_NOT_NULL(testToken);
//With operator type.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(CURRENT_PROGRAM_COUNTER,opeToken->id);
TEST_ASSERT_EQUAL(90,opeToken->precedence);
free(testTokenizer);
free(opeToken);
//Try reverse the other of the equation
testTokenizer = stringCreate("$+2");
testToken = getToken(testTokenizer);
//This testToken should be not NULL
TEST_ASSERT_NOT_NULL(testToken);
//With operator type.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(CURRENT_PROGRAM_COUNTER,opeToken->id);
TEST_ASSERT_EQUAL(90,opeToken->precedence);
free(testTokenizer);
free(opeToken);
}
void test_stringCreate_will_update_identifier_to_the_defined_term_if_the_term_is_behind()
{
char *name = "num1";
DefineElement element;
element.ID = "num1";
element.actualID = "*200";
getElement_ExpectAndReturn(DefineList, name,&element);
String * testTokenizer = stringCreate("6num1");
//Make sure the identifier been updated.
TEST_ASSERT_NOT_NULL(testTokenizer);
TEST_ASSERT_EQUAL_STRING("6*200",testTokenizer->rawString);
free(testTokenizer);
}
void test_getToken_should_detect_complement_in_an_expression()
{
String *testTokenizer = stringCreate("~2+9");
Token *testToken = getToken(testTokenizer);
//This testToken should be not NULL
TEST_ASSERT_NOT_NULL(testToken);
//With operator type.
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(COMPLEMENT,opeToken->id);
TEST_ASSERT_EQUAL(80,opeToken->precedence);
free (opeToken);
//Lets try to input some equation that the complement is being in middle.
testTokenizer = stringCreate("2+~9");
free(getToken(testTokenizer));
free(getToken(testTokenizer));
testToken = getToken(testTokenizer); //~
//This testToken should be not NULL
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(COMPLEMENT,opeToken->id);
TEST_ASSERT_EQUAL(80,opeToken->precedence);
free(opeToken);
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NULL(testToken);
free(testTokenizer);
}
int main (int argc, char *argv[])
{
int i,j,groupNumber;
MrfEntry *currEntry;
GffEntry *currGffEntry,*nextGffEntry;
Array gffEntries;
FILE *fp;
Stringa buffer;
short int paired;
if (argc != 2) {
usage ("%s <prefix>",argv[0]);
}
buffer = stringCreate (1000);
groupNumber = 0;
mrf_init ("-");
gffEntries = arrayCreate (100000,GffEntry);
while (currEntry = mrf_nextEntry ()) {
processRead (gffEntries, currEntry, &groupNumber);
}
mrf_deInit ();
arraySort (gffEntries,(ARRAYORDERF)sortGffEntriesByTargetNameAndGroupNumber);
i = 0;
while (i < arrayMax (gffEntries)) {
currGffEntry = arrp (gffEntries,i,GffEntry);
stringPrintf (buffer,"%s_%s.gff",argv[1],currGffEntry->targetName);
fp = fopen (string (buffer),"w");
if (fp == NULL) {
die ("Unable to open file: %s",string (buffer));
}
fprintf (fp,"browser hide all\n");
fprintf (fp,"track name=\"%s_%s\" visibility=2\n",argv[1],currGffEntry->targetName);
fprintf (fp,"%s\n",currGffEntry->line);
j = i + 1;
while (j < arrayMax (gffEntries)) {
nextGffEntry = arrp (gffEntries,j,GffEntry);
if (!strEqual (currGffEntry->targetName,nextGffEntry->targetName)) {
break;
}
fprintf (fp,"%s\n",nextGffEntry->line);
j++;
}
i = j;
fclose (fp);
}
stringDestroy (buffer);
return 0;
}
void test_stringCreate_will_throw_error_if_the_based_number_is_not_valid_for_number_that__larger_than_the_base()
{
Error exception;
Try
{
String * testTokenizer = stringCreate("6*o'1234p'");
}
Catch(exception)
{
TEST_ASSERT_EQUAL(INVALID_EXPRESSION,exception);
TEST_ASSERT_EQUAL_STRING("6*o'1234p'",errorMessage.rawString);
TEST_ASSERT_EQUAL(2,errorMessage.position);
TEST_ASSERT_EQUAL_STRING("Invalid expression ! ",errorMessage.message);
}
}
symtable *stCreate()
{
symtable *st = (symtable *) malloc(sizeof(symtable));
st->blockList = listCreate();
//Add block0
block *b = (block *) malloc(sizeof(block));
b->name = stringCreate();
stringAppendCharArray(b->name, "block0", 6*sizeof(char));
b->symbols = bstCreate(bstCompareSymbol);
b->nextLoc = 0;
listAddBack(st->blockList, b);
//Initialize block0 with PJ's builtin procedures and input/output files
for (unsigned int i = 0; i < builtin_num; i++)
{
const char *builtinName = pjbuiltinString(i);
string *name = stringCreate();
stringAppendCharArray(name, builtinName, strlen(builtinName));
symbol *sym = symbolCreate(name);
stringDestroy(name);
symbolSetBuiltin(sym, i);
stAddSymbol(st, sym);
}
return st;
}
void test_getToken_will_detect_ADD_SET_EQUAL()
{
String * testTokenizer = stringCreate("3+=1");
Token *testToken;
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(ADD_SET_EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(10,opeToken->precedence);
free(opeToken);
free(testTokenizer);
}
void test_stringCreate_will_update_identifier_to_the_defined_term()
{
//first,consider that the user will define an identifier name num1 as following.
//#define num1 200+
char *name = "num1";
DefineElement element;
element.ID = "num1";
element.actualID = "200+";
getElement_ExpectAndReturn(DefineList, name,&element);
String * testTokenizer = stringCreate("num1 6");
//Make sure the identifier been updated.
TEST_ASSERT_NOT_NULL(testTokenizer);
TEST_ASSERT_EQUAL_STRING("200+ 6",testTokenizer->rawString);
free(testTokenizer);
}
void test_getToken_will_identify_SUBTRACT_SET_EQUAL()
{
String * testTokenizer = stringCreate("3-=4");
Token *testToken;
free(getToken(testTokenizer));
testToken = getToken(testTokenizer);
TEST_ASSERT_NOT_NULL(testToken);
TEST_ASSERT_EQUAL(OPERATOR,*testToken);
Operator *opeToken = (Operator*)testToken;
TEST_ASSERT_EQUAL(OPERATOR,opeToken->type);
TEST_ASSERT_EQUAL(SUBTRACT_SET_EQUAL,opeToken->id);
TEST_ASSERT_EQUAL(10,opeToken->precedence);
free(opeToken);
free(testTokenizer);
}
void test_stringCreate_will_throw_error_if_the_identifier_is_not_defined_in_the_linked_list_for_a_loger_expression()
{
char *name = "num1";
Error exception;
getElement_ExpectAndReturn(DefineList, name,NULL);
Try
{
String * testTokenizer = stringCreate("6+1208345%69-num1");
}
Catch(exception)
{
TEST_ASSERT_EQUAL(UNDEFINED_IDENTIFIER,exception);
TEST_ASSERT_EQUAL_STRING("6+1208345%69-num1",errorMessage.rawString);
TEST_ASSERT_EQUAL(13,errorMessage.position);
TEST_ASSERT_EQUAL_STRING("Undefined Identifier! ",errorMessage.message);
}
}
