Pdvm_datetime-2

pdvm_datetime.py Teil 2

Der Teil 2 beinhaltet alles was ich über die Tests gemacht habe und die allgemeine Vorgehensweisen.

Allgemeines zu den Tests

Grundsätzlich gehe ich so vor, dass ich eine Datei selbsttestend mache. Dieses bedeutet, dass die einzelnen Konstellationen und Properties getestet werden, wenn die Datei direkt mit Phyton gestartet wird. Dieses hat mehrere Vorteile.
  • Test können mit der Entwicklung eingebaut werden und das Vorgehen sofort überprüfen.
  • Bisher getestetes wird mit jeder neuen oder geänderten Funktionalität wiederholt und stellt damit die Konsistenz der Software sicher.
  • Testserien können speziell gestaltet werden.
Hier gehe ich so vor, dass ich kleine Testroutinen geschrieben habe, die Tests, die in einem Wörterbuch eingetragen sind abarbeitet. Grundsätzlich wird hier dann die Differenz eines maschinell ermittelten Wertes zu einem fix eingegebenen (oder berechneten Wert) ermittelt. Tests mit Differenzen weißen damit auf Fehler in den Berechnungen hin. So gibt es am Ende eine Zusammenfassung evtl. aufgetretener Differenzen oder im besten Falle einfach ein OK.

Hauptprogramm - Testumgebung - Initalisierung

Beschreibung

# Hauptprogramm - Testumgebung
# --------------------------------------------------------------
if __name__=='__main__':
    # --------------------------------------------------------------
    import os                                  # Für Testbereich
    from pdvm_util import lockedWritten, multiChar, p_print, t_p_t
    # das Wörterbuch mit den einzelnen Testelementen wurde ausgelagert
    import pdvm_datetime_test
    tests = pdvm_datetime_test.testtabelle()
    # --------------------------------------------------------------
    try:                    # Console wir leer gemacht
        os.system('CLS')    # for Windows
    except:
        os.system('CLEAR')  # for Unix

    a = Pdvm_DateTime()                                 # Objekt wird initialisiert / Standardsprache

    linel = 70                  # Länge der Linien im Log
    print(multiChar("=",linel,1))
    print(lockedWritten(transkateone('general','OutTestProt', a.language)))
    print(multiChar("=",linel,2))
    blank = "----> "            # einrücken verschiedener Ausgaben
    test_list = {}

    a.PdvmDateTime = a.PdvmDateTimeNow()
    akt_year = str(a.Year)      # muss auf dem aktuellen Jahr stehen
    tag_4monC = (               # Tage 4 Monate vom aktuellen Monat zurück [Test0230]
        (122,122),(122,122),(120,121),(120,121),(119,120),(122,122),
        (121,121),(122,122),(122,122),(122,122),(122,122),(121,121)
    )
    tag_4mon = int(tag_4monC[a.Month][a.LYear])


    # Einstellungen zur Log-Ausgabe
    show_detail = [
        0,                      # (0) Details nach init / nur wenn 6 = 0
        0,                      # (1) Details bei dem Setzen / nur wenn 6 = 0
        0,                      # (2) Details bei den Additionen / nur wenn 6 = 0
        0,                      # (3) print Testdaten im Log
        0,                      # (4) print Testdaten am Ende
        0,                      # (5) Detail Date/Time / nur wenn 6 = 0
        0,                      # (6) Ergebnis im Log ausgeben / Fehlermeldungen kommen immer
    ]

 

Testumgebung  Initalisierung - Beschreibung

Source
Der eigentliche Testablauf ist grundsätzlich das Hauptprogramm der zu testenten Programmdatei. Damit dieses nur ausgefürht wird, wenn es direkt unter Python ausgeführt wird, habe wir die Bendingung [if __name__=='__main__':]. Darunter wird dann unser Test ausgeführt.
Wir beginnen mit einigen Imports
  • import os  --> verwenden wir für Systemkommandos. In unserem Falle später zum Löschen der Konsole.
  • from pdvm_util import lockedWritten, multiChar, p_print, t_p_t --> verwenden wir in der Formatierung und dem Log der Tests.
  • import pdvm_datetime_test  --> enthält das Wörterbuch mit den eigentlichen Test. Test werden separat beschrieben.
