Blackboxtest- und Algorithmus-Übungsaufgabe „Gesamtnote und Bestehensregeln“

Blackboxtest- und Algorithmus-Übungsaufgabe “Gesamtnote und Bestehensregeln”

https://bildung.social/@oerinformatik/111523089116938885

https://oer-informatik.de/blackbox-testfall-uebung-berechnungihkabschluss

Blackbox-Test, Äquivalenzklassen, Grenzwertanalyse, Testfall, Testfalldokumentation, Bestehensregeln, Gewichteter Durchschnitt, Pseudocode, Algorithmus, Übungsaufgaben, Prüfungsvorbereitung

tl/dr; (ca. 26 min Lese- und Bearbeitungszeit): Übungsaufgaben zur Erstellung von Testfällen nach Blackbox-Systematik für eine Funktion, die aus den Einzelergebnissen die Abschlussnote nach den Bestehensregeln der Ausbildungsverordnung berechnet. Du bestimmst systematisch Äquivalenzklassen und Grenzwerte und formulierst abschließend den Algorithmus in Pseudocode [AI-Assisted]. (Zuletzt geändert am 29.10.2026)

Dieser Artikel ist Teil einer Artikelreihe über Blackbox-Tests: Blackbox-Testfälle erstellen / Leitfragen zur Blackbox-Testfallerstellung / Übung „Punkte im String“ / Übung „Klassengröße“ / Übung „Ganzzahliges Teilen“ / Übung „Abschlussnote“ / Übung „Verzinsung“

In dieser Übung leitest Du für eine Funktion, die die Abschlussnote nach den Bestehensregeln der Ausbildungsverordnung berechnet, Testfälle nach Blackbox-Systematik ab: mit Äquivalenzklassen und Grenzwerten. Anschließend entwirfst Du den Algorithmus der Funktion in Pseudocode. Das Vorgehen beschreibt der Artikel Blackbox-Testfälle erstellen.

Blackbox-Schema der Funktion abschlussnote(): sechs Einzelergebnisse gehen hinein, heraus kommt die Abschlussnote, 0 oder eine Exception (mit KI erstellt)

Hinweise zur Bearbeitung: Als FIA, FISY, FIDP, IKS oder IKD musst Du zur Teil-2-Prüfung Aufgaben auf Kernkompetenz-Ebene lösen können, das ist Aufgabe 2.1. Von FIA wird zusätzlich erwartet, dass ihnen Aufgaben auf Profilkompetenz-Ebene (Aufgabe 3.1) keine Probleme bereiten. Schreib Deine Lösung zuerst vollständig auf, bevor Du die Beispiellösung aufklappst. Andere Testfälle sind ebenfalls richtig, wenn sie die Blackbox-Systematik fachgerecht umsetzen.

Du möchtest eigene Aufgaben zum Üben von einem KI-Sprachmodell generieren lassen?

Kopiere den Text in ein KI-Sprachmodell Deiner Wahl und passe Kompetenzstufe, Anzahl, Bearbeitungszeit und Szenario bei Bedarf an. Wie die Aufgaben aufgebaut sind, beschreibt der Artikel Wie sind die Aufgaben aufgebaut?. Prüfe die Ergebnisse mit dem Lehrartikel: KI-Sprachmodelle machen Fehler.

Erstelle neue Übungsaufgaben zum Thema „Blackboxtest- und Algorithmus-
Übungsaufgabe "Gesamtnote und Bestehensregeln"“.

Bauplan: Halte Dich an Aufbau, Kompetenzstufen, Operatoren,
Anforderungsbereiche, Punkte und Zeitschätzung, die im Artikel
https://oer-informatik.de/aufgaben-aufbau beschrieben sind.

Fachliche Grundlage:
- https://oer-informatik.de/blackboxtests
- Stilbeispiel: https://oer-informatik.de/blackbox-testfall-uebung-berechnungihkabschluss

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Blackbox-Test
- Äquivalenzklassen
- Grenzwertanalyse
- Testfall
- Testfalldokumentation
- Bestehensregeln
- Gewichteter Durchschnitt
- Pseudocode
- Algorithmus

Kompetenzstufe: Kernkompetenz (alternativ: Basiskompetenz, Profilkompetenz, Expertise)
Anzahl: 1 Aufgabe mit Teilaufgaben
Bearbeitungszeit in Minuten ca.: <5 bis 30 min>
Szenario: eines der Szenarien aus dem Bauplan

