void GTest_DNASequenceAlphabetType::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
QString v = el.attribute(VALUE_ATTR);
if (v.isEmpty()) {
failMissingValue(VALUE_ATTR);
return;
}
if (v == "DNAAlphabet_RAW"){
alphabetType = DNAAlphabet_RAW;
return;
}
if (v == "DNAAlphabet_NUCL"){
alphabetType = DNAAlphabet_NUCL;
return;
}
if (v == "DNAAlphabet_AMINO"){
alphabetType = DNAAlphabet_AMINO;
return;
}
stateInfo.setError(QString("alphabetType not set %1").arg(VALUE_ATTR));
return;
}
void GTest_DNAMulSequencePart::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
subseq = el.attribute(VALUE_ATTR).toLatin1();
if (subseq.isEmpty()) {
failMissingValue(VALUE_ATTR);
return;
}
QString p = el.attribute(START_ATTR);
if (p.isEmpty()) {
failMissingValue(START_ATTR);
return;
}
bool ok = false;
startPos= p.toInt(&ok);
if (!ok) {
failMissingValue(START_ATTR);
}
seqName = el.attribute(SEQNAME_ATTR);
if (seqName.isEmpty()) {
failMissingValue(SEQNAME_ATTR);
return;
}
}
void GTest_DNASequenceQualityValue::init(XMLTestFormat* tf, const QDomElement& el) {
Q_UNUSED(tf);
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
QString buf;
bool ok = false;
buf = el.attribute(POSITION_ATTR).toLatin1();
if (buf.isEmpty()) {
failMissingValue(POSITION_ATTR);
}
pos = buf.toInt(&ok);
if (!ok) {
setError("Failed to parse sequence position");
return;
}
ok = false;
buf = el.attribute(VALUE_ATTR).toLatin1();
if (buf.isEmpty()) {
failMissingValue(VALUE_ATTR);
}
expectedVal = buf.toInt(&ok);
if (!ok) {
setError("Failed to parse expected value");
return;
}
}
void GTest_CheckPhyNodeBranchDistance::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
treeContextName = el.attribute(OBJ_ATTR);
if (treeContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
nodeName = el.attribute(PHYNODE_ATTR);
if (nodeName.isEmpty()) {
failMissingValue(PHYNODE_ATTR);
return;
}
QString v = el.attribute(VALUE_ATTR);
if (v.isEmpty()) {
failMissingValue(VALUE_ATTR);
return;
}
bool ok = false;
distance = v.toDouble(&ok);
if (!ok) {
failMissingValue(VALUE_ATTR);
}
}
void GTest_uHMMERBuild::init(XMLTestFormat* tf, const QDomElement& el) {
Q_UNUSED(tf);
QString inFile = el.attribute(IN_FILE_NAME_ATTR);
if (inFile.isEmpty()) {
failMissingValue(IN_FILE_NAME_ATTR);
return;
}
outFile = el.attribute(OUT_FILE_NAME_ATTR);
if (outFile.isEmpty()) {
failMissingValue(OUT_FILE_NAME_ATTR);
return;
}
QString expOpt = el.attribute(EXP_OPT_ATTR);
if (expOpt.isEmpty()) {
failMissingValue(EXP_OPT_ATTR);
return;
}
QString hmmName = el.attribute(HMM_NAME_ATTR);
QString delTempStr = el.attribute(DEL_TEMP_FILE_ATTR);
if (delTempStr .isEmpty()) {
failMissingValue(DEL_TEMP_FILE_ATTR);
return;
}
if(delTempStr=="yes")
deleteTempFile = true;
else if(delTempStr=="no") deleteTempFile =false;
else {
failMissingValue(DEL_TEMP_FILE_ATTR);
return;
}
UHMMBuildSettings s;
s.name = hmmName;
if(expOpt=="LS") s.strategy = P7_LS_CONFIG;
else if(expOpt=="FS") s.strategy = P7_FS_CONFIG;
else if(expOpt=="BASE") s.strategy = P7_BASE_CONFIG;
else if(expOpt=="SW") s.strategy = P7_SW_CONFIG;
else {
stateInfo.setError( QString("invalid value %1, available values: LS, FS, BASE, SW").arg(EXP_OPT_ATTR) );
return;
}
QFileInfo fi(env->getVar("TEMP_DATA_DIR")+"/"+outFile);
fi.absoluteDir().mkpath(fi.absoluteDir().absolutePath());
QFile createFile(fi.absoluteFilePath());
createFile.open(QIODevice::WriteOnly);
if(!createFile.isOpen()){
stateInfo.setError( QString("File opening error \"%1\", description: ").arg(createFile.fileName())+createFile.errorString() );
return;
}
else createFile.close();
buildTask = new HMMBuildToFileTask(env->getVar("COMMON_DATA_DIR")+"/"+inFile, createFile.fileName(), s);
outFile = createFile.fileName();
addSubTask(buildTask);
}
void GTest_CompareTwoMsa::init(XMLTestFormat *, const QDomElement& element) {
docContextName = element.attribute(DOC1_ATTR);
if (docContextName.isEmpty()) {
failMissingValue(DOC1_ATTR);
return;
}
secondDocContextName = element.attribute(DOC2_ATTR);
if (secondDocContextName.isEmpty()) {
failMissingValue(DOC2_ATTR);
return;
}
}
void GTest_hmmCompare::init(XMLTestFormat* tf, const QDomElement& el) {
Q_UNUSED(tf);
file1Name = el.attribute(IN_FILE1_NAME_ATTR);
if (file1Name.isEmpty()) {
failMissingValue(IN_FILE1_NAME_ATTR);
return;
}
file2Name= el.attribute(IN_FILE2_NAME_ATTR);
if (file2Name.isEmpty()) {
failMissingValue(IN_FILE2_NAME_ATTR);
return;
}
}
//----------------------------------------------------------
void GTest_CompareDNASequenceQualityInTwoObjects::init(XMLTestFormat* tf, const QDomElement& el) {
Q_UNUSED(tf);
doc1CtxName = el.attribute("doc1");
if (doc1CtxName.isEmpty()) {
failMissingValue("doc1");
return;
}
doc2CtxName = el.attribute("doc2");
if (doc2CtxName.isEmpty()) {
failMissingValue("doc2");
return;
}
}
void GTest_CompareTreesInTwoObjects::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
docContextName = el.attribute(DOC_ATTR);
if (docContextName.isEmpty()) {
failMissingValue(DOC_ATTR);
return;
}
secondDocContextName = el.attribute(VALUE_ATTR);
if (secondDocContextName.isEmpty()) {
failMissingValue(VALUE_ATTR);
return;
}
}
//----------------------------------------------------------
void GTest_DNASequenceQualityScores::init(XMLTestFormat* tf, const QDomElement& el) {
Q_UNUSED(tf);
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
qualityScores = el.attribute(QUALITY_ATTR).toLatin1();
if (qualityScores.isEmpty()) {
failMissingValue(QUALITY_ATTR);
}
}
void GTest_DNASequenceAlphabet::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
alphabetId = el.attribute(VALUE_ATTR);
if (alphabetId.isEmpty()) {
failMissingValue(VALUE_ATTR);
return;
}
}
void GTest_PerfectMatch::init(XMLTestFormat*, const QDomElement& el) {
QString fileURLStr = el.attribute(URL);
if (fileURLStr.isEmpty()) {
failMissingValue(URL);
}
QString commonDataDir = env->getVar("COMMON_DATA_DIR");
fileURL = commonDataDir + "/" + fileURLStr;
QString expectedFormatStr = el.attribute(FORMAT);
if (expectedFormatStr.isEmpty()) {
failMissingValue(FORMAT);
}
// WARNING expectedFormat here may be invalid foramat Id
// it's normal test will just fail
expectedFormat = DocumentFormatId(expectedFormatStr);
}
void GTest_PhyML::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
treeObjFromDoc = NULL;
task = NULL;
input = NULL;
maDoc = NULL;
treeDoc = NULL;
inputDocCtxName = el.attribute("in");
if (inputDocCtxName.isEmpty()) {
failMissingValue("in");
return;
}
resultCtxName = el.attribute("sample");
negative = el.attribute("negative");
QString dataType = el.attribute("datatype");
if(!dataType.isEmpty()) {
settings.extToolArguments << "-d";
settings.extToolArguments << dataType;
}
QString bootstrapString = el.attribute("bootstrap");
if(!bootstrapString.isEmpty()){
settings.extToolArguments << "-b";
settings.extToolArguments << bootstrapString;
}
QString subtitutionalModel = el.attribute("model");
if(!subtitutionalModel.isEmpty()) {
settings.extToolArguments << "-m";
settings.extToolArguments << subtitutionalModel;
}
QString ttRatioString = el.attribute("tt_ratio");
if(!ttRatioString.isEmpty()) {
settings.extToolArguments << "-t";
settings.extToolArguments << ttRatioString;
}
QString subRatesString = el.attribute("substitution_rates");
if(!subRatesString.isEmpty()) {
settings.extToolArguments << "-t";
settings.extToolArguments << subRatesString;
}
QString invSitesString = el.attribute("inv_sites");
if(!invSitesString.isEmpty()) {
settings.extToolArguments << "-v";
settings.extToolArguments << invSitesString;
}
QString gammaFactorString = el.attribute("gamma");
if(!gammaFactorString.isEmpty()) {
settings.extToolArguments << "-a";
settings.extToolArguments << gammaFactorString;
}
}
void GTest_AddSharedDbUrl::init(XMLTestFormat *, const QDomElement &el) {
const QString url = el.attribute(URL_ATTR);
CHECK_EXT(!url.isEmpty(), failMissingValue(URL_ATTR), );
const QString portStr = el.attribute(PORT_ATTR);
int port = -1;
if (!portStr.isEmpty()) {
bool conversionOk = false;
port = portStr.toInt(&conversionOk);
CHECK_EXT(conversionOk, stateInfo.setError(QString("Cannot convert %1 to an integer value of port number").arg(portStr)), );
}
void GTest_MrBayes::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
treeObjFromDoc = NULL;
task = NULL;
input = NULL;
inputDocCtxName = el.attribute("in");
if (inputDocCtxName.isEmpty()) {
failMissingValue("in");
return;
}
resultCtxName = el.attribute("sample");
QString seed;
seed = el.attribute("mbSeed");
if(seed == NULL){
failMissingValue("mbSeed");
return;
}else{
mbSeed = seed.toInt();
}
}
void GTest_DNASequencInMulSequence::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
QString v = el.attribute(VALUE_ATTR);
if (v.isEmpty()) {
failMissingValue(VALUE_ATTR);
return;
}
bool ok = false;
seqInMSeq = v.toInt(&ok);
if (!ok) {
failMissingValue(VALUE_ATTR);
}
}
void GTest_SecStructPredictTask::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
seqName = el.attribute(SEQ_NAME_ATTR);
if (seqName.isEmpty()) {
failMissingValue(SEQ_NAME_ATTR);
return;
}
algName = el.attribute(ALG_NAME_ATTR);
if (algName.isEmpty()) {
failMissingValue(ALG_NAME_ATTR);
return;
}
resultsTableContextName = el.attribute(INDEX_ATTR);
if (resultsTableContextName.isEmpty()) {
failMissingValue(INDEX_ATTR);
return;
}
}
void GTest_DiPropertySiteconCheckAttribs::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
key = el.attribute(DI_KEY_ATTR);
if (key.isEmpty()) {
failMissingValue(DI_KEY_ATTR);
return;
}
val = el.attribute(DI_VAL_ATTR);
if (val.isEmpty()) {
failMissingValue(DI_VAL_ATTR);
return;
}
QString expAveStr = el.attribute(EXPECTED_AVE_ATTR);
if (expAveStr.isEmpty()) {
failMissingValue(EXPECTED_AVE_ATTR);
return;
}
bool isOk;
expAve = qRound(expAveStr.toFloat(&isOk) * 10000);
if(!isOk) {
stateInfo.setError( QString("Wrong conversion to the integer for %1").arg(EXPECTED_AVE_ATTR) );
return;
}
QString expSdevStr = el.attribute(EXPECTED_SDEV_ATTR);
if (expAveStr.isEmpty()) {
failMissingValue(EXPECTED_SDEV_ATTR);
return;
}
expSdev = qRound(expSdevStr.toFloat(&isOk) * 10000);
if(!isOk) {
stateInfo.setError( QString("Wrong conversion to the integer for %1").arg(EXPECTED_SDEV_ATTR) );
return;
}
}
void GTest_CheckStringExists::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
stringToCheck = el.attribute(STRING_ATTR);
if (stringToCheck.isNull()) {
failMissingValue(STRING_ATTR);
return;
}
wholeLine = (el.attribute(WITH_LINE_BREAK) == "true");
mustExist = (el.attribute(MUST_EXIST) == "true");
newlines = (el.attribute(NEWLINES) == "true");
while (newlines && stringToCheck.contains("\\n")) {
stringToCheck.replace("\\n", "\n");
}
}
void GTest_DNAMulSequenceQuality::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
seqName = el.attribute(SEQNAME_ATTR);
if (seqName.isEmpty()) {
failMissingValue(SEQNAME_ATTR);
return;
}
expectedQuality = el.attribute(QUALITY_ATTR).toLatin1();
if (expectedQuality.isEmpty()) {
failMissingValue(QUALITY_ATTR);
return;
}
}
void GTest_CalculateTreeFromAligment::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
task = NULL;
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
treeObjContextName = el.attribute(INDEX_ATTR);
if (treeObjContextName.isEmpty()) {
failMissingValue(INDEX_ATTR);
return;
}
algName = el.attribute(ALGORITHM_ATTR);
if (algName.isEmpty()) {
failMissingValue(ALGORITHM_ATTR);
return;
}
}
void GTest_CheckPhyNodeHasSibling::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
treeContextName = el.attribute(OBJ_ATTR);
if (treeContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
nodeName = el.attribute(PHYNODE_ATTR);
if (nodeName.isEmpty()) {
failMissingValue(PHYNODE_ATTR);
return;
}
siblingName = el.attribute(SIBLING_ATTR);
if (siblingName.isEmpty()) {
failMissingValue(SIBLING_ATTR);
return;
}
}
//---------------------------------------------------------------------
void GTest_DNATranslation3to1Test::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
objContextName = el.attribute(OBJ_ATTR);
if (objContextName.isEmpty()) {
failMissingValue(OBJ_ATTR);
return;
}
QString v = el.attribute(START_ATTR);
if (v.isEmpty()) {
failMissingValue(START_ATTR);
return;
}
bool ok = false;
strFrom = v.toInt(&ok);
if (!ok) {
failMissingValue(START_ATTR);
}
QString e = el.attribute(END_ATTR);
if (e.isEmpty()) {
failMissingValue(END_ATTR);
return;
}
ok = false;
strTo = e.toInt(&ok);
if (!ok) {
failMissingValue(END_ATTR);
}
stringValue = el.attribute(VALUE_ATTR);
if (stringValue.isEmpty()) {
failMissingValue(VALUE_ATTR);
return;
}
}
void GTest_uHMMERCalibrate::init(XMLTestFormat* tf, const QDomElement& el) {
Q_UNUSED(tf);
calibrateTask = NULL;
QString hmmFile = el.attribute(HMM_FILE_ATTR);
if (hmmFile.isEmpty()) {
failMissingValue(HMM_FILE_ATTR);
return;
}
QString mu_str = el.attribute(MU_ATTR);
if (mu_str.isEmpty()) {
failMissingValue(MU_ATTR);
return;
}
bool ok=false;
mu = mu_str.toFloat(&ok);
if(!ok) {
failMissingValue(MU_ATTR);
return;
}
QString lambda_str = el.attribute(LAMBDA_ATTR);
if (lambda_str.isEmpty()) {
failMissingValue(LAMBDA_ATTR);
return;
}
ok=false;
lambda = lambda_str.toFloat(&ok);
if(!ok) {
failMissingValue(LAMBDA_ATTR);
return;
}
QString nThreads_str = el.attribute(NUMBER_OF_THREADS_ATTR);
if (nThreads_str.isEmpty()) {
failMissingValue(NUMBER_OF_THREADS_ATTR);
return;
}
ok=false;
int nThreads = nThreads_str.toFloat(&ok);
if(!ok) {
failMissingValue(NUMBER_OF_THREADS_ATTR);
return;
}
nCalibrates = 1;
QString nCalibrates_str = el.attribute(RUN_N_CALIBRATES);
if (!nCalibrates_str.isEmpty()) {
bool ok=false;
nCalibrates = nCalibrates_str.toInt(&ok);
if(!ok) {
failMissingValue(RUN_N_CALIBRATES);
return;
}
}
UHMMCalibrateSettings s;
QString seed_str = el.attribute(SEED_ATTR);
if (!seed_str.isEmpty()) {
bool ok=false;
int seed = seed_str.toInt(&ok);
if(!ok) {
failMissingValue(SEED_ATTR);
return;
}
s.seed = seed;
}
calibrateTask = new HMMCalibrateToFileTask*[nCalibrates];
s.nThreads = nThreads;
//Run nCalibrates HMMCalibrate tasks simultaneously
for(int i=0;i<nCalibrates;i++){
calibrateTask[i] = new HMMCalibrateToFileTask(env->getVar("COMMON_DATA_DIR")+"/"+hmmFile,env->getVar("TEMP_DATA_DIR")+"/temp111",s);
}
addSubTask(new GTest_uHMMERCalibrateSubtask(calibrateTask, nCalibrates));
}
const QString GTest_AddSharedDbUrl::USER_NAME_ATTR = "user";
const QString GTest_AddSharedDbUrl::PASSWORD_ATTR = "password";
const QString GTest_AddSharedDbUrl::CUSTOM_DB_NAME = "custom-db-name";
void GTest_AddSharedDbUrl::init(XMLTestFormat *, const QDomElement &el) {
const QString url = el.attribute(URL_ATTR);
CHECK_EXT(!url.isEmpty(), failMissingValue(URL_ATTR), );
const QString portStr = el.attribute(PORT_ATTR);
int port = -1;
if (!portStr.isEmpty()) {
bool conversionOk = false;
port = portStr.toInt(&conversionOk);
CHECK_EXT(conversionOk, stateInfo.setError(QString("Cannot convert %1 to an integer value of port number").arg(portStr)), );
}
const QString dbName = el.attribute(DB_NAME_ATTR);
CHECK_EXT(!dbName.isEmpty(), failMissingValue(DB_NAME_ATTR), );
dbUrl = U2DbiUtils::createDbiUrl(url, port, dbName);
userName = el.attribute(USER_NAME_ATTR);
passwordIsSet = el.hasAttribute(PASSWORD_ATTR);
password = el.attribute(PASSWORD_ATTR);
customDbName = el.attribute(CUSTOM_DB_NAME);
}
Task::ReportResult GTest_AddSharedDbUrl::report() {
Settings *settings = AppContext::getSettings();
CHECK_EXT(NULL != settings, stateInfo.setError("Invalid application settings"), ReportResult_Finished);
const QString fullDbUrl = U2DbiUtils::createFullDbiUrl(userName, dbUrl);
settings->setValue("/shared_database/recent_connections/" + customDbName, fullDbUrl);
if (passwordIsSet) {
void GTest_SW_CheckRegion::init(XMLTestFormat *tf, const QDomElement& el) {
Q_UNUSED(tf);
QString stepStr = el.attribute(CHUNK_ATTR);
if (stepStr.isEmpty()) {
failMissingValue(CHUNK_ATTR);
return;
}
bool ok=false;
chunkSize = stepStr.toInt(&ok);
if(!ok) {
failMissingValue(CHUNK_ATTR);
return;
}
QString overlapStr= el.attribute(OVERLAP_ATTR);
if (overlapStr.isEmpty()) {
failMissingValue(OVERLAP_ATTR);
return;
}
ok=false;
overlap = overlapStr.toInt(&ok);
if(!ok) {
failMissingValue(OVERLAP_ATTR);
return;
}
QString extraLenStr = el.attribute(EXTRA_LEN_ATTR);
if (extraLenStr.isEmpty()) {
failMissingValue(EXTRA_LEN_ATTR);
return;
}
ok=false;
extraLen = extraLenStr.toInt(&ok);
if(!ok) {
failMissingValue(EXTRA_LEN_ATTR);
return;
}
QString regionStr = el.attribute(REGION_ATTR);
if (regionStr.isEmpty()) {
failMissingValue(REGION_ATTR);
return;
}
QStringList regNums = regionStr.split("..");
if (regNums.size()!=2) {
failMissingValue(REGION_ATTR);
return;
}
ok=false;
region.startPos = regNums[0].toInt(&ok);
if(!ok) {
failMissingValue(REGION_ATTR);
return;
}
region.length= regNums[1].toInt(&ok)-region.startPos;
if(!ok) {
failMissingValue(REGION_ATTR);
return;
}
QString reventNorm_str = el.attribute(REVERSE_ATTR);
if (reventNorm_str == "true") {
reventNorm = true;
} else if(reventNorm_str == "false") {
reventNorm = false;
} else {
failMissingValue(REVERSE_ATTR);
return;
}
QString regions_str = el.attribute(RESULT_ATTR);
if (regions_str.isEmpty()) {
failMissingValue(RESULT_ATTR);
return;
}
QRegExp rx("(\\d+)(..)(\\d+)");
QStringList list;
int pos = 0;
while ((pos = rx.indexIn(regions_str, pos)) != -1) {
int start=rx.cap(1).toInt();
int end=rx.cap(3).toInt();
result.append(U2Region(start,end-start));
pos += rx.matchedLength();
}
}
