def erhalteAlleEventsAm(conn, datum=date.today()):
from Event import Event
from Zeit import Zeit
from EventManager import EventManager as EM
"""
Query all rows in the tasks table
:param conn: the Connection object
:return:
"""
datum = datum.toordinal()
cur = conn.cursor()
cur.execute('''SELECT * FROM events WHERE dateOrdinal=?''', (datum, ))
rows = cur.fetchall()
events = []
for row in rows:
zeitStart = Zeit(0, 0)
zeitEnde = Zeit(0, 0)
zeitStart.vonMinuten(row[2])
zeitEnde.vonMinuten(row[3])
event = Event(zeitStart, zeitEnde)
event.id = row[0]
event.text = row[1]
event.startzeit.datum = date.fromordinal(row[4])
event.endzeit.datum = event.startzeit.datum
zeitStart.event = event
zeitEnde.event = event
if row[5] == 1: event.istPause = True
if row[5] == 2:
EM.mittagspause = event
else:
events.append(event)
return events
def test_subtraktion(self):
zeit1 = Zeit(14, 35)
zeit2 = Zeit(2, 0)
zeit3 = Zeit(3, 40)
zeit4 = Zeit(12, 30)
self.assertEqual(str(zeit1 - zeit2), f"Zeit 12:35 am {zeit1.erhalteDatum()}")
self.assertEqual(str(zeit1 - zeit3), f"Zeit 10:55 am {zeit1.erhalteDatum()}")
def test_addition(self):
zeit1 = Zeit(14, 35)
zeit2 = Zeit(2, 0)
zeit3 = Zeit(3, 30)
zeit4 = Zeit(12, 30)
self.assertEqual(str(zeit1 + zeit2), f"Zeit 16:35 am {zeit1.erhalteDatum()}")
self.assertEqual(str(zeit1 + zeit3), f"Zeit 18:05 am {zeit1.erhalteDatum()}")
def test_groesser_gleich(self):
zeit1 = Zeit(14, 35)
zeit2 = Zeit(2, 0)
zeit4 = Zeit(12, 30)
self.assertTrue(zeit2 >= zeit2)
self.assertFalse(zeit4 >= zeit1)
self.assertTrue(zeit1 >= zeit2)
def test_kleiner(self):
zeit1 = Zeit(14, 35)
zeit2 = Zeit(2, 0)
zeit3 = Zeit(12, 30)
self.assertTrue(zeit2 < zeit1)
self.assertTrue(zeit3 < zeit1)
self.assertFalse(zeit3 < zeit2)
self.assertFalse(zeit2 < zeit2)
def test_initialisierung(self):
zeit1 = Zeit(14, 0)
event1 = Event(zeit1, Zeit(15, 0))
self.assertEqual(str(event1),
f"Start 14:00 Ende 15:00 am {zeit1.erhalteDatum()}")
self.assertEqual(
str(zeit1),
f"Zeit 14:00 am {zeit1.erhalteDatum()} zu Event Start 14:00 Ende 15:00 am {zeit1.erhalteDatum()}"
)
def test_groesser(self):
zeit1 = Zeit(14, 35)
zeit2 = Zeit(2, 0)
zeit3 = Zeit(2, 0)
zeit4 = Zeit(12, 30)
self.assertTrue(zeit1 > zeit2)
self.assertTrue(zeit1 > zeit4)
self.assertFalse(zeit2 > zeit3)
self.assertFalse(zeit4 > zeit1)
def test_zeichnen(self):
from TimeManager import TimeManager as TM
from Event import Event
SM.init()
testEvent = Event(Zeit(10, 00), TM.mittagspauseStart, False,
"testevent")
testNachmEvent = Event(Zeit(16, 00), Zeit(18, 30), False, "testNachm")
testEvent2 = Event(Zeit(9, 30), Zeit(11, 30), False, "test")
testEvent.zeichne()
testNachmEvent.zeichne()
testEvent2.zeichne()
SM.run()
def test_schneiden(self):
event1 = Event(Zeit(14, 0), Zeit(15, 0))
event2 = Event(Zeit(14, 30), Zeit(15, 30))
event3 = Event(Zeit(15, 0), Zeit(16, 0))
event4 = Event(Zeit(15, 30), Zeit(16, 30))
event5 = Event(Zeit(11, 30), Zeit(16, 30))
self.assertTrue(event1.schneiden(event2))
self.assertFalse(event1.schneiden(event4))
self.assertFalse(event1.schneiden(event3))
self.assertFalse(event3.schneiden(event1))
self.assertTrue(event3.schneiden(event2))
self.assertTrue(event5.schneiden(event4))
self.assertTrue(event2.schneiden(event2))
def test_addEvent(self):
EM.events = []
SM.init()
event1 = Event(Zeit(14, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(17, 00))
event3 = Event(Zeit(14, 45), Zeit(17, 00))
lsg1 = Event(Zeit(15, 0), Zeit(16, 30))
EM.addEvent(event1)
EM.addEvent(event2)
# hinzufügen ohne Überlapp
self.assertEqual(
str(EM.events[0]),
f"Start 14:30 Ende 15:00 am {EM.events[0].startzeit.erhalteDatum()}"
)
self.assertEqual(
str(EM.events[1]),
f"Start 16:30 Ende 17:00 am {EM.events[1].startzeit.erhalteDatum()}"
)
# mit überlapp
EM.addEvent(event3)
self.assertTrue(EM.hatEvent(lsg1))
self.assertTrue(EM.hatEvent(event1))
self.assertTrue(EM.hatEvent(event2))
def pixelZuZeit(y):
from TimeManager import TimeManager
from Zeit import Zeit
zeit = Zeit(0, 0, TimeManager.aktuellesDatum.datum)
zeitspannePix = ScreenManager.canvasHeight / 5 * 4 #nutzbarer Bereich
aufstehLiniePix = ScreenManager.canvasHeight / 10
#rechne in Minuten
ratio = zeitspannePix / (TimeManager.schlafenszeit -
TimeManager.aufstehzeit).zeitInMinuten()
zeitInMinuten = (y - aufstehLiniePix
) / ratio + TimeManager.aufstehzeit.zeitInMinuten()
zeit.vonMinuten(zeitInMinuten)
return zeit
def test_Zeit_von_String(self):
test1 = "13"
test2 = "25"
test3 = "14:30"
test4 = "15:312"
zeit1 = Zeit.fromString(test1)
zeit2 = Zeit.fromString(test2)
zeit3 = Zeit.fromString(test3)
zeit4 = Zeit.fromString(test4)
lsg1 = f"Zeit 13:00 am {zeit1.erhalteDatum()}"
lsg3 = f"Zeit 14:30 am {zeit3.erhalteDatum()}"
self.assertEqual(str(zeit1), lsg1)
self.assertIsNone(zeit2, "Zeit richtig verworfen")
self.assertEqual(str(zeit3), lsg3)
self.assertIsNone(zeit4, "Zeit richtig verworfen")
def Test_zeitZuPixel(self):
SM.canvasHeight = 500
TM.aufstehzeit = Zeit(10, 0)
TM.schlafenszeit = Zeit(18, 0)
zeit1 = TM.aufstehzeit
zeit2 = Zeit(11, 0)
lsg1 = 50 # erster Valider Wert
lsg2 = 100
y1 = SM.zeitZuPixel(zeit1)
y2 = SM.zeitZuPixel(zeit2)
self.assertEqual(y1, lsg1)
self.assertEqual(y2, lsg2)
def Test_pixelZuZeit(self):
SM.canvasHeight = 500
TM.aufstehzeit = Zeit(10, 0)
TM.schlafenszeit = Zeit(18, 0)
y1 = 50 # erster Valider Wert
y2 = 100
lsg1 = TM.aufstehzeit
lsg2 = Zeit(11, 0)
zeit1 = SM.pixelZuZeit(y1)
zeit2 = SM.pixelZuZeit(y2)
self.assertEqual(str(zeit1), str(lsg1))
self.assertEqual(str(zeit2), str(lsg2))
def test_circa2(self):
TM.genauigkeit = Zeit(0, 5)
zeit1 = Zeit(14,35,date(2020,1,1))
zeit2 = Zeit(14,35)
zeit3 = Zeit(14,33, date(2020,1,1))
self.assertFalse(zeit1.circa(zeit2))
self.assertTrue(zeit1.circa(zeit3))
def erhalteAlleZeiten(conn):
from Zeit import Zeit
"""
Query all rows in the tasks table
:param conn: the Connection object
:return:
"""
cur = conn.cursor()
cur.execute("SELECT * FROM zeiten")
rows = cur.fetchall()
zeiten = []
for row in rows:
zeit = Zeit(0, 0)
zeit.id = row[0]
zeit.vonMinuten(row[1])
zeiten.append(zeit)
return zeiten
def test_beruehren(self):
event1 = Event(Zeit(14, 0), Zeit(15, 0))
event2 = Event(Zeit(14, 30), Zeit(15, 30))
event3 = Event(Zeit(15, 0), Zeit(16, 0))
event4 = Event(Zeit(17, 0), Zeit(18, 0))
self.assertTrue(event1.beruehrt(event2))
self.assertTrue(event1.beruehrt(event3))
self.assertFalse(event1.beruehrt(event4))
self.assertTrue(event3.beruehrt(event1))
self.assertFalse(event4.beruehrt(event2))
def erhalteAlleZeitenAm(conn, datum=date.today()):
from Zeit import Zeit
"""
Query all rows in the tasks table
:param conn: the Connection object
:return:
"""
cur = conn.cursor()
cur.execute('''SELECT * FROM zeiten WHERE dateOrdinal = ?''',
(datum.toordinal(), ))
rows = cur.fetchall()
zeiten = []
for row in rows:
zeit = Zeit(0, 0, datum)
zeit.id = row[0]
zeit.vonMinuten(row[1])
zeiten.append(zeit)
return zeiten
def Test_pixelZeit(self):
SM.canvasHeight = 600
z = Zeit(12, 0)
zeit1 = SM.pixelZuZeit(500)
y1 = SM.zeitZuPixel(zeit1)
y2 = SM.zeitZuPixel(z)
zeit2 = SM.pixelZuZeit(y2)
self.assertEqual(500, y1)
self.assertEqual(z, zeit2)
def ladeZeiten():
from EventManager import EventManager as EM
from Event import Event
if not Db.initialisiert: Db.init()
zeiten = Db.erhalteAlleZeitenAm(Db.conn,
TimeManager.aktuellesDatum.datum)
print(
f"Datum in Ordianl {TimeManager.aktuellesDatum.datum.toordinal()}")
if len(zeiten) == 4:
TimeManager.zeiten = zeiten
TimeManager.aufstehzeit = TimeManager.zeiten[0]
TimeManager.mittagspauseStart = TimeManager.zeiten[1]
TimeManager.mittagspauseEnde = TimeManager.zeiten[2]
TimeManager.schlafenszeit = TimeManager.zeiten[3]
EM.mittagspause = Event(TimeManager.mittagspauseStart,
TimeManager.mittagspauseEnde, False,
"Mittagspause")
TimeManager.mittagspauseStart.event = EM.mittagspause
TimeManager.mittagspauseEnde.event = EM.mittagspause
else:
TimeManager.aufstehzeit = Zeit(8, 0,
TimeManager.aktuellesDatum.datum)
TimeManager.aktuellesDatum = Zeit(0, 0,
TimeManager.aktuellesDatum.datum)
TimeManager.mittagspauseStart = Zeit(
12, 30, TimeManager.aktuellesDatum.datum)
TimeManager.mittagspauseEnde = Zeit(
13, 30, TimeManager.aktuellesDatum.datum)
TimeManager.schlafenszeit = Zeit(23, 00,
TimeManager.aktuellesDatum.datum)
TimeManager.zeiten = (TimeManager.aufstehzeit,
TimeManager.mittagspauseStart,
TimeManager.mittagspauseEnde,
TimeManager.schlafenszeit)
EM.mittagspause = Event(TimeManager.mittagspauseStart,
TimeManager.mittagspauseEnde, False,
"Mittagspause")
TimeManager.mittagspauseStart.event = EM.mittagspause
TimeManager.mittagspauseEnde.event = EM.mittagspause
for zeit in TimeManager.zeiten:
zeit.zeichne()
def test_findeEvent(self):
EM.events = []
event1 = Event(Zeit(14, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(17, 00))
event3 = Event(Zeit(14, 45), Zeit(17, 00))
EM.addEvent(event1)
EM.addEvent(event2)
EM.addEvent(event3)
lsg1 = EM.findeEvent(Zeit(14, 45))
lsg2 = EM.findeEvent(Zeit(15, 00))
lsg3 = EM.findeEvent(Zeit(16, 30))
self.assertEqual(event1, lsg1)
self.assertEqual(event3, lsg2)
self.assertEqual(event2, lsg3)
def test_findeEvents(self):
EM.events = []
event1 = Event(Zeit(14, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(17, 00))
event3 = Event(Zeit(14, 45), Zeit(17, 00))
EM.addEvent(event1)
EM.addEvent(event2)
EM.addEvent(event3)
lsg = EM.findeEvents(Zeit(15, 0), Zeit(20, 0))
self.assertTrue(event2 in lsg and event3 in lsg)
self.assertFalse(event1 in lsg)
def test_removeElement(self):
EM.events = []
event1 = Event(Zeit(11, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(22, 00))
event3 = Event(Zeit(14, 45), Zeit(17, 00))
EM.addEvent(event1)
EM.addEvent(event2)
EM.addEvent(event3)
EM.removeEvent(event1)
self.assertIsNone(EM.findeEvent(Zeit(12, 0)))
self.assertEqual(len(EM.events), 2)
def zeichneHintergrund():
from TimeManager import TimeManager as TM
from EventManager import EventManager as EM
from Zeit import Zeit
#passe Mittagspause an
EM.mittagspause.verstecke()
TM.mittagspauseStart.event = EM.mittagspause
TM.mittagspauseEnde.event = EM.mittagspause
EM.mittagspause.startzeit = TM.mittagspauseStart
EM.mittagspause.endzeit = TM.mittagspauseEnde
EM.mittagspause.zeichne()
#zeichne wichtige Linien
for zeit in TM.zeiten:
zeit.entferne()
zeit.zeichne()
# passe Genauigkeit an die neue Skalierung an, runde danach auf schöne 5 Min Intervalle
TM.genauigkeit.vonMinuten(
(TM.schlafenszeit - TM.aufstehzeit).zeitInMinuten() /
TM.genauigkeitsfaktor)
TM.genauigkeit = TM.genauigkeit.runde(Zeit(0, 5, None))
# Inputanzeige und Datumanzeige korrekt verschieben
ScreenManager.canvas.coords(ScreenManager.inputAnzeige, 20,
int(ScreenManager.canvasHeight - 20))
ScreenManager.canvas.coords(
ScreenManager.datumAnzeige,
int(ScreenManager.canvasWidth / 2),
20,
)
ScreenManager.canvas.coords(
ScreenManager.jahrAnzeige,
int(ScreenManager.canvasWidth / 2),
40,
)
def select(zeit, exakt=False):
from TimeManager import TimeManager
from EventManager import EventManager
from Event import Event
from Zeit import Zeit
if exakt:
genauigkeit = Zeit(0, 0, None)
else:
genauigkeit = TimeManager.genauigkeit
gefundeneZeit = TimeManager.findeZeit(zeit, genauigkeit)
if gefundeneZeit is not None:
gefundeneZeit.zeichneMarkiert()
ScreenManager.ausgewaehlt = gefundeneZeit
ScreenManager.ausgewaehlt.fokusiere()
return
event = EventManager.findeEvent(zeit, genauigkeit)
if event is None:
zeit = zeit.runde()
# ändere das Datum des neuen Events auf das Datum von akutellesDatum im TimeManager
#zeit.datum = TimeManager.aktuellesDatum.datum
if TimeManager.aufstehzeit <= zeit < TimeManager.schlafenszeit:
neuesEvent = EventManager.addEvent(
Event(zeit, zeit + EventManager.eventLaenge))
ScreenManager.ausgewaehlt = neuesEvent
else:
return
else:
if zeit.circa(event.startzeit, genauigkeit):
ScreenManager.ausgewaehlt = event.startzeit
elif zeit.circa(event.endzeit, genauigkeit):
ScreenManager.ausgewaehlt = event.endzeit
else:
ScreenManager.ausgewaehlt = event
ScreenManager.ausgewaehlt.zeichneMarkiert()
ScreenManager.ausgewaehlt.fokusiere()
def test_verschiebeEventUm(self):
EM.events = []
TM.schlafenszeit = Zeit(23, 0)
EM.mittagspause = Event(Zeit(0, 0), Zeit(0, 0))
event1 = Event(Zeit(11, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(22, 00))
event3 = Event(Zeit(15, 00), Zeit(16, 30))
lsg1 = Event(Zeit(17, 30), Zeit(23, 00))
lsg2 = Event(Zeit(18, 30), Zeit(23, 00))
lsg3 = Event(Zeit(12, 30), Zeit(16, 00)) #event1 3. Verschiebung
lsg4 = Event(Zeit(16, 0), Zeit(17, 30)) #event3 3.V
lsg5 = Event(Zeit(18, 30), Zeit(23, 00)) #event2 3.V
EM.addEvent(event1)
EM.addEvent(event2)
EM.addEvent(event3)
EM.verschiebeEventUm(event2, Zeit(1, 0))
self.assertEqual(str(EM.findeEvent(Zeit(18, 00))), str(lsg1))
self.assertEqual(lsg1, event2)
EM.verschiebeEventUm(event2,
Zeit(1,
0)) #verschiebe in die Schlafenszeit hinein
self.assertEqual(str(EM.findeEvent(Zeit(19, 00))), str(lsg2))
self.assertEqual(lsg2, event2)
EM.verschiebeEventUm(event1,
Zeit(1, 0)) #verschiebe mit anhängenden Events
self.assertEqual(str(EM.findeEvent(Zeit(13, 0))),
str(lsg3)) #event1 verschoben
self.assertEqual(str(event1), str(lsg3))
self.assertEqual(str(EM.findeEvent(Zeit(17, 0))),
str(lsg4)) # event3 verschoben
self.assertEqual(str(event3), str(lsg4))
self.assertEqual(str(EM.findeEvent(Zeit(20, 0))),
str(lsg5)) # event2 verschoben
self.assertEqual(event2, lsg5)
def keyInput(keyEvent):
from Zeit import Zeit
from TimeManager import TimeManager
from EventManager import EventManager
from Event import Event
if keyEvent.keysym == "Return":
#Parse different input
zeit = Zeit.fromString(ScreenManager.inputText)
zeit1, zeit2 = Zeit.intervalFromString(ScreenManager.inputText)
datum = Zeit.dateFromString(ScreenManager.inputText)
#reset the input Text
ScreenManager.inputText = ""
if zeit is not None:
zeit.datum = TimeManager.aktuellesDatum.datum
ScreenManager.select(zeit, True)
elif zeit1 is not None and zeit2 is not None:
zeit1.datum = zeit2.datum = TimeManager.aktuellesDatum.datum
if (TimeManager.aufstehzeit <= zeit1 <
TimeManager.mittagspauseStart
and zeit1 < zeit2 <= TimeManager.mittagspauseStart
) or (TimeManager.mittagspauseEnde <= zeit1 <
TimeManager.schlafenszeit
and zeit1 < zeit2 <= TimeManager.schlafenszeit):
neuesEvent = EventManager.addEvent(Event(zeit1, zeit2))
ScreenManager.ausgewaehlt = neuesEvent
ScreenManager.ausgewaehlt.zeichneMarkiert()
ScreenManager.ausgewaehlt.fokusiere()
else:
ScreenManager.inputText = "Invalid Input for Interval"
elif datum is not None:
# speichere
EventManager.speichereEvents()
TimeManager.speichereZeiten()
#verschiebe
TimeManager.aktuellesDatum.datum = datum.datum
# lösche die Zeiten und Events von vorherigen Tag vom Canvas
for event in EventManager.events:
event.verstecke()
for zeit in TimeManager.zeiten:
zeit.entferne()
EventManager.mittagspause.verstecke()
# Lade und zeichne neu
TimeManager.ladeZeiten()
EventManager.ladeEvents()
ScreenManager.zeichneHintergrund()
ScreenManager.canvas.itemconfig(
ScreenManager.datumAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumLang())
ScreenManager.canvas.itemconfig(
ScreenManager.jahrAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumJahr())
elif keyEvent.keysym == "BackSpace":
ScreenManager.inputText = ScreenManager.inputText[:-1]
elif keyEvent.keysym == "Delete":
pass
elif keyEvent.keysym == "Right":
#speichere
EventManager.speichereEvents()
TimeManager.speichereZeiten()
TimeManager.aktuellesDatum.verschiebeAufMorgen()
# lösche die Zeiten und Events von vorherigen Tag vom Canvas
for event in EventManager.events:
event.verstecke()
for zeit in TimeManager.zeiten:
zeit.entferne()
EventManager.mittagspause.verstecke()
#Lade und zeichne neu
TimeManager.ladeZeiten()
ScreenManager.zeichneHintergrund()
EventManager.ladeEvents()
ScreenManager.canvas.itemconfig(
ScreenManager.datumAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumLang())
ScreenManager.canvas.itemconfig(
ScreenManager.jahrAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumJahr())
elif keyEvent.keysym == "Left":
#speichere
EventManager.speichereEvents()
TimeManager.speichereZeiten()
TimeManager.aktuellesDatum.verschiebeAufGestern()
#lösche die Zeiten und Events von vorherigen Tag vom Canvas
for event in EventManager.events:
event.verstecke()
for zeit in TimeManager.zeiten:
zeit.entferne()
EventManager.mittagspause.verstecke()
#lade und zeichne neu
TimeManager.ladeZeiten()
ScreenManager.zeichneHintergrund()
EventManager.ladeEvents()
ScreenManager.canvas.itemconfig(
ScreenManager.datumAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumLang())
ScreenManager.canvas.itemconfig(
ScreenManager.jahrAnzeige,
text=TimeManager.aktuellesDatum.erhalteDatumJahr())
else:
ScreenManager.inputText += keyEvent.char
ScreenManager.canvas.itemconfig(
ScreenManager.inputAnzeige,
text=f"Input: {ScreenManager.inputText}")
def test_verbindung(self):
EM.events = []
event1 = Event(Zeit(14, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(17, 00))
event3 = Event(Zeit(14, 45), Zeit(17, 00))
event4 = Event(Zeit(17, 00), Zeit(18, 00))
event5 = Event(Zeit(11, 00), Zeit(14, 30))
lsg1 = Event(Zeit(15, 0), Zeit(16, 30))
EM.addEvent(event1)
EM.addEvent(event2)
EM.addEvent(event3)
EM.addEvent(event4)
EM.addEvent(event5)
#for event in EM.events:
# print(f"{event}")
self.assertEqual(event1.eventDanach, lsg1)
self.assertEqual(event2.eventDavor, lsg1)
self.assertEqual(event2.eventDanach, event4)
self.assertEqual(event5.eventDanach, event1)
def test_addPause2(self):
EM.events = []
TM.schlafenszeit = Zeit(23, 0)
EM.mittagspause = Event(Zeit(0, 0), Zeit(0, 0))
event1 = Event(Zeit(11, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(22, 00))
EM.addEvent(event1)
EM.addEvent(event2)
lsg1 = Event(Zeit(11, 30), Zeit(13, 00))
pause = Event(Zeit(13, 0), Zeit(15, 0))
lsg2 = Event(Zeit(15, 0), Zeit(17, 00))
lsg3 = Event(Zeit(17, 00), Zeit(22, 30))
EM.addPause(Zeit(13, 00), Zeit(2, 0))
self.assertEqual(str(event1), str(lsg1))
self.assertEqual(str(EM.findeEvent(Zeit(13, 5))), str(pause))
self.assertTrue(EM.findeEvent(Zeit(13, 5)).istPause)
self.assertEqual(str(EM.findeEvent(Zeit(15, 20))), str(lsg2))
self.assertEqual(str(event2), str(lsg3))
def test_verschiebeZeitNach(self):
EM.events = []
TM.schlafenszeit = Zeit(23, 0)
EM.mittagspause = Event(Zeit(0, 0), Zeit(0, 0))
event1 = Event(Zeit(11, 30), Zeit(15, 00))
event2 = Event(Zeit(16, 30), Zeit(22, 00))
lsg1 = Event(Zeit(11, 30), Zeit(16, 30))
lsg2 = Event(Zeit(11, 30), Zeit(17, 00))
lsg3 = Event(Zeit(17, 00), Zeit(22, 00))
EM.addEvent(event1)
EM.addEvent(event2)
EM.verschiebeZeitNach(event1, False, Zeit(16, 30))
self.assertEqual(str(event1.eventDanach), str(event2))
self.assertEqual(str(event2.eventDavor), str(event1))
self.assertEqual(str(event1), str(lsg1))
EM.verschiebeZeitNach(event1, False, Zeit(17, 0))
self.assertEqual(str(event1.eventDanach), str(event2))
self.assertEqual(str(event2.eventDavor), str(event1))
self.assertEqual(str(event1), str(lsg2))
self.assertEqual(str(event2), str(lsg3))