Vorgehen:
1. Lies zuerst die verlinkten Artikel. Kannst Du keine Webseiten
   abrufen, sag mir das, statt zu raten.
2. Steht bei einer Angabe noch ein Platzhalter in <…>, frag mich
   zuerst danach. Richte Punkte und Zahl der Teilaufgaben nach der
   Bearbeitungszeit (ca. 0,9 min je Punkt).
3. Gib je Aufgabe Titel mit Kompetenzstufe, Ausgangssituation und
   Teilaufgaben mit Operator und Punktzahl aus, dazu die geschätzte
   Bearbeitungszeit.
4. Gib die Beispiellösungen mit Punkteverteilung erst aus, wenn ich
   danach frage.

Aufgabe 2.1: Testfälle für die Berechnung der Abschlussnote (Kernkompetenz)

Für eine Funktion, die die Abschlussnote von Fachinformatiker*innen der Fachrichtung Anwendungsentwicklung berechnet, sollen Blackbox-Tests entwickelt werden.

Die Funktion abschlussnote(note[]: HashMap): int soll die Note des Berufsabschlusses aus den Einzelergebnissen (Wertung von 0 bis 100 Punkten) berechnen. Die Einzelergebnisse werden in einer Hashmap (in Python: einem Dictionary) note übergeben und können über die in der Tabelle unten genannten Keys angesprochen werden (z. B. note["T2P"] = 84). Die Values (die Punkte der Teilleistungen) sind jeweils vom Typ int.

Nach gleichem Muster sind die Gewichtungen in einer Hashmap hinterlegt – diese ist global verfügbar und unveränderlich (z. B. gewichtung["PJ"] = 25).

Als Anforderungen sind gegeben:

  • Die Rückgabe der Funktion soll die gewichtete Durchschnittsnote sein (0 bis 100 Punkte), wenn die Prüfung bestanden wurde.

  • Die Funktion soll eine Exception werfen, wenn die Berechnung aufgrund ungültiger Eingaben/Werte nicht möglich ist.

  • Die Rückgabe soll der Wert 0 sein, wenn die Prüfung nicht bestanden wurde.

  • Die Bestehensregeln sind folgende1:

    • Im Gesamtergebnis (gewichteter Durchschnitt Teil 1 und Teil 2 zusammen) müssen mindestens 50 Punkte erreicht werden.

    • Im Ergebnis von Teil 2 (gewichteter Durchschnitt von allem, bis auf die erste Prüfungsleistung) müssen mindestens 50 Punkte erreicht werden.

    • In mindestens drei Prüfungsbereichen von Teil 2 müssen jeweils mindestens 50 Punkte erreicht werden.

    • In keinem Prüfungsbereich von Teil 2 dürfen weniger als 30 Punkte erreicht werden.

Vereinfachend werden in dieser Übung Projektarbeit (PJ) und Präsentation/Fachgespräch (FG) als eigene Prüfungsbereiche behandelt; in der Verordnung bilden sie zusammen einen Prüfungsbereich.

Ein beispielhaftes Prüfungsergebnis besteht aus den folgenden Prüfungsleistungen:

Prüfungsleistungen mit Keys, Gewichtung und Beispielergebnis
Prüfungsbestandteil Key in Hashmap Gewichtung Beispiel Punkte
Teil 1 Einrichten eines IT-gestützten Arbeitsplatzes T1 20% 56
Teil 2 Planen eines Softwareprodukts T2P 10% 84
Entwicklung und Umsetzung von Algorithmen T2A 10% 60
Wirtschafts- und Sozialkunde T2W 10% 81
Projektarbeit PJ 25% 78
Präsentation und Fachgespräch FG 25% 85
Gesamtergebnis: 74

Ein vereinfachter Funktionsaufruf kann für die Testfälle mit JSON-Notation erfolgen, für obiges Beispiel also:

abschlussnote({"T1":56, "T2P":84, "T2A":60, "T2W":81, "PJ":78, "FG":85})

Die Funktion abschlussnote(note[]: HashMap): int soll fachgerecht mit Testfällen nach Blackbox-Systematik versehen werden.

a) Bereite eine fachgerechte tabellarische Testfalldokumentation vor und trage darin vier Testfälle (zwei je Blackbox-Systematik) mit allen Daten ein, die bereits bekannt sind (die anderen Zellen können vorbereitet, aber leer bleiben). Nenne auch die zugrunde gelegte Systematik. (6 Punkte)

