ARB
calculator.cxx
Go to the documentation of this file.
1 // ========================================================= //
2 // //
3 // File : calculator.cxx //
4 // Purpose : perform SAI calculation //
5 // //
6 // Coded by Ralf Westram (coder@reallysoft.de) in Dec 19 //
7 // http://www.arb-home.de/ //
8 // //
9 // ========================================================= //
10 
11 #include "calculator.h"
12 #include <arbdbt.h>
13 
14 using namespace std;
15 
16 class SequenceHandler : virtual Noncopyable { // @@@ class SequenceHandler should be used wherever NOT_ALL_SAI_HAVE_DATA
17  GBDATA *gb_item; // item (e.g. SAI, species, ...)
18  char *ali; // alignment name
19 
20  GBDATA *gb_data; // data element containing sequence (e.g. 'ali_xxx/data')
22  bool createPossible;
23 
24  mutable SmartCharPtr buffer; // holds data (if GB_read_as_string has been used)
25 
26  void annotate_error() {
27  sai_assert(error);
28  char *fieldDescription = NULp;
29  if (gb_data) {
30  fieldDescription = GBS_global_string_copy("; field '%s'", GB_read_key_pntr(gb_data));
31  }
32  error = GBS_global_string("%s (at %s '%s'; alignment '%s'%s)",
33  error,
34  GB_read_key_pntr(gb_item),
36  ali,
37  fieldDescription ? fieldDescription : "");
38  free(fieldDescription);
39  }
40 
41 public:
42  SequenceHandler(GBDATA *gb_item_, const char *ali_) :
43  gb_item(gb_item_),
44  ali(strdup(ali_)),
45  gb_data(NULp),
46  error(NULp),
47  createPossible(true)
48  {
49  GBDATA *gb_ali = GB_entry(gb_item, ali);
50  if (!gb_ali) {
51  error = "has no entries";
52  }
53  else {
54  gb_data = GB_entry(gb_ali, "data"); // try standard sequence entry first.
55  if (!gb_data && !GB_have_error()) {
56  if (strcmp(GB_read_key_pntr(gb_item), "extended") == 0) {
57  // these entries are only tried for SAI:
58  gb_data = GB_entry(gb_ali, "bits"); // e.g. occurs in 'markerline'
59  }
60  }
61 
62  if (!gb_data) {
63  error = GB_have_error()
64  ? GB_await_error()
65  : "could not detect sequence data";
66  }
67  }
68 
69  if (!error) {
70  GB_TYPES type = GB_read_type(gb_data);
71  if (type != GB_STRING && type != GB_BITS) {
72  error = "cannot handle type as sequence- or associated-data";
73  createPossible = false;
74  gb_data = NULp; // => !wasFound()
75  }
76  }
77 
78  if (error) {
79  annotate_error();
80  }
81  else {
82  sai_assert(wasFound());
83  createPossible = false;
84  }
85  }
86  ~SequenceHandler() { free(ali); }
87 
88  GB_ERROR getError() const {
89  // used to retrieve error (after call to ctor) => cannot read data
90  // Nevertheless calling create() and then writing data may be a valid option!
91  return error;
92  }
93  bool wasFound() const { return gb_data != NULp; } // Note: "wasFound() && getError()" may occur!
94 
95  const char *read_char_pntr() const {
96  sai_assert(wasFound());
97  GB_TYPES type = GB_read_type(gb_data);
98  if (type == GB_STRING) {
99  return GB_read_char_pntr(gb_data);
100  }
101  buffer.assign(GB_read_as_string(gb_data));
102  return buffer.content();
103  }
104 
105  char *read_string() const {
106  sai_assert(wasFound());
107  return GB_read_as_string(gb_data);
108  }
109 
110  GB_ERROR write_string(const char *data) const {
111  sai_assert(wasFound());
112  return GB_write_autoconv_string(gb_data, data);
113  }
114 
115  GB_ERROR create(GB_TYPES type, const char *fieldName) {
116  bool annotateError = true;
117 
118  if (createPossible) {
119  sai_assert(!wasFound()); // already have sequence
120  error = NULp; // superseeds any errors from ctor
121  gb_data = GBT_create_sequence_data(gb_item, ali, fieldName, type, 0);
122  if (!gb_data) error = GB_await_error();
123  }
124  else {
125  if (getError()) {
126  annotateError = false; // keep existing and already annotated error
127  }
128  else if (wasFound()) {
129  error = "cannot create data over existing";
130  }
131  else {
132  sai_assert(0); // sth is wrong here with program logic
133  error = "cannot create data (logic error)";
134  }
135  }
136 
137  if (error && annotateError) annotate_error();
138  return error;
139  }
140 };
141 
142 inline bool saiHasDataInAli(GBDATA *gb_sai_data, const char *saiName, const char *ali) {
143  GBDATA *gb_sai = GBT_expect_SAI_rel_SAI_data(gb_sai_data, saiName);
144  if (!gb_sai) {
145  GB_clear_error();
146  return false;
147  }
148 
149  SequenceHandler saiseq(gb_sai, ali);
150  return saiseq.wasFound();
151 }
152 
153 bool SaiCalculator::allSaiHaveDataInAlignment(const char *ali) {
154  bool seenMissingData = false;
155  GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main);
156 
157  for (int i = 0; inputSaiNames[i] && !seenMissingData; ++i) {
158  seenMissingData = !saiHasDataInAli(gb_sai_data, inputSaiNames[i], ali);
159  }
160  return !seenMissingData;
161 }
162 
163 void SaiCalculator::run() {
165 
166  GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main);
167  GBDATA *gb_target_sai = GBT_find_SAI_rel_SAI_data(gb_sai_data, outSaiName);
168  if (!gb_target_sai) {
169  if (GB_have_error()) {
170  error = GB_await_error();
171  }
172  else { // create new SAI as target:
173  gb_target_sai = GB_create_container(gb_sai_data, "extended");
174  error = gb_target_sai
175  ? GBT_write_string(gb_target_sai, "name", outSaiName)
176  : GB_await_error();
177  }
178  }
179 
180  if (!error) {
181  sai_assert(gb_target_sai);
182 
183  // @@@ DRY cases:
184  switch (scope) {
185  case SAS_SELECTED: {
186  char *ali = GBT_get_default_alignment(gb_main);
187  if (!ali) {
188  error = GB_await_error();
189  }
190  else {
191  calc4ali(ali, gb_target_sai);
192  free(ali);
193  }
194  break;
195  }
196  case SAS_ALL: {
197  ConstStrArray aliName;
199  if (aliName.empty()) error = "No alignments found";
200 
201  for (int a = 0; aliName[a] && !error; ++a) {
202  calc4ali(aliName[a], gb_target_sai);
203  }
204  break;
205  }
206  case SAS_COMMON: {
207  ConstStrArray aliName;
209  if (aliName.empty()) error = "No alignments found";
210 
211  ConstStrArray commonAliName;
212  for (int a = 0; aliName[a] && !error; ++a) {
213  if (allSaiHaveDataInAlignment(aliName[a])) {
214  commonAliName.put(aliName[a]);
215  }
216  }
217  if (commonAliName.empty() && !error) error = "No alignments found where all SAI have data";
218 
219  for (int a = 0; commonAliName[a] && !error; ++a) {
220  calc4ali(commonAliName[a], gb_target_sai);
221  }
222  break;
223  }
224  case SAS_TARGET: {
225  ConstStrArray aliName;
227  if (aliName.empty()) error = "No alignments found";
228 
229  ConstStrArray existingAliName;
230  for (int a = 0; aliName[a] && !error; ++a) {
231  if (saiHasDataInAli(gb_sai_data, outSaiName, aliName[a])) {
232  existingAliName.put(aliName[a]);
233  }
234  }
235  if (existingAliName.empty() && !error) error = "No alignments found where target SAI has data";
236 
237  for (int a = 0; existingAliName[a] && !error; ++a) {
238  calc4ali(existingAliName[a], gb_target_sai);
239  }
240  break;
241  }
242  }
243  }
244 
245  // @@@ test gb_target_sai for "ali_..." subcontainers. If none exist = > raise error to avoid creation of SAI w/o any data.
246 }
247 
248 
249 void SaiCalculator::calc4ali(const char *ali, GBDATA *gb_target_sai) {
250  sai_assert(ali && ali[0]); // has to be defined and not empty
251  sai_assert(!error);
252 
253  GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main);
254  string sai_comment = "CalcSAI: ";
255 
256  // collect input data:
257  StrArray saiData;
258  for (int i = 0; inputSaiNames[i] && !error; ++i) {
259  GBDATA *gb_sai = GBT_expect_SAI_rel_SAI_data(gb_sai_data, inputSaiNames[i]);
260  if (!gb_sai) {
261  error = GB_await_error();
262  }
263  else {
264  SequenceHandler saiseq(gb_sai, ali);
265  if (saiseq.getError()) {
266  error = saiseq.getError();
267  }
268  else if (saiseq.wasFound()) {
269  saiData.put(saiseq.read_string());
270  }
271  else {
272  UNCOVERED();
273  // @@@ somehow report sai has no data in alignment (caller shall fail if not found any data or if not enough SAI for operator)
274  }
275  }
276 
277  if (i>0) sai_comment += '+';
278  sai_comment += inputSaiNames[i];
279  }
280 
281  if (!error) {
282  SaiCalcEnv calcEnv(saiData, gb_main);
283  ErrorOrString result = op.apply(calcEnv);
284 
285  sai_comment += " | ";
286  sai_comment += op.get_description();
287 
288  if (result.hasError()) {
289  error = result.getError();
290  }
291  else { // write result to target SAI:
292  SequenceHandler targetSeq(gb_target_sai, ali);
293 
294  if (!targetSeq.wasFound()) {
295  error = targetSeq.create(GB_STRING, "data");
296  }
297 
298  if (!error) {
299  string saidata = result.getValue();
300  error = targetSeq.write_string(saidata.c_str());
301 
302  if (!error) {
303  GBDATA *gb_ali = GB_entry(gb_target_sai, ali);
304  gb_assert(gb_ali);
305  if (gb_ali) {
306  // write SAI comment (operator type, source SAIs, ...)
307  error = GBT_write_string(gb_ali, "_TYPE", sai_comment.c_str());
308  }
309  }
310  }
311  }
312  }
313 }
314 
315 // --------------------------------------------------------------------------------
316 
317 #ifdef UNIT_TESTS
318 
319 #include <arb_diff.h>
320 #include <arb_file.h>
321 #include <test_unit.h>
322 
323 void TEST_SequenceHandler() {
324  GB_shell shell;
325  GBDATA *gb_main = GB_open("TEST_prot_tiny.arb", "rw"); // ../../UNIT_TESTER/run/TEST_prot_tiny.arb
326 
327  {
328  GB_transaction ta(gb_main);
329 
330  GBDATA *gb_maxFreq = GBT_expect_SAI(gb_main, "MAX_FREQUENCY");
331  GBDATA *gb_pvp = GBT_expect_SAI(gb_main, "POS_VAR_BY_PARSIMONY");
332  GBDATA *gb_marker = GBT_expect_SAI(gb_main, "markerline");
333  GBDATA *gb_CONS = GBT_expect_SAI(gb_main, "CONSENSUS");
334 
335  SequenceHandler mfdna(gb_maxFreq, "ali_dna");
336  SequenceHandler mfpro(gb_maxFreq, "ali_prot");
337  SequenceHandler pvdna(gb_pvp, "ali_dna");
338  SequenceHandler pvpro(gb_pvp, "ali_prot");
339  SequenceHandler mldna(gb_marker, "ali_dna");
340  SequenceHandler mlpro(gb_marker, "ali_prot");
341 
342  TEST_EXPECT(mfdna.wasFound()); TEST_EXPECT_NO_ERROR(mfdna.getError());
343  TEST_EXPECT(mfpro.wasFound()); TEST_EXPECT_NO_ERROR(mfpro.getError());
344  TEST_EXPECT(pvdna.wasFound()); TEST_EXPECT_NO_ERROR(pvdna.getError());
345  TEST_EXPECT(mldna.wasFound()); TEST_EXPECT_NO_ERROR(mldna.getError());
346  TEST_EXPECT(mlpro.wasFound()); TEST_EXPECT_NO_ERROR(mlpro.getError());
347 
348  TEST_REJECT(pvpro.wasFound()); TEST_EXPECT_ERROR_CONTAINS(pvpro.getError(), "has no entries (at extended 'POS_VAR_BY_PARSIMONY'; alignment 'ali_prot')");
349 
350  TEST_EXPECT_CONTAINS(mfdna.read_char_pntr(), "8570068866840660555755577540000060080000008775740000000008876547667770006555555");
351  TEST_EXPECT_EQUAL (mfpro.read_char_pntr(), "====050846555500000760006557055586550000055000555686654808508057566566754665055005800080550004500005666688====0=");
352  TEST_EXPECT_CONTAINS(pvdna.read_char_pntr(), "..---664--2662440-44-61662664462-----4--4------662440.........442241224552");
353  TEST_EXPECT_CONTAINS(mldna.read_char_pntr(), "00111101111111110111100010001100111111111111111111010111111111111100111111111100000011111111001001111111111111111");
354  TEST_EXPECT_EQUAL (mlpro.read_char_pntr(), "0000101101000011111111111001100011001111100111000111100111011101011011100110100110111111001110011110111111000010");
355 
356  // test to modify handled sequence and then read modified:
357  TEST_EXPECT_NO_ERROR(mfpro.write_string(SmartCharPtr(GBS_string_eval(mfpro.read_char_pntr(), ":0=-")).content()));
358  // "====050846555500000760006557055586550000055000555686654808508057566566754665055005800080550004500005666688====0="
359  TEST_EXPECT_EQUAL (mfpro.read_char_pntr(), "====-5-8465555-----76---6557-5558655-----55---5556866548-85-8-57566566754665-55--58---8-55---45----5666688====-=");
360 
361  TEST_EXPECT_NO_ERROR(mlpro.write_string(SmartCharPtr(GBS_string_eval(mlpro.read_char_pntr(), ":1=-:0=1:-=0")).content())); // invert
362  // "0000101101000011111111111001100011001111100111000111100111011101011011100110100110111111001110011110111111000010"
363  TEST_EXPECT_EQUAL(mlpro.read_char_pntr(), "1111010010111100000000000110011100110000011000111000011000100010100100011001011001000000110001100001000000111101");
364 
365  TEST_EXPECT_NO_ERROR(mlpro.write_string("hello"));
366  TEST_EXPECT_EQUAL(mlpro.read_char_pntr(), "11111");
367 
368  // test to create sequence data:
369  TEST_EXPECT_ERROR_CONTAINS(mfdna.create(GB_STRING, "data"), "cannot create data over existing (at extended 'MAX_FREQUENCY'; alignment 'ali_dna'; field 'data')");
370  TEST_EXPECT_ERROR_CONTAINS(mldna.create(GB_STRING, "data"), "cannot create data over existing (at extended 'markerline'; alignment 'ali_dna'; field 'bits')");
371 
372  TEST_REJECT(pvpro.wasFound()); // has no data yet
373  TEST_EXPECT_NO_ERROR(pvpro.create(GB_STRING, "data")); // create of new data entry (ali container is missing here)
374  TEST_EXPECT(pvpro.wasFound()); // now has data
375  // test write + read data into created GB_STRING entry:
376  TEST_EXPECT_EQUAL(pvpro.read_char_pntr(), "..."); // default when only created, but never written
377  TEST_EXPECT_NO_ERROR(pvpro.write_string( "10210310"));
378  TEST_EXPECT_EQUAL(pvpro.read_char_pntr(), "10210310");
379 
380  {
381  // erase data entries from SAI "CONSENSUS":
382  GBDATA *gb_CONS_ali_dna = GB_entry(gb_CONS, "ali_dna");
383  GBDATA *gb_CONS_ali_pro = GB_entry(gb_CONS, "ali_prot");
384 
385  GBDATA *gb_data_dna = GB_entry(gb_CONS_ali_dna, "data");
386  GBDATA *gb_data_pro = GB_entry(gb_CONS_ali_pro, "data");
387 
388  TEST_EXPECT_NO_ERROR(GB_delete(gb_data_dna));
389  TEST_EXPECT_NO_ERROR(GB_delete(gb_data_pro));
390 
391  // create new data entry with wrong type
392  GBDATA *gb_int_data = GB_create(gb_CONS_ali_pro, "data", GB_INT);
393  TEST_EXPECT_NO_ERROR(GB_write_int(gb_int_data, 4711));
394  }
395 
396  SequenceHandler codna(gb_CONS, "ali_dna");
397  SequenceHandler copro(gb_CONS, "ali_prot");
398 
399  TEST_REJECT(codna.wasFound());
400  TEST_REJECT(copro.wasFound());
401  TEST_EXPECT_ERROR_CONTAINS(codna.getError(), "could not detect sequence data (at extended 'CONSENSUS'; alignment 'ali_dna')");
402  TEST_EXPECT_ERROR_CONTAINS(copro.getError(), "cannot handle type as sequence- or associated-data (at extended 'CONSENSUS'; alignment 'ali_prot')");
403 
404  TEST_REJECT(codna.wasFound()); // has no data yet
405  TEST_EXPECT_NO_ERROR(codna.create(GB_BITS, "bits")); // create of new data entry (ali container is present here)
406  TEST_EXPECT(codna.wasFound()); // now has data
407  // test write + read data into created GB_BITS entry:
408  TEST_EXPECT_NORESULT__NOERROREXPORTED(codna.read_char_pntr()); // default when only created, but never written
409  TEST_EXPECT_NO_ERROR(codna.write_string( "10210310"));
410  TEST_EXPECT_EQUAL(codna.read_char_pntr(), "10110110"); // string above was converted into bitstring
411 
412  // let create fail due to createPossible==false:
413  TEST_EXPECT_ERROR_CONTAINS(copro.create(GB_STRING, "data"), "cannot handle type as sequence- or associated-data (at extended 'CONSENSUS'; alignment 'ali_prot')"); // @@@ somehow indicate this is a followup-error?!
414  }
415 
416  GB_close(gb_main);
417 }
418 
419 #define TEST_EXPECT_MAKEOP(type,cfg) do{ \
420  ErrorOrSaiOperatorPtr made = SaiOperator::make(type,cfg); \
421  if (made.hasError()) { \
422  TEST_EXPECT_NO_ERROR(made.getError().deliver()); \
423  } \
424  op = made.getValue(); \
425  }while(0)
426 
427 static GB_ERROR tmp_all_but(GBDATA *gb_main, const char *keep) {
428  GB_transaction ta(gb_main);
429  GB_ERROR error = NULp;
430  for (GBDATA *gbd = GB_child(gb_main); gbd && !error; gbd = GB_nextChild(gbd)) {
431  if (strcmp(GB_read_key_pntr(gbd), keep) != 0) {
432  error = GB_set_temporary(gbd);
433  }
434  }
435  error = ta.close(error);
436  return error;
437 }
438 
439 static void clone_test_sai(GBDATA *gb_main, const char *name) {
440  GB_transaction ta(gb_main);
441 
442  GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main); TEST_REJECT_NULL(gb_sai_data);
443  GBDATA *gb_sai = GBT_expect_SAI_rel_SAI_data(gb_sai_data, name); TEST_REJECT_NULL(gb_sai);
444  GBDATA *gb_clone_sai = GB_clone(gb_sai_data, gb_sai); TEST_REJECT_NULL(gb_clone_sai);
445 
446  GBDATA *gb_clone_name = gb_clone_sai ? GB_entry(gb_clone_sai, "name") : NULp;
447  TEST_REJECT_NULL(gb_clone_name);
448 
449  TEST_EXPECT_NO_ERROR(GB_write_string(gb_clone_name, GBS_global_string("cloned_%s", GB_read_char_pntr(gb_clone_name))));
450 }
451 
452 static GB_ERROR clone_SAI(GBDATA *gb_main, const char *source_name, const char *dest_name) {
453  GB_ERROR error = NULL;
454 
455  GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main);
456  GBDATA *gb_source = GBT_find_SAI_rel_SAI_data(gb_sai_data, source_name);
457 
458  if (!gb_source) error = "cant find source";
459  else {
460  GBDATA *gb_dest_exists = GBT_find_SAI_rel_SAI_data(gb_sai_data, dest_name);
461  if (gb_dest_exists) error = "dest exists";
462  else {
463  GBDATA *gb_dest = GB_create_container(gb_sai_data, "extended");
464  if (!gb_dest) error = GB_await_error();
465  else {
466  error = GB_copy_dropProtectMarksAndTempstate(gb_dest, gb_source);
467  if (!error) error = GBT_write_string(gb_dest, "name", dest_name);
468  }
469  }
470  }
471 
472  return error;
473 }
474 
475 void TEST_SaiCalculator() {
476  GB_shell shell;
477  GBDATA *gb_main = GB_open("TEST_prot_tiny.arb", "rw"); // ../../UNIT_TESTER/run/TEST_prot_tiny.arb
478  // other database with several SAI: ../../UNIT_TESTER/run/TEST_fields_ascii.arb
479 
480  ConstStrArray inputSais;
481 
482  SaiOperatorPtr op;
483  TEST_EXPECT_MAKEOP(SOP_TRANSLATE, "default='.'"); // creates 'op' from type and config (or fails)
484 
485  {
486  SaiCalculator calculator(gb_main, inputSais, *op, "unwrittenSAI", SAS_SELECTED);
487  TEST_EXPECT(calculator.hasError());
488  TEST_EXPECT_ERROR_CONTAINS(calculator.getError().deliver(), "translator applies to single SAI only (have: 0)"); // @@@ clumsy message; test for multiple SAIs is in saiop.cxx@CLUMSYMSG
489  }
490 
491  inputSais.put("MAX_FREQUENCY"); // (only in "ali_dna")
492  {
493  SaiCalculator calculator(gb_main, inputSais, *op, "mf_translated", SAS_SELECTED);
494  TEST_REJECT(calculator.hasError());
495  }
496 
497  // test markerline translation via ACI:
498  inputSais.clear();
499  inputSais.put("markerline"); // (in "ali_dna" and "ali_prot")
500  TEST_EXPECT_MAKEOP(SOP_ACI, "aci='translate(\"01\",\"-x\")'");
501 
502  {
503  SaiCalculator calculator(gb_main, inputSais, *op, "markerline_aci", SAS_SELECTED);
504  TEST_REJECT(calculator.hasError());
505  }
506 
507  // clone markerline sai -> markerline_clone (using copy function as used in SAI admin):
508  {
509  GB_transaction ta(gb_main);
510  TEST_EXPECT_NO_ERROR(clone_SAI(gb_main, "markerline", "markerline_clone"));
511  }
512 
513  // apply inverse aci than above, saving over binary sai:
514  TEST_EXPECT_MAKEOP(SOP_ACI, "aci='translate(\"01\",\"10\")'");
515  {
516  SaiCalculator calculator(gb_main, inputSais, *op, "markerline_clone", SAS_COMMON);
517  TEST_REJECT(calculator.hasError());
518 
519  // additional tests: test sai has 'data' + test content of 'bits':
520  GB_transaction ta(gb_main);
521 
522  GBDATA *gb_sai = GBT_find_SAI(gb_main, "markerline_clone"); TEST_REJECT_NULL(gb_sai);
523 
524  GBDATA *gb_ali = GB_entry(gb_sai, "ali_prot"); TEST_REJECT_NULL(gb_ali);
525  GBDATA *gb_data = GB_entry(gb_ali, "data"); TEST_EXPECT_NULL(gb_data); // no longer writes into 'data' entry
526  GBDATA *gb_bits = GB_entry(gb_ali, "bits"); TEST_REJECT_NULL(gb_bits);
527 
528  SmartCharPtr bitstr = GB_read_as_string(gb_bits);
529  TEST_EXPECT_EQUAL(&*bitstr, "1111010010111100000000000110011100110000011000111000011000100010100100011001011001000000110001100001000000111101");
530  }
531 
532  inputSais.put("POS_VAR_BY_PARSIMONY"); // (only in "ali_dna")
533  TEST_EXPECT_MAKEOP(SOP_ACI, "aci='remove(\"-=.0\")|len|srt(0=-)'");
534 
535  {
536  SaiCalculator calculator(gb_main, inputSais, *op, "pvp_mix_marker1", SAS_SELECTED);
537  TEST_REJECT(calculator.hasError());
538  }
539  {
540  SaiCalculator calculator(gb_main, inputSais, *op, "pvp_mix_marker2", SAS_ALL);
541  TEST_EXPECT(calculator.hasError());
542  TEST_EXPECT_ERROR_CONTAINS(calculator.getError().deliver(), "has no entries (at extended 'POS_VAR_BY_PARSIMONY'; alignment 'ali_prot')");
543  }
544  {
545  SaiCalculator calculator(gb_main, inputSais, *op, "pvp_mix_marker3", SAS_COMMON);
546  TEST_REJECT(calculator.hasError());
547  }
548 
549  TEST_EXPECT_NO_ERROR(GBT_set_default_alignment(gb_main, "ali_prot"));
550 
551  inputSais.remove(1); // remove POS_VAR_BY_PARSIMONY
552  // (keep "markerline")
553  inputSais.put("CONSENSUS"); // (in "ali_dna" and "ali_prot")
554  TEST_EXPECT_MAKEOP(SOP_ACI, "aci='count(atAT);head(1)|mult|srt(0=-)'"); // only show set marker position for A and T.
555  {
556  SaiCalculator calculator(gb_main, inputSais, *op, "ml_cons1", SAS_SELECTED); // "ml_cons1" now has only data in "ali_prot"
557  TEST_REJECT(calculator.hasError());
558  }
559  {
560  SaiCalculator calculator(gb_main, inputSais, *op, "ml_cons2", SAS_ALL);
561  TEST_EXPECT(calculator.hasError());
562  TEST_EXPECT_ERROR_CONTAINS(calculator.getError().deliver(), "has no entries (at extended 'markerline'; alignment 'ali_dna_incomplete')"); // @@@ change error message: maybe better sth like "has no data"?
563  }
564  {
565  SaiCalculator calculator(gb_main, inputSais, *op, "ml_cons3", SAS_COMMON);
566  TEST_REJECT(calculator.hasError());
567  }
568 
569  // @@@ provoke some "no data" error by combining "ml_cons1" (ali_prot only) + POS_VAR_BY_PARSIMONY (ali_dna only) with scope SAS_COMMON
570 
571  clone_test_sai(gb_main, "ml_cons1"); // data in 'ali_prot' only
572  clone_test_sai(gb_main, "markerline_aci"); // data in 'ali_dna' only
573 
574  // test SAS_TARGET (e.g. overwrite cloned SAIs with different operator):
575  {
576  SaiOperatorPtr oldOp = op;
577 
578  TEST_EXPECT_MAKEOP(SOP_ACI, "aci='count(gcGC);head(1)|mult|srt(0=-)'"); // only show set marker position for G and C.
579  {
580  SaiCalculator calculator(gb_main, inputSais, *op, "cloned_ml_cons1", SAS_TARGET);
581  TEST_REJECT(calculator.hasError());
582  }
583  {
584  SaiCalculator calculator(gb_main, inputSais, *op, "cloned_markerline_aci", SAS_TARGET);
585  TEST_REJECT(calculator.hasError());
586  }
587 
588  op = oldOp;
589  }
590 
591  // delete 'ali_dna_incomplete' (used in no SAI, only in one species)
592  {
593  GB_transaction ta(gb_main);
594  GBDATA *gb_ali_incomplete = GBT_get_alignment(gb_main, "ali_dna_incomplete");
595  TEST_EXPECT_NO_ERROR(GB_delete(gb_ali_incomplete));
596  }
597  {
598  // test again with SAS_ALL -> now it works
599  SaiCalculator calculator(gb_main, inputSais, *op, "ml_cons4", SAS_ALL);
600  TEST_REJECT(calculator.hasError());
601  }
602 
603  // @@@ test errors where no data is found (or not enough data, e.g. 2 SAI expected by operator but only one found)
604 
605  // ---------------------------------------
606  // save DB and test its content:
607  const char *written_ascii = "TEST_calcSAI_written.arb";
608  const char *expectd_ascii = "TEST_calcSAI_expectd.arb"; // ../../UNIT_TESTER/run/TEST_calcSAI_expectd.arb
609 
610  TEST_EXPECT_NO_ERROR(tmp_all_but(gb_main, "extended_data"));
611  TEST_EXPECT_NO_ERROR(GB_save_as(gb_main, written_ascii, "a"));
612 
613 // #define TEST_AUTO_UPDATE // uncomment to update expected result
614 #if defined(TEST_AUTO_UPDATE)
615  TEST_COPY_FILE(written_ascii, expectd_ascii);
616 #endif
617  TEST_EXPECT_TEXTFILE_DIFFLINES(written_ascii, expectd_ascii, 0);
619 
620  GB_close(gb_main);
621 }
622 
623 #endif // UNIT_TESTS
624 
625 // --------------------------------------------------------------------------------
GB_ERROR GB_copy_dropProtectMarksAndTempstate(GBDATA *dest, GBDATA *source)
Definition: arbdb.cxx:2152
string result
GBDATA * GB_open(const char *path, const char *opent)
Definition: ad_load.cxx:1363
GB_TYPES type
void put(const char *elem)
Definition: arb_strarray.h:188
GBDATA * GB_child(GBDATA *father)
Definition: adquery.cxx:322
Definition: arbdb.h:69
GB_ERROR GB_write_string(GBDATA *gbd, const char *s)
Definition: arbdb.cxx:1387
GBDATA * GBT_expect_SAI_rel_SAI_data(GBDATA *gb_sai_data, const char *name)
Definition: aditem.cxx:174
bool wasFound() const
Definition: calculator.cxx:93
GBDATA * GBT_get_alignment(GBDATA *gb_main, const char *aliname)
Definition: adali.cxx:808
GB_ERROR getError() const
Definition: calculator.cxx:88
void GBT_get_alignment_names(ConstStrArray &names, GBDATA *gbd)
Definition: adali.cxx:317
char * GB_read_as_string(GBDATA *gbd)
Definition: arbdb.cxx:1060
bool hasError() const
Definition: ErrorOrType.h:50
TYPE getValue() const
Definition: ErrorOrType.h:58
const char * GBS_global_string(const char *templat,...)
Definition: arb_msg.cxx:203
bool GB_have_error()
Definition: arb_msg.cxx:338
STL namespace.
char * GBS_string_eval(const char *insource, const char *icommand)
Definition: admatch.cxx:699
GB_ERROR create(GB_TYPES type, const char *fieldName)
Definition: calculator.cxx:115
GBDATA * GBT_expect_SAI(GBDATA *gb_main, const char *name)
Definition: aditem.cxx:184
int GB_unlink(const char *path)
Definition: arb_file.cxx:188
char buffer[MESSAGE_BUFFERSIZE]
Definition: seq_search.cxx:34
bool empty() const
Definition: arb_strarray.h:86
GB_ERROR GB_delete(GBDATA *&source)
Definition: arbdb.cxx:1916
GBDATA * GBT_find_SAI(GBDATA *gb_main, const char *name)
Definition: aditem.cxx:177
#define TEST_EXPECT_CONTAINS(str, part)
Definition: test_unit.h:1316
GB_ERROR GB_await_error()
Definition: arb_msg.cxx:342
GBDATA * GB_create_container(GBDATA *father, const char *key)
Definition: arbdb.cxx:1829
#define TEST_EXPECT(cond)
Definition: test_unit.h:1328
GB_TYPES GB_read_type(GBDATA *gbd)
Definition: arbdb.cxx:1643
GB_ERROR write_string(const char *data) const
Definition: calculator.cxx:110
GB_CSTR GB_read_key_pntr(GBDATA *gbd)
Definition: arbdb.cxx:1656
GBDATA * GB_create(GBDATA *father, const char *key, GB_TYPES type)
Definition: arbdb.cxx:1781
#define true
Definition: ureadseq.h:14
void GB_clear_error()
Definition: arb_msg.cxx:354
GB_ERROR GBT_set_default_alignment(GBDATA *gb_main, const char *alignment_name)
Definition: adali.cxx:765
GB_ERROR GB_save_as(GBDATA *gbd, const char *path, const char *savetype)
const char * read_char_pntr() const
Definition: calculator.cxx:95
GBDATA * GB_clone(GBDATA *gb_destCont, GBDATA *gb_source)
Definition: arbdb.cxx:2196
#define TEST_REJECT(cond)
Definition: test_unit.h:1330
#define TEST_REJECT_NULL(n)
Definition: test_unit.h:1325
static void error(const char *msg)
Definition: mkptypes.cxx:96
void remove(int i)
char * read_string() const
Definition: calculator.cxx:105
#define TEST_EXPECT_ZERO_OR_SHOW_ERRNO(iocond)
Definition: test_unit.h:1090
SequenceHandler(GBDATA *gb_item_, const char *ali_)
Definition: calculator.cxx:42
GB_ERROR GB_write_int(GBDATA *gbd, long i)
Definition: arbdb.cxx:1250
GB_ERROR GB_set_temporary(GBDATA *gbd) __ATTR__USERESULT
Definition: arbdb.cxx:2282
#define TEST_EXPECT_NULL(n)
Definition: test_unit.h:1322
#define gb_assert(cond)
Definition: arbdbt.h:11
Definition: saiop.h:40
GB_ERROR close(GB_ERROR error)
Definition: arbdbpp.cxx:35
GB_ERROR GBT_write_string(GBDATA *gb_container, const char *fieldpath, const char *content)
Definition: adtools.cxx:451
bool saiHasDataInAli(GBDATA *gb_sai_data, const char *saiName, const char *ali)
Definition: calculator.cxx:142
#define TEST_EXPECT_NO_ERROR(call)
Definition: test_unit.h:1118
#define sai_assert(cond)
#define NULp
Definition: cxxforward.h:116
#define TEST_EXPECT_ERROR_CONTAINS(call, part)
Definition: test_unit.h:1114
NOT4PERL GBDATA * GBT_create_sequence_data(GBDATA *species, const char *ali_name, const char *key, GB_TYPES type, int security_write)
Definition: adali.cxx:643
char * GBT_get_default_alignment(GBDATA *gb_main)
Definition: adali.cxx:747
GBDATA * GBT_find_SAI_rel_SAI_data(GBDATA *gb_sai_data, const char *name)
Definition: aditem.cxx:171
#define TEST_EXPECT_TEXTFILE_DIFFLINES(fgot, fwant, diff)
Definition: test_unit.h:1416
GB_TYPES
Definition: arbdb.h:62
ARB_ERROR getError() const
Definition: ErrorOrType.h:53
GBDATA * GB_nextChild(GBDATA *child)
Definition: adquery.cxx:326
GB_transaction ta(gb_var)
GB_CSTR GB_read_char_pntr(GBDATA *gbd)
Definition: arbdb.cxx:904
GBDATA * gb_main
Definition: adname.cxx:32
GBDATA * GBT_get_SAI_data(GBDATA *gb_main)
Definition: aditem.cxx:154
GB_CSTR GBT_get_name_or_description(GBDATA *gb_item)
Definition: aditem.cxx:459
#define TEST_EXPECT_EQUAL(expr, want)
Definition: test_unit.h:1294
GBDATA * GB_entry(GBDATA *father, const char *key)
Definition: adquery.cxx:334
char * GBS_global_string_copy(const char *templat,...)
Definition: arb_msg.cxx:194
void GB_close(GBDATA *gbd)
Definition: arbdb.cxx:655
Definition: arbdb.h:66
#define UNCOVERED()
Definition: arb_assert.h:380
GB_ERROR GB_write_autoconv_string(GBDATA *gbd, const char *val)
Definition: arbdb.cxx:1479