// ========================================================= // // // // File : calculator.cxx // // Purpose : perform SAI calculation // // // // Coded by Ralf Westram (coder@reallysoft.de) in Dec 19 // // http://www.arb-home.de/ // // // // ========================================================= // #include "calculator.h" #include using namespace std; class SequenceHandler : virtual Noncopyable { // @@@ class SequenceHandler should be used wherever NOT_ALL_SAI_HAVE_DATA GBDATA *gb_item; // item (e.g. SAI, species, ...) char *ali; // alignment name GBDATA *gb_data; // data element containing sequence (e.g. 'ali_xxx/data') GB_ERROR error; bool createPossible; mutable SmartCharPtr buffer; // holds data (if GB_read_as_string has been used) void annotate_error() { sai_assert(error); char *fieldDescription = NULp; if (gb_data) { fieldDescription = GBS_global_string_copy("; field '%s'", GB_read_key_pntr(gb_data)); } error = GBS_global_string("%s (at %s '%s'; alignment '%s'%s)", error, GB_read_key_pntr(gb_item), GBT_get_name_or_description(gb_item), ali, fieldDescription ? fieldDescription : ""); free(fieldDescription); } public: SequenceHandler(GBDATA *gb_item_, const char *ali_) : gb_item(gb_item_), ali(strdup(ali_)), gb_data(NULp), error(NULp), createPossible(true) { GBDATA *gb_ali = GB_entry(gb_item, ali); if (!gb_ali) { error = "has no entries"; } else { gb_data = GB_entry(gb_ali, "data"); // try standard sequence entry first. if (!gb_data && !GB_have_error()) { if (strcmp(GB_read_key_pntr(gb_item), "extended") == 0) { // these entries are only tried for SAI: gb_data = GB_entry(gb_ali, "bits"); // e.g. occurs in 'markerline' } } if (!gb_data) { error = GB_have_error() ? GB_await_error() : "could not detect sequence data"; } } if (!error) { GB_TYPES type = GB_read_type(gb_data); if (type != GB_STRING && type != GB_BITS) { error = "cannot handle type as sequence- or associated-data"; createPossible = false; gb_data = NULp; // => !wasFound() } } if (error) { annotate_error(); } else { sai_assert(wasFound()); createPossible = false; } } ~SequenceHandler() { free(ali); } GB_ERROR getError() const { // used to retrieve error (after call to ctor) => cannot read data // Nevertheless calling create() and then writing data may be a valid option! return error; } bool wasFound() const { return gb_data != NULp; } // Note: "wasFound() && getError()" may occur! const char *read_char_pntr() const { sai_assert(wasFound()); GB_TYPES type = GB_read_type(gb_data); if (type == GB_STRING) { return GB_read_char_pntr(gb_data); } buffer.assign(GB_read_as_string(gb_data)); return buffer.content(); } char *read_string() const { sai_assert(wasFound()); return GB_read_as_string(gb_data); } GB_ERROR write_string(const char *data) const { sai_assert(wasFound()); return GB_write_autoconv_string(gb_data, data); } GB_ERROR create(GB_TYPES type, const char *fieldName) { bool annotateError = true; if (createPossible) { sai_assert(!wasFound()); // already have sequence error = NULp; // superseeds any errors from ctor gb_data = GBT_create_sequence_data(gb_item, ali, fieldName, type, 0); if (!gb_data) error = GB_await_error(); } else { if (getError()) { annotateError = false; // keep existing and already annotated error } else if (wasFound()) { error = "cannot create data over existing"; } else { sai_assert(0); // sth is wrong here with program logic error = "cannot create data (logic error)"; } } if (error && annotateError) annotate_error(); return error; } }; inline bool saiHasDataInAli(GBDATA *gb_sai_data, const char *saiName, const char *ali) { GBDATA *gb_sai = GBT_expect_SAI_rel_SAI_data(gb_sai_data, saiName); if (!gb_sai) { GB_clear_error(); return false; } SequenceHandler saiseq(gb_sai, ali); return saiseq.wasFound(); } bool SaiCalculator::allSaiHaveDataInAlignment(const char *ali) { bool seenMissingData = false; GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main); for (int i = 0; inputSaiNames[i] && !seenMissingData; ++i) { seenMissingData = !saiHasDataInAli(gb_sai_data, inputSaiNames[i], ali); } return !seenMissingData; } void SaiCalculator::run() { sai_assert(!GB_have_error()); GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main); GBDATA *gb_target_sai = GBT_find_SAI_rel_SAI_data(gb_sai_data, outSaiName); if (!gb_target_sai) { if (GB_have_error()) { error = GB_await_error(); } else { // create new SAI as target: gb_target_sai = GB_create_container(gb_sai_data, "extended"); error = gb_target_sai ? GBT_write_string(gb_target_sai, "name", outSaiName) : GB_await_error(); } } if (!error) { sai_assert(gb_target_sai); // @@@ DRY cases: switch (scope) { case SAS_SELECTED: { char *ali = GBT_get_default_alignment(gb_main); if (!ali) { error = GB_await_error(); } else { calc4ali(ali, gb_target_sai); free(ali); } break; } case SAS_ALL: { ConstStrArray aliName; GBT_get_alignment_names(aliName, gb_main); if (aliName.empty()) error = "No alignments found"; for (int a = 0; aliName[a] && !error; ++a) { calc4ali(aliName[a], gb_target_sai); } break; } case SAS_COMMON: { ConstStrArray aliName; GBT_get_alignment_names(aliName, gb_main); if (aliName.empty()) error = "No alignments found"; ConstStrArray commonAliName; for (int a = 0; aliName[a] && !error; ++a) { if (allSaiHaveDataInAlignment(aliName[a])) { commonAliName.put(aliName[a]); } } if (commonAliName.empty() && !error) error = "No alignments found where all SAI have data"; for (int a = 0; commonAliName[a] && !error; ++a) { calc4ali(commonAliName[a], gb_target_sai); } break; } case SAS_TARGET: { ConstStrArray aliName; GBT_get_alignment_names(aliName, gb_main); if (aliName.empty()) error = "No alignments found"; ConstStrArray existingAliName; for (int a = 0; aliName[a] && !error; ++a) { if (saiHasDataInAli(gb_sai_data, outSaiName, aliName[a])) { existingAliName.put(aliName[a]); } } if (existingAliName.empty() && !error) error = "No alignments found where target SAI has data"; for (int a = 0; existingAliName[a] && !error; ++a) { calc4ali(existingAliName[a], gb_target_sai); } break; } } } // @@@ test gb_target_sai for "ali_..." subcontainers. If none exist = > raise error to avoid creation of SAI w/o any data. } void SaiCalculator::calc4ali(const char *ali, GBDATA *gb_target_sai) { sai_assert(ali && ali[0]); // has to be defined and not empty sai_assert(!error); GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main); string sai_comment = "CalcSAI: "; // collect input data: StrArray saiData; for (int i = 0; inputSaiNames[i] && !error; ++i) { GBDATA *gb_sai = GBT_expect_SAI_rel_SAI_data(gb_sai_data, inputSaiNames[i]); if (!gb_sai) { error = GB_await_error(); } else { SequenceHandler saiseq(gb_sai, ali); if (saiseq.getError()) { error = saiseq.getError(); } else if (saiseq.wasFound()) { saiData.put(saiseq.read_string()); } else { UNCOVERED(); // @@@ somehow report sai has no data in alignment (caller shall fail if not found any data or if not enough SAI for operator) } } if (i>0) sai_comment += '+'; sai_comment += inputSaiNames[i]; } if (!error) { SaiCalcEnv calcEnv(saiData, gb_main); ErrorOrString result = op.apply(calcEnv); sai_comment += " | "; sai_comment += op.get_description(); if (result.hasError()) { error = result.getError(); } else { // write result to target SAI: SequenceHandler targetSeq(gb_target_sai, ali); if (!targetSeq.wasFound()) { error = targetSeq.create(GB_STRING, "data"); } if (!error) { string saidata = result.getValue(); error = targetSeq.write_string(saidata.c_str()); if (!error) { GBDATA *gb_ali = GB_entry(gb_target_sai, ali); gb_assert(gb_ali); if (gb_ali) { // write SAI comment (operator type, source SAIs, ...) error = GBT_write_string(gb_ali, "_TYPE", sai_comment.c_str()); } } } } } } // -------------------------------------------------------------------------------- #ifdef UNIT_TESTS #include #include #include void TEST_SequenceHandler() { GB_shell shell; GBDATA *gb_main = GB_open("TEST_prot_tiny.arb", "rw"); // ../../UNIT_TESTER/run/TEST_prot_tiny.arb { GB_transaction ta(gb_main); GBDATA *gb_maxFreq = GBT_expect_SAI(gb_main, "MAX_FREQUENCY"); GBDATA *gb_pvp = GBT_expect_SAI(gb_main, "POS_VAR_BY_PARSIMONY"); GBDATA *gb_marker = GBT_expect_SAI(gb_main, "markerline"); GBDATA *gb_CONS = GBT_expect_SAI(gb_main, "CONSENSUS"); SequenceHandler mfdna(gb_maxFreq, "ali_dna"); SequenceHandler mfpro(gb_maxFreq, "ali_prot"); SequenceHandler pvdna(gb_pvp, "ali_dna"); SequenceHandler pvpro(gb_pvp, "ali_prot"); SequenceHandler mldna(gb_marker, "ali_dna"); SequenceHandler mlpro(gb_marker, "ali_prot"); TEST_EXPECT(mfdna.wasFound()); TEST_EXPECT_NO_ERROR(mfdna.getError()); TEST_EXPECT(mfpro.wasFound()); TEST_EXPECT_NO_ERROR(mfpro.getError()); TEST_EXPECT(pvdna.wasFound()); TEST_EXPECT_NO_ERROR(pvdna.getError()); TEST_EXPECT(mldna.wasFound()); TEST_EXPECT_NO_ERROR(mldna.getError()); TEST_EXPECT(mlpro.wasFound()); TEST_EXPECT_NO_ERROR(mlpro.getError()); TEST_REJECT(pvpro.wasFound()); TEST_EXPECT_ERROR_CONTAINS(pvpro.getError(), "has no entries (at extended 'POS_VAR_BY_PARSIMONY'; alignment 'ali_prot')"); TEST_EXPECT_CONTAINS(mfdna.read_char_pntr(), "8570068866840660555755577540000060080000008775740000000008876547667770006555555"); TEST_EXPECT_EQUAL (mfpro.read_char_pntr(), "====050846555500000760006557055586550000055000555686654808508057566566754665055005800080550004500005666688====0="); TEST_EXPECT_CONTAINS(pvdna.read_char_pntr(), "..---664--2662440-44-61662664462-----4--4------662440.........442241224552"); TEST_EXPECT_CONTAINS(mldna.read_char_pntr(), "00111101111111110111100010001100111111111111111111010111111111111100111111111100000011111111001001111111111111111"); TEST_EXPECT_EQUAL (mlpro.read_char_pntr(), "0000101101000011111111111001100011001111100111000111100111011101011011100110100110111111001110011110111111000010"); // test to modify handled sequence and then read modified: TEST_EXPECT_NO_ERROR(mfpro.write_string(SmartCharPtr(GBS_string_eval(mfpro.read_char_pntr(), ":0=-")).content())); // "====050846555500000760006557055586550000055000555686654808508057566566754665055005800080550004500005666688====0=" TEST_EXPECT_EQUAL (mfpro.read_char_pntr(), "====-5-8465555-----76---6557-5558655-----55---5556866548-85-8-57566566754665-55--58---8-55---45----5666688====-="); TEST_EXPECT_NO_ERROR(mlpro.write_string(SmartCharPtr(GBS_string_eval(mlpro.read_char_pntr(), ":1=-:0=1:-=0")).content())); // invert // "0000101101000011111111111001100011001111100111000111100111011101011011100110100110111111001110011110111111000010" TEST_EXPECT_EQUAL(mlpro.read_char_pntr(), "1111010010111100000000000110011100110000011000111000011000100010100100011001011001000000110001100001000000111101"); TEST_EXPECT_NO_ERROR(mlpro.write_string("hello")); TEST_EXPECT_EQUAL(mlpro.read_char_pntr(), "11111"); // test to create sequence data: TEST_EXPECT_ERROR_CONTAINS(mfdna.create(GB_STRING, "data"), "cannot create data over existing (at extended 'MAX_FREQUENCY'; alignment 'ali_dna'; field 'data')"); TEST_EXPECT_ERROR_CONTAINS(mldna.create(GB_STRING, "data"), "cannot create data over existing (at extended 'markerline'; alignment 'ali_dna'; field 'bits')"); TEST_REJECT(pvpro.wasFound()); // has no data yet TEST_EXPECT_NO_ERROR(pvpro.create(GB_STRING, "data")); // create of new data entry (ali container is missing here) TEST_EXPECT(pvpro.wasFound()); // now has data // test write + read data into created GB_STRING entry: TEST_EXPECT_EQUAL(pvpro.read_char_pntr(), "..."); // default when only created, but never written TEST_EXPECT_NO_ERROR(pvpro.write_string( "10210310")); TEST_EXPECT_EQUAL(pvpro.read_char_pntr(), "10210310"); { // erase data entries from SAI "CONSENSUS": GBDATA *gb_CONS_ali_dna = GB_entry(gb_CONS, "ali_dna"); GBDATA *gb_CONS_ali_pro = GB_entry(gb_CONS, "ali_prot"); GBDATA *gb_data_dna = GB_entry(gb_CONS_ali_dna, "data"); GBDATA *gb_data_pro = GB_entry(gb_CONS_ali_pro, "data"); TEST_EXPECT_NO_ERROR(GB_delete(gb_data_dna)); TEST_EXPECT_NO_ERROR(GB_delete(gb_data_pro)); // create new data entry with wrong type GBDATA *gb_int_data = GB_create(gb_CONS_ali_pro, "data", GB_INT); TEST_EXPECT_NO_ERROR(GB_write_int(gb_int_data, 4711)); } SequenceHandler codna(gb_CONS, "ali_dna"); SequenceHandler copro(gb_CONS, "ali_prot"); TEST_REJECT(codna.wasFound()); TEST_REJECT(copro.wasFound()); TEST_EXPECT_ERROR_CONTAINS(codna.getError(), "could not detect sequence data (at extended 'CONSENSUS'; alignment 'ali_dna')"); TEST_EXPECT_ERROR_CONTAINS(copro.getError(), "cannot handle type as sequence- or associated-data (at extended 'CONSENSUS'; alignment 'ali_prot')"); TEST_REJECT(codna.wasFound()); // has no data yet TEST_EXPECT_NO_ERROR(codna.create(GB_BITS, "bits")); // create of new data entry (ali container is present here) TEST_EXPECT(codna.wasFound()); // now has data // test write + read data into created GB_BITS entry: TEST_EXPECT_NORESULT__NOERROREXPORTED(codna.read_char_pntr()); // default when only created, but never written TEST_EXPECT_NO_ERROR(codna.write_string( "10210310")); TEST_EXPECT_EQUAL(codna.read_char_pntr(), "10110110"); // string above was converted into bitstring // let create fail due to createPossible==false: 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?! } GB_close(gb_main); } #define TEST_EXPECT_MAKEOP(type,cfg) do{ \ ErrorOrSaiOperatorPtr made = SaiOperator::make(type,cfg); \ if (made.hasError()) { \ TEST_EXPECT_NO_ERROR(made.getError().deliver()); \ } \ op = made.getValue(); \ }while(0) static GB_ERROR tmp_all_but(GBDATA *gb_main, const char *keep) { GB_transaction ta(gb_main); GB_ERROR error = NULp; for (GBDATA *gbd = GB_child(gb_main); gbd && !error; gbd = GB_nextChild(gbd)) { if (strcmp(GB_read_key_pntr(gbd), keep) != 0) { error = GB_set_temporary(gbd); } } error = ta.close(error); return error; } static void clone_test_sai(GBDATA *gb_main, const char *name) { GB_transaction ta(gb_main); GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main); TEST_REJECT_NULL(gb_sai_data); GBDATA *gb_sai = GBT_expect_SAI_rel_SAI_data(gb_sai_data, name); TEST_REJECT_NULL(gb_sai); GBDATA *gb_clone_sai = GB_clone(gb_sai_data, gb_sai); TEST_REJECT_NULL(gb_clone_sai); GBDATA *gb_clone_name = gb_clone_sai ? GB_entry(gb_clone_sai, "name") : NULp; TEST_REJECT_NULL(gb_clone_name); TEST_EXPECT_NO_ERROR(GB_write_string(gb_clone_name, GBS_global_string("cloned_%s", GB_read_char_pntr(gb_clone_name)))); } static GB_ERROR clone_SAI(GBDATA *gb_main, const char *source_name, const char *dest_name) { GB_ERROR error = NULL; GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main); GBDATA *gb_source = GBT_find_SAI_rel_SAI_data(gb_sai_data, source_name); if (!gb_source) error = "cant find source"; else { GBDATA *gb_dest_exists = GBT_find_SAI_rel_SAI_data(gb_sai_data, dest_name); if (gb_dest_exists) error = "dest exists"; else { GBDATA *gb_dest = GB_create_container(gb_sai_data, "extended"); if (!gb_dest) error = GB_await_error(); else { error = GB_copy_dropProtectMarksAndTempstate(gb_dest, gb_source); if (!error) error = GBT_write_string(gb_dest, "name", dest_name); } } } return error; } void TEST_SaiCalculator() { GB_shell shell; GBDATA *gb_main = GB_open("TEST_prot_tiny.arb", "rw"); // ../../UNIT_TESTER/run/TEST_prot_tiny.arb // other database with several SAI: ../../UNIT_TESTER/run/TEST_fields_ascii.arb ConstStrArray inputSais; SaiOperatorPtr op; TEST_EXPECT_MAKEOP(SOP_TRANSLATE, "default='.'"); // creates 'op' from type and config (or fails) { SaiCalculator calculator(gb_main, inputSais, *op, "unwrittenSAI", SAS_SELECTED); TEST_EXPECT(calculator.hasError()); 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 } inputSais.put("MAX_FREQUENCY"); // (only in "ali_dna") { SaiCalculator calculator(gb_main, inputSais, *op, "mf_translated", SAS_SELECTED); TEST_REJECT(calculator.hasError()); } // test markerline translation via ACI: inputSais.clear(); inputSais.put("markerline"); // (in "ali_dna" and "ali_prot") TEST_EXPECT_MAKEOP(SOP_ACI, "aci='translate(\"01\",\"-x\")'"); { SaiCalculator calculator(gb_main, inputSais, *op, "markerline_aci", SAS_SELECTED); TEST_REJECT(calculator.hasError()); } // clone markerline sai -> markerline_clone (using copy function as used in SAI admin): { GB_transaction ta(gb_main); TEST_EXPECT_NO_ERROR(clone_SAI(gb_main, "markerline", "markerline_clone")); } // apply inverse aci than above, saving over binary sai: TEST_EXPECT_MAKEOP(SOP_ACI, "aci='translate(\"01\",\"10\")'"); { SaiCalculator calculator(gb_main, inputSais, *op, "markerline_clone", SAS_COMMON); TEST_REJECT(calculator.hasError()); // additional tests: test sai has 'data' + test content of 'bits': GB_transaction ta(gb_main); GBDATA *gb_sai = GBT_find_SAI(gb_main, "markerline_clone"); TEST_REJECT_NULL(gb_sai); GBDATA *gb_ali = GB_entry(gb_sai, "ali_prot"); TEST_REJECT_NULL(gb_ali); GBDATA *gb_data = GB_entry(gb_ali, "data"); TEST_EXPECT_NULL(gb_data); // no longer writes into 'data' entry GBDATA *gb_bits = GB_entry(gb_ali, "bits"); TEST_REJECT_NULL(gb_bits); SmartCharPtr bitstr = GB_read_as_string(gb_bits); TEST_EXPECT_EQUAL(&*bitstr, "1111010010111100000000000110011100110000011000111000011000100010100100011001011001000000110001100001000000111101"); } inputSais.put("POS_VAR_BY_PARSIMONY"); // (only in "ali_dna") TEST_EXPECT_MAKEOP(SOP_ACI, "aci='remove(\"-=.0\")|len|srt(0=-)'"); { SaiCalculator calculator(gb_main, inputSais, *op, "pvp_mix_marker1", SAS_SELECTED); TEST_REJECT(calculator.hasError()); } { SaiCalculator calculator(gb_main, inputSais, *op, "pvp_mix_marker2", SAS_ALL); TEST_EXPECT(calculator.hasError()); TEST_EXPECT_ERROR_CONTAINS(calculator.getError().deliver(), "has no entries (at extended 'POS_VAR_BY_PARSIMONY'; alignment 'ali_prot')"); } { SaiCalculator calculator(gb_main, inputSais, *op, "pvp_mix_marker3", SAS_COMMON); TEST_REJECT(calculator.hasError()); } TEST_EXPECT_NO_ERROR(GBT_set_default_alignment(gb_main, "ali_prot")); inputSais.remove(1); // remove POS_VAR_BY_PARSIMONY // (keep "markerline") inputSais.put("CONSENSUS"); // (in "ali_dna" and "ali_prot") TEST_EXPECT_MAKEOP(SOP_ACI, "aci='count(atAT);head(1)|mult|srt(0=-)'"); // only show set marker position for A and T. { SaiCalculator calculator(gb_main, inputSais, *op, "ml_cons1", SAS_SELECTED); // "ml_cons1" now has only data in "ali_prot" TEST_REJECT(calculator.hasError()); } { SaiCalculator calculator(gb_main, inputSais, *op, "ml_cons2", SAS_ALL); TEST_EXPECT(calculator.hasError()); 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"? } { SaiCalculator calculator(gb_main, inputSais, *op, "ml_cons3", SAS_COMMON); TEST_REJECT(calculator.hasError()); } // @@@ provoke some "no data" error by combining "ml_cons1" (ali_prot only) + POS_VAR_BY_PARSIMONY (ali_dna only) with scope SAS_COMMON clone_test_sai(gb_main, "ml_cons1"); // data in 'ali_prot' only clone_test_sai(gb_main, "markerline_aci"); // data in 'ali_dna' only // test SAS_TARGET (e.g. overwrite cloned SAIs with different operator): { SaiOperatorPtr oldOp = op; TEST_EXPECT_MAKEOP(SOP_ACI, "aci='count(gcGC);head(1)|mult|srt(0=-)'"); // only show set marker position for G and C. { SaiCalculator calculator(gb_main, inputSais, *op, "cloned_ml_cons1", SAS_TARGET); TEST_REJECT(calculator.hasError()); } { SaiCalculator calculator(gb_main, inputSais, *op, "cloned_markerline_aci", SAS_TARGET); TEST_REJECT(calculator.hasError()); } op = oldOp; } // delete 'ali_dna_incomplete' (used in no SAI, only in one species) { GB_transaction ta(gb_main); GBDATA *gb_ali_incomplete = GBT_get_alignment(gb_main, "ali_dna_incomplete"); TEST_EXPECT_NO_ERROR(GB_delete(gb_ali_incomplete)); } { // test again with SAS_ALL -> now it works SaiCalculator calculator(gb_main, inputSais, *op, "ml_cons4", SAS_ALL); TEST_REJECT(calculator.hasError()); } // @@@ test errors where no data is found (or not enough data, e.g. 2 SAI expected by operator but only one found) // --------------------------------------- // save DB and test its content: const char *written_ascii = "TEST_calcSAI_written.arb"; const char *expectd_ascii = "TEST_calcSAI_expectd.arb"; // ../../UNIT_TESTER/run/TEST_calcSAI_expectd.arb TEST_EXPECT_NO_ERROR(tmp_all_but(gb_main, "extended_data")); TEST_EXPECT_NO_ERROR(GB_save_as(gb_main, written_ascii, "a")); // #define TEST_AUTO_UPDATE // uncomment to update expected result #if defined(TEST_AUTO_UPDATE) TEST_COPY_FILE(written_ascii, expectd_ascii); #endif TEST_EXPECT_TEXTFILE_DIFFLINES(written_ascii, expectd_ascii, 0); TEST_EXPECT_ZERO_OR_SHOW_ERRNO(GB_unlink(written_ascii)); GB_close(gb_main); } #endif // UNIT_TESTS // --------------------------------------------------------------------------------