Typ Name Eingabewerte Erwartetes
Ergebnis		 Tats.
Erg.(*)		 Bestanden?(*)
GW Knapp bestanden abschlussnote({"T1":50, "T2P":50, "T2A":50, "T2W":50, "PJ":50, "FG":50}) 50
GW Beste Note abschlussnote({"T1":100, "T2P":100, "T2A":100, "T2W":100, "PJ":100, "FG":100}) 100
ÄQ Bestanden abschlussnote({"T1":65, "T2P":65, "T2A":65, "T2W":65, "PJ":65, "FG":65}) 65
ÄQ Nicht bestanden
wg. Note 6		 abschlussnote({"T1":65, "T2P":65, "T2A":25, "T2W":65, "PJ":65, "FG":65}) 0

(*) Wird später ausgefüllt. GW: Grenzwert, ÄQ: Äquivalenzklasse.

b) Vervollständige die Testsuite, indem Du Grenzwerttests für alle extremen Notenwerte ergänzt. Bilde darüber hinaus Äquivalenzklassen für jede Art, die Prüfung nicht zu bestehen. Ergänze auch ungültige Eingaben gemäß Spezifikation. Fasse dabei gleichartige Testfälle in der Testfalldokumentation zusammen und nenne jeweils die zugrunde gelegte Systematik. (12 Punkte)

Allein über die Kombinatorik sind hier viele Testfälle möglich. Um effizient zu testen, sollte jedoch jede Bestehens-Anforderung einmal erfüllt und einmal (isoliert) nicht erfüllt sein. Kombinationen aus unterschiedlichen Nicht-Bestehens-Kriterien sollten vermieden werden (jedenfalls so lange die einzelnen Kriterien noch nicht isoliert getestet wurden).

Typ Name Eingabewerte Erwartetes
Ergebnis		 Tats.
Erg.(*)		 Best-
anden?(*)
GW1 Schlechteste Note abschlussnote({"T1":0, "T2P":0, "T2A":0, "T2W":0, "PJ":0, "FG":0}) 0
GW2 Alles knapp
nicht bestanden		 abschlussnote({"T1":49, "T2P":49, "T2A":49, "T2W":49, "PJ":49, "FG":49}) 0
GW3 Alles knapp
bestanden		 abschlussnote({"T1":50, "T2P":50, "T2A":50, "T2W":50, "PJ":50, "FG":50}) 50
GW4 Beste Note abschlussnote({"T1":100, "T2P":100, "T2A":100, "T2W":100, "PJ":100, "FG":100}) 100
ÄQ1 Alles bestanden abschlussnote({"T1":65, "T2P":65, "T2A":65, "T2W":65, "PJ":65, "FG":65}) 65
ÄQ2 Alles nicht
bestanden		 abschlussnote({"T1":40, "T2P":40, "T2A":40, "T2W":40, "PJ":40, "FG":40}) 0
ÄQ3 Nicht bestanden
wg. Note 6		 abschlussnote({"T1":85, "T2P":25, "T2A":85, "T2W":85, "PJ":85, "FG":85}) 0
ÄQ4 Nicht bestanden
Gesamtergebnis <50		 abschlussnote({"T1":0, "T2P":60, "T2A":60, "T2W":60, "PJ":60, "FG":60}) 0
ÄQ5 Nicht bestanden
Teil 2 <50		 abschlussnote({"T1":90, "T2P":55, "T2A":55, "T2W":55, "PJ":55, "FG":35}) 0
ÄQ6 Nicht bestanden
nicht mind. 3× T2 >=50		 abschlussnote({"T1":90, "T2P":48, "T2A":48, "T2W":48, "PJ":55, "FG":55}) 0
ÄQ7 Knapp bestanden
trotz Note 5 in T2		 abschlussnote({"T1":85, "T2P":31, "T2A":53, "T2W":53, "PJ":53, "FG":53}) 57
ÄQ8 Knapp bestanden
trotz T1 0 P.		 abschlussnote({"T1":0, "T2P":65, "T2A":65, "T2W":65, "PJ":65, "FG":65}) 52
ÄQ9 Ungültig
Einzelnote über 100 P.		 abschlussnote({"T1":65, "T2P":65, "T2A":65, "T2W":65, "PJ":65, "FG":101}) Exception
ÄQ10 Ungültig
Einzelnote kleiner 0		 abschlussnote({"T1":75, "T2P":65, "T2A":65, "T2W":65, "PJ":-1, "FG":65}) Exception
ÄQ11 Ungültig
Einzelnote leer		 abschlussnote({"T1":85, "T2P":65, "T2A":65, "T2W":, "PJ":65, "FG":65}) Exception
ÄQ12 Ungültig
Einzelnote Gleitkomma		 abschlussnote({"T1":85, "T2P":65, "T2A":65.5, "T2W":65, "PJ":65, "FG":65}) Exception
ÄQ13 Ungültig
Einzelnote fehlt		 abschlussnote({"T1":85, "T2A":65, "T2W":65, "PJ":65, "FG":65}) Exception
GW5 Ungültig
leere Hashmap		 abschlussnote({}) Exception

