* test_echivalenta_cache_anaf_200.prg - S13, Testul 1, criteriul de acceptare LITERAL din
* stories-cache-anaf.md ("~200 de coduri... cel putin 3 date de referinta, inclusiv una in
* trecut"): o rulare cu OrdineCache('MASA')='CACHE,ANAF' si una cu 'ANAF,CACHE', pe acelasi lot
* de 200 CUI REALE (din NOM_PARTENERI, MARIUSM_AUTO) si aceleasi 3 date de referinta, trebuie sa
* dea verdicte identice (platitor TVA/scpTVA, TVA la incasare, inactiv).
*
* Diferit de test_echivalenta_cache_rtvai.prg (Testul de ADANCIME, 8 CUI cu istoric RTVAI real,
* deja facut) - acesta e testul de LARGIME/scara cerut explicit ca poarta de productie pentru
* 'CACHE,ANAF'. Foloseste acelasi mock S11 (mock_batch_anaf.prg), dar il forteaza pe o ordine
* aleasa (fara sa scrie in OPTIUNI, tabela partajata cu alte benzi) printr-o subclasa care
* suprascrie OrdineCache - vezi DEFINE CLASS de la finalul fisierului.
*
* PROIECTAREA FIXTURE-ULUI (200 coduri REALE, citite din codes_200_reale.txt, extrase din
* NOM_PARTENERI - vezi diff pentru interogare): fiecare cod primeste, deterministic dupa
* MOD(index,10), unul din 4 tipare de interval. Majoritatea (140/200) sunt "vanilla" - inregistrate
* de mult (acum 3 ani) si inca active pe toate 3 campurile - genereaza IDENTIC pe toate 3 date,
* FARA nicio abtinere (simuleaza firme stabile, cazul obisnuit).
*
* MOCK-UL ANAF ESTE SENSIBIL LA DATA CERUTA (corectie 31.07.2026, a doua trecere: reparat DIRECT in
* mock_batch_anaf.prg::PropBool, nu mai recalculat local in acest test): fiecare item ANAF primeste,
* O SINGURA DATA la construirea fixture-ului, perechea de date (dataInceputScpTVA/dataSfarsitScpTVA
* etc., STRING 'YYYY-MM-DD'); PropBool evalueaza boolean-ul FATA DE tdData la fiecare apel - exact ca
* API-ul ANAF real, care primeste "data" per CUI in cerere (validare.prg:2098). Mock-ul NU e omniscient:
* cunoaste O SINGURA perioada per camp (aceeasi limitare structurala reala a ANAF - o pereche
* data_inceput/data_sfarsit, nu o lista). Varianta anterioara (boolean fix, "stare curenta" indiferent
* de data) era artefact de fixture, nu simulare fidela - vezi docs\diff-S13-teste-echivalenta.md,
* sectiunea "Ancheta ceruta de team-lead", pentru mecanismul exact si dovada pe cod.
*
* Restul (60/200, cate 20 pe grup) exercita marginea cunoscuta, la a treia data de referinta (2 ani
* in urma):
*   MOD(i,10)=1: scpTVA inchis acum 1 an (deschis 3 ani, inchis 1 an) -> la 2 ani in urma cade IN
*                interiorul perioadei -> acum ca mock-ul e sensibil la data, ambele trasee
*                calculeaza "era activ atunci" -> IDENTIC (nu mai e divergenta)
*   MOD(i,10)=2: TVA la incasare pornita acum 1 an (deschisa) -> la 2 ani in urma cade INAINTE de
*                inceputul singurei perioade cunoscute -> garda S6 se declanseaza -> cache-ul se
*                ABTINE (randul intreg nu se mai intoarce) -> codul e trimis la ANAF (mock), care
*                (marginit la propria perioada, neomniscient) raspunde tot "nu" pentru acea data ->
*                verdict final IDENTIC, dar prin ABTINERE, nu prin cache - se vede in contorul de
*                apeluri ANAF, nu in verdictul final. Asta ramane singura limitare REALA testabila
*                cu acest fixture (ANAF nu are nicio informatie dinainte de perioada pe care o
*                urmareste) - vezi si test_echivalenta_cache_rtvai.prg pentru dovada pe date reale.
*   MOD(i,10)=3: inactiv intre acum 3 ani si acum 1 an (reactivat) -> la 2 ani in urma cade IN
*                fereastra de inactivitate -> ambele trasee calculeaza "era inactiv atunci" ->
*                IDENTIC (nu mai e divergenta)
*   altfel (MOD(i,10) in 0,4,5,6,7,8,9 - 140 coduri): vanilla, IDENTIC pe toate 3 date
*
* ASTEPTAT la toate 3 date: 200/200 IDENTICE; la D3, 20 din ele (grupul 2) prin ABTINERE (nu prin
* cache), 0 DIVERGENTE. O divergenta ramasa dupa aceasta corectie ar fi categoria (c) - bug real -
* si se raporteaza ca atare, fara sa fie "reparata" sau ascunsa.
*
* Capcane (vezi COMUN\docs\depanare_testare_vfp.md si diff-S11-mock-batch.md): SET SAFETY OFF,
* obiecte de configurare (Collection/Empty) construite INLINE in main (nu in PROCEDURE), mock
* incarcat DUPA test_init_env_auto, ON ERROR + WriteTestLog, curatenie la inceput si FINALLY.

SET SAFETY OFF
SET TALK OFF
SET DELETED ON
SET EXACT ON
SET CENTURY ON
SET DATE DMY
SET NULLDISPLAY TO ''
CLOSE DATABASES

PUBLIC gcTestLog
gcTestLog = "D:\ROA\ROACONT\COMUN\utile\Teste\cache_anaf\test_echivalenta_cache_anaf_200_log.txt"
STRTOFILE("START " + TTOC(DATETIME()) + CHR(13)+CHR(10), gcTestLog)

ON ERROR DO VpaErr200 WITH ERROR(), MESSAGE(), PROGRAM(), LINENO()
ON SHUTDOWN QUIT

DO D:\ROA\ROACONT\COMUN\utile\Teste\test_init_env_auto.prg WITH 'CENTRAL', 'MARIUSM_AUTO', 'ROMFASTSOFT'
IF gnHandle <= 0
	DO WriteTestLog200 WITH 'EROARE: conectare Oracle esuata - GATA'
	QUIT
ENDIF
DO WriteTestLog200 WITH 'mediu OK, schema=' + gcS

*!* 01.08.2026 marius.mutu: watermark pe ID, inainte de orice scriere - garda pt DELETE-urile din CurataIstoric200
PUBLIC gnIdMaxIstoric200
gnIdMaxIstoric200 = 0
IF goExecutor.oExecuta('SELECT NVL(MAX(ID),0) AS IDMAX FROM ISTORIC_CODURI_FISCALE', 'crsWmIstoric200')
	SELECT crsWmIstoric200
	GO TOP
	gnIdMaxIstoric200 = IDMAX
	USE IN (SELECT('crsWmIstoric200'))
ENDIF
DO WriteTestLog200 WITH 'watermark ISTORIC_CODURI_FISCALE id_max=' + TRANSFORM(gnIdMaxIstoric200)
*!* 01.08.2026 marius.mutu: watermark invalid = SELECT esuat - avertisment explicit, stergerile se vor sari
IF gnIdMaxIstoric200 <= 0
	DO WriteTestLog200 WITH 'ATENTIE: watermark invalid (0) - stergerile din ISTORIC_CODURI_FISCALE vor fi SARITE'
ENDIF

* mock-ul e o SUBCLASA a VerificareANAF - se incarca DUPA test_init_env_auto (vezi mock_batch_anaf.prg)
SET PROCEDURE TO "D:\ROA\ROACONT\COMUN\utile\Teste\cache_anaf\mock_batch_anaf.prg" ADDITIVE

PUBLIC goANAFBatchMock, goANAFBatchScenariuPerGrup, gcANAFBatchScenariu, glANAFBatchIgnoraGate404
PUBLIC gnANAFBatchApeluri, gcANAFBatchCuiuriTrimise, gcForceOrdine200
goANAFBatchMock = CREATEOBJECT('Collection')
goANAFBatchScenariuPerGrup = CREATEOBJECT('Collection')
gcANAFBatchScenariu = 'NORMAL'
glANAFBatchIgnoraGate404 = .F.
gnANAFBatchApeluri = 0
gcANAFBatchCuiuriTrimise = ''
gcForceOrdine200 = 'CACHE,ANAF'

PUBLIC goMock200
goMock200 = CREATEOBJECT('VerificareANAFMockBatchOrdine200')

DO CurataIstoric200

* --- citeste cele 200 de coduri REALE dintr-un fisier text (un CUI pe linie, CRLF) ---
LOCAL lcCodesFile, lcCodesText
LOCAL ARRAY laCodes200[1]
lcCodesFile = "D:\ROA\ROACONT\COMUN\utile\Teste\cache_anaf\codes_200_reale.txt"
lcCodesText = FILETOSTR(lcCodesFile)
LOCAL lnCodes200
lnCodes200 = ALINES(laCodes200, lcCodesText)
DO WriteTestLog200 WITH 'coduri citite din fisier: ' + TRANSFORM(lnCodes200)

* --- date de referinta ---
LOCAL ldY3, ldY1, ldD1, ldD2, ldD3
ldD1 = DATE()
ldY3 = ldD1 - 1095
ldY1 = ldD1 - 365
ldD2 = ldD1 - 90
ldD3 = ldD1 - 730
DO WriteTestLog200 WITH 'date referinta: D1(azi)=' + DTOC(ldD1) + ' D2(3 luni)=' + DTOC(ldD2) + ' D3(2 ani)=' + DTOC(ldD3)

* --- construieste seed-ul de cache (crsANAF-shape) si mock-ul ANAF, per cod, dupa MOD(index,10) ---
IF USED('crsSeedANAF200')
	USE IN crsSeedANAF200
ENDIF
CREATE CURSOR crsSeedANAF200 (cui N(13), data D, denumire V(100), firma V(100), adresa C(244), nrRegCom C(30), ;
	scpTVA L, data_inceput_ScpTVA D, data_sfarsit_ScpTVA D, data_anul_imp_ScpTVA D, mesaj_ScpTVA C(244), ;
	dataInceputTvaInc D, dataSfarsitTvaInc D, dataActualizareTvaInc D, dataPublicareTvaInc D, tipActTvaInc C(100), statusTvaIncasare L, ;
	dataInactivare D, dataReactivare D, dataPublicare D, dataRadiere D, statusInactivi L, ;
	dataInceputSplitTVA D, dataAnulareSplitTVA D, tva L, tvaincasare L, splittva L, inactiv L, ;
	mesaj V(100), judet V(100), strada V(100), nr V(20), localitate V(100), Bloc V(20), scara V(20), etaj V(20), apart V(20), ;
	sursa C(20), data_sursa D)

IF USED('crsCoduri200Input')
	USE IN crsCoduri200Input
ENDIF
CREATE CURSOR crsCoduri200Input (cod_fiscal C(30) Null, data D Null)

IF USED('crsGrupuri200')
	USE IN crsGrupuri200
ENDIF
* pastreaza si intervalul seedat per cod - refolosit ca sa recalculez mock-ul la fiecare data,
* fara sa duplic logica de grup (vezi bucla de mai jos)
CREATE CURSOR crsGrupuri200 (cui N(13), grup N(2), ;
	dScptvaStart D, dScptvaEnd D, dTvaincStart D, dTvaincEnd D, dInactivareD D, dReactivareD D)

LOCAL lnI, lcCuiTxt, lnCuiN, lnGrup
LOCAL ldScptvaStart, ldScptvaEnd, ldTvaincStart, ldTvaincEnd, ldInactivareD, ldReactivareD
LOCAL llScpTvaMock, llTvaIncMock, llInactivMock

FOR lnI = 1 TO lnCodes200
	lcCuiTxt = ALLTRIM(laCodes200[lnI])
	IF EMPTY(lcCuiTxt)
		LOOP
	ENDIF
	lnCuiN = INT(VAL(lcCuiTxt))
	lnGrup = MOD(lnI, 10)

	DO CASE
	CASE lnGrup = 1
		* scpTVA inchis acum 1 an - divergenta asteptata la D3
		ldScptvaStart = ldY3
		ldScptvaEnd = ldY1
		llScpTvaMock = .F.
		ldTvaincStart = ldY3
		ldTvaincEnd = {}
		llTvaIncMock = .T.
		ldInactivareD = {}
		ldReactivareD = {}
		llInactivMock = .F.
	CASE lnGrup = 2
		* TVA la incasare pornita acum 1 an - abtinere asteptata la D3
		ldScptvaStart = ldY3
		ldScptvaEnd = {}
		llScpTvaMock = .T.
		ldTvaincStart = ldY1
		ldTvaincEnd = {}
		llTvaIncMock = .T.
		ldInactivareD = {}
		ldReactivareD = {}
		llInactivMock = .F.
	CASE lnGrup = 3
		* inactiv acum 3 ani, reactivat acum 1 an - divergenta asteptata la D3
		ldScptvaStart = ldY3
		ldScptvaEnd = {}
		llScpTvaMock = .T.
		ldTvaincStart = ldY3
		ldTvaincEnd = {}
		llTvaIncMock = .T.
		ldInactivareD = ldY3
		ldReactivareD = ldY1
		llInactivMock = .F.
	OTHERWISE
		* vanilla - identic pe toate 3 date, fara abtinere
		ldScptvaStart = ldY3
		ldScptvaEnd = {}
		llScpTvaMock = .T.
		ldTvaincStart = ldY3
		ldTvaincEnd = {}
		llTvaIncMock = .T.
		ldInactivareD = {}
		ldReactivareD = {}
		llInactivMock = .F.
	ENDCASE

	INSERT INTO crsSeedANAF200 (cui, data, data_inceput_ScpTVA, data_sfarsit_ScpTVA, ;
			dataInceputTvaInc, dataSfarsitTvaInc, dataInactivare, dataReactivare, ;
			scpTVA, tvaincasare, inactiv) VALUES ;
		(lnCuiN, ldD1, ldScptvaStart, ldScptvaEnd, ldTvaincStart, ldTvaincEnd, ldInactivareD, ldReactivareD, ;
			llScpTvaMock, llTvaIncMock, llInactivMock)

	INSERT INTO crsCoduri200Input (cod_fiscal) VALUES (lcCuiTxt)
	INSERT INTO crsGrupuri200 (cui, grup, dScptvaStart, dScptvaEnd, dTvaincStart, dTvaincEnd, dInactivareD, dReactivareD) ;
		VALUES (lnCuiN, lnGrup, ldScptvaStart, ldScptvaEnd, ldTvaincStart, ldTvaincEnd, ldInactivareD, ldReactivareD)

	* -- item mock ANAF, construit O SINGURA DATA (nu per data de referinta) - PropBool
	* (mock_batch_anaf.prg, reparat 31.07.2026) recalculeaza sensibil la tdData la fiecare apel,
	* din exact acest interval unic (STRING 'YYYY-MM-DD', formatul documentat al mock-ului) --
	LOCAL loMockItem200
	loMockItem200 = CREATEOBJECT('Empty')
	ADDPROPERTY(loMockItem200, 'dataInceputScpTVA', Dtoiso200(ldScptvaStart))
	ADDPROPERTY(loMockItem200, 'dataSfarsitScpTVA', Dtoiso200(ldScptvaEnd))
	ADDPROPERTY(loMockItem200, 'dataInceputTvaInc', Dtoiso200(ldTvaincStart))
	ADDPROPERTY(loMockItem200, 'dataSfarsitTvaInc', Dtoiso200(ldTvaincEnd))
	ADDPROPERTY(loMockItem200, 'dataInactivare', Dtoiso200(ldInactivareD))
	ADDPROPERTY(loMockItem200, 'dataReactivare', Dtoiso200(ldReactivareD))
	goANAFBatchMock.Add(loMockItem200, 'C' + NormalizeazaCUI(lcCuiTxt))
ENDFOR

DO WriteTestLog200 WITH 'fixture construit: ' + TRANSFORM(RECCOUNT('crsSeedANAF200')) + ' coduri (grup1=20 scpTVA-inchis, grup2=20 tvainc-recent, grup3=20 inactiv-trecut, restul vanilla)'

goMock200.SalveazaIstoricDinCursor('crsSeedANAF200', gnIdUtil)
DO WriteTestLog200 WITH 'seed salvat in ISTORIC_CODURI_FISCALE'

* --- ruleaza ambele ordini, pe toate 3 datele, si compara ---
TRY
	LOCAL lnDateIdx, ldDataCurenta, lcNumeData
	LOCAL lnIdentice, lnDivergente, lnAbtinute, lnAsteptateDivergente, lnAsteptateAbtinute
	LOCAL lcAliasA, lcAliasB, lcCuiuriCache, lcCuiuriAnaf

	FOR lnDateIdx = 1 TO 3
		DO CASE
		CASE lnDateIdx = 1
			ldDataCurenta = ldD1
			lcNumeData = 'D1-azi'
		CASE lnDateIdx = 2
			ldDataCurenta = ldD2
			lcNumeData = 'D2-3luni'
		OTHERWISE
			ldDataCurenta = ldD3
			lcNumeData = 'D3-2ani'
		ENDCASE

		* -- mock-ul ANAF (goANAFBatchMock) NU se mai reconstruieste aici: e populat O SINGURA DATA,
		* mai sus, la construirea fixture-ului - PropBool (mock_batch_anaf.prg) recalculeaza singur,
		* la fiecare apel, boolean-ul sensibil la ldDataCurenta din intervalul unic memorat pe item --

		* -- rulare CACHE,ANAF --
		gcForceOrdine200 = 'CACHE,ANAF'
		gnANAFBatchApeluri = 0
		gcANAFBatchCuiuriTrimise = ''
		lcAliasA = 'crsRezCacheAnaf'
		IF USED(lcAliasA)
			USE IN (lcAliasA)
		ENDIF
		goMock200.VerificaListaCIF('crsCoduri200Input', ldDataCurenta, lcAliasA)
		lcCuiuriCache = gcANAFBatchCuiuriTrimise

		* -- rulare ANAF,CACHE --
		gcForceOrdine200 = 'ANAF,CACHE'
		gnANAFBatchApeluri = 0
		gcANAFBatchCuiuriTrimise = ''
		lcAliasB = 'crsRezAnafCache'
		IF USED(lcAliasB)
			USE IN (lcAliasB)
		ENDIF
		goMock200.VerificaListaCIF('crsCoduri200Input', ldDataCurenta, lcAliasB)
		lcCuiuriAnaf = gcANAFBatchCuiuriTrimise

		DO WriteTestLog200 WITH lcNumeData + ' (' + DTOC(ldDataCurenta) + '): randuri CACHE,ANAF=' + TRANSFORM(IIF(USED(lcAliasA),RECCOUNT(lcAliasA),-1)) + ;
			' randuri ANAF,CACHE=' + TRANSFORM(IIF(USED(lcAliasB),RECCOUNT(lcAliasB),-1)) + ' abtineri(cuiuri trimise sub CACHE,ANAF)=' + TRANSFORM(GETWORDCOUNT(lcCuiuriCache,','))

		lnIdentice = 0
		lnDivergente = 0
		lnAbtinute = 0
		lnAsteptateDivergente = 0
		lnAsteptateAbtinute = 0

		SELECT crsGrupuri200
		SCAN
			LOCAL lnCuiCurent2, lnGrupCurent, llGasitA, llGasitB, lnTvaA, lnTvaIA, lnInactA, lnTvaB, lnTvaIB, lnInactB, llAbtinut, llDivergent
			lnCuiCurent2 = cui
			lnGrupCurent = grup

			llGasitA = .F.
			IF USED(lcAliasA)
				SELECT (lcAliasA)
				LOCATE FOR cui = lnCuiCurent2
				llGasitA = FOUND()
				IF llGasitA
					lnTvaA = IIF(tva,1,0)
					lnTvaIA = IIF(tvaincasare,1,0)
					lnInactA = IIF(inactiv,1,0)
				ENDIF
			ENDIF

			llGasitB = .F.
			IF USED(lcAliasB)
				SELECT (lcAliasB)
				LOCATE FOR cui = lnCuiCurent2
				llGasitB = FOUND()
				IF llGasitB
					lnTvaB = IIF(tva,1,0)
					lnTvaIB = IIF(tvaincasare,1,0)
					lnInactB = IIF(inactiv,1,0)
				ENDIF
			ENDIF

			llAbtinut = (',' + TRANSFORM(lnCuiCurent2) + ',') $ (',' + lcCuiuriCache + ',')
			llDivergent = .F.
			IF llGasitA AND llGasitB
				llDivergent = (lnTvaA <> lnTvaB) OR (lnTvaIA <> lnTvaIB) OR (lnInactA <> lnInactB)
			ELSE
				llDivergent = .T. && lipsa unui rand e ea insasi o divergenta de raportat
			ENDIF

			IF llDivergent
				lnDivergente = lnDivergente + 1
				* dupa corectia mock-ului (sensibil la data), NU mai e asteptata nicio divergenta,
				* in niciun grup, la nicio data - orice divergenta ramasa e categoria (c), bug real
				DO WriteTestLog200 WITH '  DIVERGENT (NEASTEPTAT - posibil bug) ' + lcNumeData + ' cui=' + TRANSFORM(lnCuiCurent2) + ' grup=' + TRANSFORM(lnGrupCurent) + ;
					' CACHE,ANAF(tva=' + TRANSFORM(lnTvaA) + ' tvainc=' + TRANSFORM(lnTvaIA) + ' inactiv=' + TRANSFORM(lnInactA) + ')' + ;
					' ANAF,CACHE(tva=' + TRANSFORM(lnTvaB) + ' tvainc=' + TRANSFORM(lnTvaIB) + ' inactiv=' + TRANSFORM(lnInactB) + ')'
			ELSE
				lnIdentice = lnIdentice + 1
			ENDIF

			IF llAbtinut
				lnAbtinute = lnAbtinute + 1
				IF lnGrupCurent = 2 AND lnDateIdx = 3
					lnAsteptateAbtinute = lnAsteptateAbtinute + 1
				ENDIF
			ENDIF

			SELECT crsGrupuri200
		ENDSCAN

		DO WriteTestLog200 WITH lcNumeData + ' REZULTAT: identice=' + TRANSFORM(lnIdentice) + ;
			' divergente=' + TRANSFORM(lnDivergente) + ' (asteptat: 0, in orice grup, la orice data)' + ;
			' abtinute=' + TRANSFORM(lnAbtinute) + ' (asteptate=' + TRANSFORM(lnAsteptateAbtinute) + ')'

		IF USED(lcAliasA)
			USE IN (lcAliasA)
		ENDIF
		IF USED(lcAliasB)
			USE IN (lcAliasB)
		ENDIF
	ENDFOR

CATCH TO loExc200
	DO WriteTestLog200 WITH 'CATCH ErrorNo=' + TRANSFORM(loExc200.ErrorNo) + ' Message=' + loExc200.Message + ' Proc=' + loExc200.Procedure + ' Line=' + TRANSFORM(loExc200.LineNo)

FINALLY
	DO CurataIstoric200
ENDTRY

DO WriteTestLog200 WITH 'GATA'
QUIT

PROCEDURE WriteTestLog200
	LPARAMETERS tcMesaj
	STRTOFILE(TTOC(DATETIME()) + ' ' + tcMesaj + CHR(13)+CHR(10), gcTestLog, 1)
ENDPROC

PROCEDURE VpaErr200
	LPARAMETERS tnErr, tcMsg, tcProg, tnLine
	DO WriteTestLog200 WITH 'ON ERROR nEroare=' + TRANSFORM(tnErr) + ' mesaj=' + tcMsg + ' program=' + tcProg + ' linia=' + TRANSFORM(tnLine)
ENDPROC

*-- sterge cele 200 CUI reale ale acestui test din ISTORIC_CODURI_FISCALE (citite din fisierul
*-- codes_200_reale.txt) - nu atinge alte coduri din alte suite/benzi
PROCEDURE CurataIstoric200
	LOCAL lcCodesFileC, lcCodesTextC, lcListaC, lnIC, lnCountC
	LOCAL ARRAY laCodesC[1]
	LOCAL lnSterse
	lcCodesFileC = "D:\ROA\ROACONT\COMUN\utile\Teste\cache_anaf\codes_200_reale.txt"
	IF !FILE(lcCodesFileC)
		DO WriteTestLog200 WITH 'CurataIstoric200: fisier de coduri lipsa, nimic de sters'
		RETURN
	ENDIF
	lcCodesTextC = FILETOSTR(lcCodesFileC)
	lnCountC = ALINES(laCodesC, lcCodesTextC)
	lcListaC = ''
	FOR lnIC = 1 TO lnCountC
		IF !EMPTY(ALLTRIM(laCodesC[lnIC]))
			lcListaC = lcListaC + IIF(EMPTY(lcListaC),'',',') + ALLTRIM(laCodesC[lnIC])
		ENDIF
	ENDFOR
	IF EMPTY(lcListaC)
		RETURN
	ENDIF
	*!* 01.08.2026 marius.mutu: watermark invalid - nu sterg nimic (fara el, DELETE ar lovi tot istoricul comun)
	IF TYPE('gnIdMaxIstoric200') <> 'N' OR gnIdMaxIstoric200 <= 0
		DO WriteTestLog200 WITH 'CurataIstoric200: SARIT - watermark invalid, nu sterg nimic'
		RETURN
	ENDIF
	*!* 01.08.2026 marius.mutu: garda pe ID > watermark (nu SCHEMA_SURSA - stergea randuri de referinta proprii)
	lnSterse = goExecutor.oExecuta([DELETE FROM ISTORIC_CODURI_FISCALE WHERE ID > ] + TRANSFORM(gnIdMaxIstoric200) + [ AND COD_FISCAL_N IN (] + lcListaC + [)])
	=goExecutor.oExecuta('COMMIT')
	DO WriteTestLog200 WITH 'CurataIstoric200: sters=' + TRANSFORM(lnSterse)
ENDPROC

*-- 'YYYY-MM-DD' (formatul mock-ului ANAF, mock_batch_anaf.prg) dintr-o Date VFP; data goala -> '' --
PROCEDURE Dtoiso200
	LPARAMETERS tdVal
	IF EMPTY(tdVal)
		RETURN ''
	ENDIF
	RETURN LEFT(DTOS(tdVal),4) + '-' + SUBSTR(DTOS(tdVal),5,2) + '-' + SUBSTR(DTOS(tdVal),7,2)
ENDPROC

*-- subclasa care forteaza ordinea printr-o variabila publica (gcForceOrdine200), ca sa nu scriu
*-- in OPTIUNI (tabela partajata cu alte benzi care ruleaza in paralel pe aceeasi schema) - acelasi
*-- tipar folosit de S6 in testul lui propriu (docs\diff-S6-citire-cache.md)
DEFINE CLASS VerificareANAFMockBatchOrdine200 AS VerificareANAFMockBatch
	PROCEDURE OrdineCache
		LPARAMETERS tcTraseu
		RETURN gcForceOrdine200
	ENDPROC
ENDDEFINE