Nun die Testvorbereitungen:
  • der Variablen tests wird die  Testtabelle zugewiesen
  • über einen try / except wird die Konsole leer gemacht. Kommando unterscheiden sich für Windows und Unix.
  • in die Variable a wird ein Pdvm_DateTime Objekt initalisiert. Dieses beinhaltet dann im Standard schon die Standardsprache und man kann dann das Objekt in der Folge gleich weiter nutzen.
  • die Variable linel (=70) bekommt die Länge der Darstellung im Test-Log.
  • mit [print(multiChar("=",linel,1))] schreiben wir eine Linie aus '=' mit einem CR vor der Augabe (1)
  • mit [print(lockedWritten(transkateone('general','OutTestProt', a.language)))] schreiben wir eine gesperrte Überschrift. Diese wird mit der Übersetzung aus dem 'OutTestProt' in der jeweiligen Standrdsprache ausgegeben.
  • mit [print(multiChar("=",linel,2))] schreiben wir eine Linie aus '=' mit einem CR nach der Ausgabe (2)
  • in der Variablen blank (= "----> ") haben wir einen konstanten Wert für bestimmte Darstellungen
  • die test_ist wird als Wörterbuch initalisiert. Hier werden die Testergebnisse und die erwarteten Testergebnisse abgelegt. Die Prüfung erfolgt dann am Ende.
  • mit [a.PdvmDateTime = a.PdvmDateTimeNow()] setzen wir in unserem Objekt den aktuellen Timestamp.