(*) Wird später ausgefüllt.

Die Rundung ist in der Spezifikation nicht festgelegt. Die erwarteten Ergebnisse gehen von kaufmännischem Runden auf ganze Punkte aus (z. B. ÄQ7: 57,2 → 57). Eine solche Lücke solltest Du vor dem Testen mit den Auftraggebenden klären.

Aufgabe 3.1: Algorithmus für die Berechnung der Abschlussnote (Profilkompetenz)

Die Funktion abschlussnote(), für die Du in Aufgabe 2.1 Blackbox-Testfälle erstellt hast, soll nun als Algorithmus entworfen werden. Setze die Anforderungen aus Aufgabe 2.1 zur Berechnung der Note und zu den Bestehensregeln in Pseudocode um. (10 Punkte)

abschlussnote(note[]: HashMap): int

Ein möglicher Algorithmus (die Gewichtung gewichtung[key] ist in Prozent angegeben und ergibt zusammen 100):

Funktion abschlussnote(note: HashMap): integer
  keys := ["T1", "T2P", "T2A", "T2W", "PJ", "FG"]
  wenn laenge(note) <> laenge(keys) dann
    wirf Exception("Anzahl der Einzelergebnisse falsch")
  Ende wenn
  summeGesamt := 0
  summeTeil2 := 0
  gewichtTeil2 := 0
  anzahlAusreichend := 0
  ungenuegend := false
  für jedes key in keys
    wenn nicht note.enthaelt(key) dann
      wirf Exception("Einzelergebnis fehlt: " + key)
    Ende wenn
    punkte := note[key]
    wenn nicht istGanzzahl(punkte) oder punkte < 0 oder punkte > 100 dann
      wirf Exception("Ungültiges Einzelergebnis: " + key)
    Ende wenn
    summeGesamt := summeGesamt + punkte * gewichtung[key]
    wenn key <> "T1" dann
      summeTeil2 := summeTeil2 + punkte * gewichtung[key]
      gewichtTeil2 := gewichtTeil2 + gewichtung[key]
      wenn punkte >= 50 dann
        anzahlAusreichend := anzahlAusreichend + 1
      Ende wenn
      wenn punkte < 30 dann
        ungenuegend := true
      Ende wenn
    Ende wenn
  Ende für
  gesamt := summeGesamt / 100
  ergebnisTeil2 := summeTeil2 / gewichtTeil2
  wenn gesamt < 50 oder ergebnisTeil2 < 50 oder anzahlAusreichend < 3 oder ungenuegend dann
    Rückgabe 0
  Ende wenn
  Rückgabe runde(gesamt)
Ende abschlussnote

Bewertungsvorschlag: Eingaben prüfen (Anzahl, Vollständigkeit, Wertebereich) 3 Punkte, gewichtete Ergebnisse für das Gesamtergebnis und Teil 2 berechnen 3 Punkte, die vier Bestehensregeln umsetzen 3 Punkte, Rückgabe 1 Punkt. Andere Lösungswege sind richtig, wenn sie alle Testfälle aus Aufgabe 2.1 erfüllen.

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Blackboxtest- und Algorithmus-Übungsaufgabe ”Gesamtnote und Bestehensregeln”” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/blackbox-testfall-uebung-berechnungihkabschluss veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/qs/testen. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 29.10.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]

  1. Siehe Verordnung über die Berufsausbildung zum Fachinformatiker und zur Fachinformatikerin, § 16↩︎

Kommentare gerne per Mastodon, Verbesserungsvorschläge per gitlab issue (siehe oben). Beitrag teilen:

Tags:

You may also like...