Grundlegende Einstellungen:
  • die Variable akt_year (= str(a.Year) bekommt das aktuelle Jahr
  • es werden nun vom aktuellen Monat zurück die Anzahl der Tage für 4 Monate berechnet. Dieses mithilfe einer Liste, dem aktuellen Monat und dem Merkmal Schaltjahr. Das Ergebnis steht dann in der Variablen tag_4mon und wird im Test 0230 verwendet.
  • Zur Ausgabe des Logs der Tests wurde die Liste show_datail geschaffen. Damit kann man dann die Test nachvollziehen und ggf. auch Fehler leicht identifizieren. Was immer ausgegeben wird, sind die Fehlermeldungen. Diese sind aber bei manchen Tests auch gewollt. Näheres bei den einzelnen Tests. Folgende Ausprägungen habe ich eingebaut:
    • 0  --> Details nach init / nur wenn 6 = 0
    • 1  --> Details bei dem Setzen / nur wenn 6 = 0
    • 2 --> Details bei den Additionen / nur wenn 6 = 0
    • 3 --> print Testdaten im Log
    • 4 --> print Testdaten am Ende
    • 5 --> Detail Date/Time / nur wenn 6 = 0
    • 6 --> Ergebnis im Log ausgeben / Fehlermeldungen kommen immer

tests_print()

Beschreibung
def tests_print (a, test_list, testname='ohne Parameter',
        fixValue=0, variValue=0, show_datail = [], show_mod=0):
    p_print(show_detail[6],  "--- get "+variValue)  
    exec('test_list[testname] = [testname, '+fixValue+', '+ variValue+']')
    if show_detail[3] : print(test_list[testname])
    if show_detail[6] == 1 : a.PrintFullProperties(show_detail[show_mod])
    p_print(show_detail[6],  multiChar("-",70,1))
    return a

tests_print() - Beschreibung

Source
Mit den tests_print() werden die einzelnen Tests durchgeführt und bei entsprechender Schalterstellung in show_detail ausgegeben. Besonders ist auf die Zeile "exec('test_list[testname] = [testname, '+fixValue+', '+ variValue+']')" hinzuweisen, die entsprechend den Parametern den eigentlichen Test ausführt. Da sich hier ggf. auf ein vorhandenes Objekt zugegriffen wird, muss diese Funktionalität innerhalb des eigentlichen Obkts befinden.

Die einzelnen Programmzeilen dürften in sich verständlich sein.

test_out()

Beschreibung
def test_out (a, test_pro, test_in):
    p_print(show_detail[6],  "--- set " +test_pro+ " = " + str(test_in))
    exec("a."+test_pro+" = " + test_in)
    return a
 

test_out() - Beschreibung

Source
Der test_out() weist über einen exec() einen Wert einem Objekt zu . Der Rest muss aus meiner Sicht verständlich sein.



    # Start des eigentlichen Testes
    # --------------------------------------------------------------------------------

    if show_detail[0] == 1:                             # ggf. Ausgabe der Eigenschaften
        p_print(show_detail[6], a.FullProperties() )
    if show_detail[6] == 1 : a.PrintFullProperties(show_detail[0])
    p_print(show_detail[6], multiChar("-",linel,0))

    p_print(show_detail[6],  a.FormCountry)
    a.FormCountry = 'deu'
    p_print(show_detail[6],  a.FormCountry)
    a.FormCountry = 'USA '
    p_print(show_detail[6],  a.FormCountry)
    a.FormCountry = ' eng '
    p_print(show_detail[6],  a.FormCountry)
    a.FormCountry = ' enl '                         # Fehlermeldung FormCountry = DIN
    p_print(show_detail[6],  a.FormCountry)

    fC = input('\n'+ transkateone('general', 'countryFDate', a.language) +': ')   # Eingabe FormCountry für den Test
    a = Pdvm_DateTime(fC)                           #   korrekter Test muss mit allen FormCountry
    la = a.language                                 # Sprache in kurze Veriable
    p_print(show_detail[6],  a.formCountry)         #   ok sein.

    # --------------------------------------------------------------------------------
    # Tests aus den Wörterbuch-Definitionen (pdvm_datetime_test,py)
    tfc = ('DIN', 'DEU', 'ENG', 'USA')
    for sts in tests:
        for tfcEle in tfc:
            if a.formCountry == tfcEle:
                erg = tests[sts][tfcEle]
                break
        a = test_out(a, tests[sts]['tset'], tests[sts]['tins'])
        tests_print(a, test_list, sts, erg, tests[sts]['tget'], show_detail, tests[sts]['tlog'])

    # Ende Test aus den Wörterbuch-Definitionen
    # --------------------------------------------------------------------------------

    # Besonderer Test in der Addition - direkt erstellt
    # --------------------------------------------------------------------------------
    p_print(show_detail[6],  "--- AddToPdvmDateTime  (1,2,3,4,5,6) ")
    p_print(show_detail[6],   t_p_t(la, 'Year')+', '+ t_p_t(la, 'Month')+', '+ t_p_t(la, 'Days')+', '+
        t_p_t(la, 'Hours')+', '+ t_p_t(la, 'Minutes')+', '+ t_p_t(la, 'Seconds'))
    p_print(show_detail[6],  multiChar("-",linel,0))
    b = Pdvm_DateTime(a.formCountry)
    b.PdvmDateTimeT = a.PdvmDateTimeT
    res = a.AddToPdvmDateTime(1,2,3,4,5,6)
    l = '8'
    p_print(show_detail[6],  transStringOne (la, 'general', 'addition', l)+": " + str(res))
    p_print(show_detail[6],  transStringOne (la, 'general', 'blank', l)+"  " + str(a.FormTimeStamp))
    p_print(show_detail[6],  transStringOne (la, 'general', 'origin', l)+": "+ str(b.PdvmDateTime))
    p_print(show_detail[6],  transStringOne (la, 'general', 'blank', l)+"  "  + str(b.FormTimeStamp) + "\n")

    t1 = b.PdvmDateTime
    p_print(show_detail[6],  "--- DiffToPdvmDateTime  von der Addition ")
    p_print(show_detail[6],   t_p_t(la, 'Year')+', '+ t_p_t(la, 'Month')+', '+ t_p_t(la, 'Days')+', '+
        t_p_t(la, 'Hours')+', '+ t_p_t(la, 'Minutes')+', '+ t_p_t(la, 'Seconds'))
    p_print(show_detail[6], multiChar("-",linel,0))
    res1 = b.DiffToPdvmDateTime(res)
    p_print(show_detail[6],  str(res1))
    # Differenz wird wieder addiert. Ergebnist muss gleich dem Eingang sein
    res2 = b.AddToPdvmDateTime(res1[0], res1[1], res1[2], res1[3], res1[4], res1[5])
    l = '32'
    p_print(show_detail[6],  transStringOne (la, 'general', 'ResAfterDiffAddition', l)+": " + str(res2))
    p_print(show_detail[6],  transStringOne (la, 'general', 'blank', l)+"  " + str(b.FormTimeStamp))

    p_print(show_detail[6],  multiChar("-",linel,2))

    p_print(show_detail[6],  "--- AddToPdvmDateTime  (-1,-2,-3,-4,-5,-6) ")
    p_print(show_detail[6],   t_p_t(la, 'Year')+', '+ t_p_t(la, 'Month')+', '+ t_p_t(la, 'Days')+', '+
        t_p_t(la, 'Hours')+', '+ t_p_t(la, 'Minutes')+', '+ t_p_t(la, 'Seconds'))
    p_print(show_detail[6], multiChar("-",linel,0))
    b = Pdvm_DateTime(a.formCountry)
    b.PdvmDateTimeT = a.PdvmDateTimeT
    res = a.AddToPdvmDateTime(-1,-2,-3,-4,-5,-6)
    l = '8'
    p_print(show_detail[6],  transStringOne (la, 'general', 'addition', l)+": " + str(res))
    p_print(show_detail[6],  transStringOne (la, 'general', 'blank', l)+"  " + str(a.FormTimeStamp))
    p_print(show_detail[6],  transStringOne (la, 'general', 'origin', l)+": "+ str(b.PdvmDateTime))
    p_print(show_detail[6],  transStringOne (la, 'general', 'blank', l)+"  "  + str(b.FormTimeStamp) + "\n")

    p_print(show_detail[6],  "--- DiffToPdvmDateTime  von der Addition ")
    p_print(show_detail[6],   t_p_t(la, 'Year')+', '+ t_p_t(la, 'Month')+', '+ t_p_t(la, 'Days')+', '+
        t_p_t(la, 'Hours')+', '+ t_p_t(la, 'Minutes')+', '+ t_p_t(la, 'Seconds'))
    p_print(show_detail[6],  multiChar("-",linel,0))
    res1 = b.DiffToPdvmDateTime(res)
    p_print(show_detail[6],  str(res1))
    # Differenz wird wieder addiert. Ergebnist muss gleich dem Eingang sein
    res2 = b.AddToPdvmDateTime(res1[0], res1[1], res1[2], res1[3], res1[4], res1[5])
    l = '32'
    p_print(show_detail[6],  transStringOne (la, 'general', 'ResAfterDiffAddition', l)+": " + str(res2))
    p_print(show_detail[6],  transStringOne (la, 'general', 'blank', l)+"  " + str(b.FormTimeStamp))

    # mit dem tests_print wird das Ergebnis in die allgemeine Prüfung einbezogen
    tests_print(a, test_list, 'Test_1010', 't1', 'res2', show_detail, 2)

    # Testet die Formatierte Ausgabe eines PdvmDateTime - wird immer ausgegeben
    print("\nT e s t  -- Form PdvmDateTime --> TimeStamp")
    print(multiChar("=",linel,0))
    l = '30'
    a.PdvmDateTime = getDateTimeNow()
    print(transStringOne (la, 'proptext', 'FormCountry', l)+" : "+ a.FormCountry)
    print(transStringOne (la, 'proptext', 'PdvmDateTimeNow', l)+" : "+ str(a.PdvmDateTime))
    print(transStringOne (la, 'proptext', 'FormTimeStamp', l)+" : "+ str(a.FormTimeStamp))
    print(transStringOne (la, 'proptext', 'TimeStamp', l)+" : "+ str(a.TimeStamp))
    print(transStringOne (la, 'proptext', 'Date', l)+" : "+ str(a.Date))
    print(transStringOne (la, 'proptext', 'Time', l)+" : "+ str(a.Time ))
    print(transStringOne (la, 'proptext', 'TimeShort', l)+" : "+ str(a.TimeShort))


    # Testausgabe - erfolgt nach den Einstellungen
    if show_detail[4] == 1:
        print(multiChar("=",linel,1))
        print(lockedWritten(transkateone('general','testEdition', a.language)))
        print(multiChar("=",linel,0))
        for test_d in test_list:
            print(test_list[test_d])
   
    print(multiChar("=",linel,1))
    print(lockedWritten(transkateone('general','testResult', a.language)))
    print(multiChar("=",linel,0))
    er = 0
    for test_d in test_list:
        if test_list[test_d][1] != test_list[test_d][2]:
            print(transkateone('general','diffIn', a.language)+" " + test_d + " -- " +
                str(test_list[test_d][1]) + " -- " + str(test_list[test_d][2]))
            er += 1
    if er > 0:
        print(str(er) + " "+ transkateone('general','diffExist', a.language))
    else:
        print(transkateone('general','noDiff', a.language)+" - Test OK")

Share by: