new <palya_nev>

• Leírás: Betölti a megadott pályát.

• Opciók: <palya_nev>: a pálya xml fájl elérési útvonala.

load <mentes_nev>

• Leírás: Betölti a megadott mentésnek megfelelő pályát, illetve játékállapotot.

• Opciók: <mentes_nev>: a mentés azonosítója.

save <mentes_nev>

• Leírás: Lementi az éppen betöltött pályát, illetve a jelenlegi játékállapotot. A pálya állapota szerializálva kerül mentésre.

• Opciók: <mentes_nev>: a mentés azonosítója.

stop

• Leírás: Szünetelteti az éppen futó játékot.

• Opciók: -

start

• Leírás: Folytatja a szüneteltetett játékot. Ilyenkor a játék folyamatosan szimulál, amíg a játék véget nem ér, vagy le nem szüneteltetjük.

• Opciók: -

exit

• Leírás: Kilép a játékból.

• Opciók: -

step <lepes_szam>

• Leírás: <lepes_szam> mennyiségű szimulációs lépést hajt végre.

• Opciók: <lepes_szam>: Ennyiszer hívja meg az időzítő step() metódusát - amely a szimulációs lépést végzi.

activate <node_azon>

• Leírás: Megváltoztatja az azonosítóval megadott Node állapotát, ha ez lehetséges.

• Opciók: <node_azon>: A Node-hoz tartozó azonosító (a pálya fájlban szereplő neve)

listNodes

• Leírás: Kilistázza a pályán található csomópontokat.

• Opciók: -

listTrains

• Leírás: Kilistázza a pályához tartozó vonatokat.

• Opciók: -

step <lepes_szam>

• Ütközés esetén: EXPLODE

• Vonat csomóponthoz érése: <train_azon> - <next_node>

• Utasok leszállása: <traincart_azon> UNLOAD

• Utasok felszállása: <traincart_azon> LOAD

• Pálya teljesítése: MAP_COMPLETED

activate <node_azon>

• Váltó esetén kiírja az aktív útvonalat: <node_azon> <aktiv_irany>

• Alagútszáj esetén: <node_azon> CONSTRUCTED/DESTROYED

listNodes

• Kilistázza a pályán található csomópontokat: <node_azon>

listTrains

• Kilistázza a pályához kapcsolódó vonatokat: <train_azon>

stop

• Sikeres végrehajtás esetén: STOP

start

• Sikeres végrehajtás esetén: START

new

• Sikeres létrehozás: MAP_CREATED

• Sikertelen létrehozás: ERROR_AT_MAPCREATION

save

• Sikeres végrehajtás esetén: MAP_SAVED

• Sikertelen végrehajtás esetén: ERROR_AT_MAPSAVING

load

• Sikeres beöltés: MAP_LOADED

• Sikertelen betöltés: ERROR_AT_MAPLOADING

• Felelősség

  • A vonatelemek és az állomások (Station, LoaderStation) rendelkeznek színnel. Ezt reprezentálja ez az osztály. A kocsik rendelkeznek egy isEmpty metódussal, amivel lekérdezhető, hogy az adott kocsi üres-e.

  • A Color egy enumeráció, ami tartalmazza a színeket.

• Felelősség

  • A pályán elhelyezett elemek helyzetét leíró osztály. A játék folytonosan van szimulálva, az elemek közötti távolság, az egyes kis időegységek alatt bekövetkezett elmozdulások számításában van szerepe. A szimulációs modell szerves részét képzi. (nem csak a grafikai megjelenéshez kapcsolódik)

• Attribútumok

  • -x: int

  • -y: int

• Metódusok

  • +Coordinate(x: int, y: int) - Konstruktor, megadott paraméterekkel létrehozza a korrdinátát

  • +getX() - Getter x koordinátához

  • +getY() - Getter y koordinátához

• Felelősség

  • Inicializálja a játékhoz szükséges objektumokat. Létrehozza a SimulationTimer és a MapManager objektumokat. Rajta keresztül állítható a játék állapota.

• Attribútumok

  • -timer: SimulationTimer - Szimulációs időzítő, a Game hozza létre.

  • -mapManager: MapManager - A Game hozza létre, pályák menedzseléséhez.

• Metódusok

  • +Main(args: string[]) - Létrehozza a SimulationTimer és a MapManager objektumokat.

  • +newGame(nextLevel: String):void - Megállítja a szumulációt, majd szól a MapManagernek, hogy hozzon létre egy új pályát, végül pedig elindítja azt.

  • +startGame(): void - Elindítja a szimulációt. A SimulationTimernek start üzenetet küld, aminek hatására elindul az időzítés.

  • +stopGame(): void - Megállítja a szimulációt. A SimulationTimernek stop üzenetet küld, aminek a hatására az időzítés megáll.

  • +resumeGame(): void - A játék előző állapota alapján dönt. Ha futott a játék akkor újra elindítja azt.

• Felelősség

  • Az ilyen típusú állomásokról az utasok felszállnak a felszállás szabályának megfelelő kocsiba.

• Ősosztályok

  • Station

• Attribútumok

  • -color: Color - Az állomás színe. Ilyen színű kocsikra szállhatnak fel az utasok az állomásról.

• Metódusok

  • +LoaderStation(color: Color) - Konstruktor. Beállítja az állomás színét.

• Felelősség

  • A pálya tartalmazza a mindenkori játékállást. A pályán találhatóak meg a vonatok és a csomópontok, illetve a pálya adminisztrációjához szükséges objektumok (Statistics, TrainScheduler).

• Attribútumok

  • -stat: Statistics - A játék közbeni statisztika. pl.: mennyi kocsi üres.

  • -trainList: List<Train> - A játékban részt vevő vonatok.

  • -nodeList: List<Node> - Adminisztrációs lista a csomópontokról.

  • -notifiableList: List<Notifiable> - Azok az objektumok találhatóak ebben a listában akik feliratkoztak az időzítőre (TrainScheduler, CollisisonCheck).

  • -trainScheduler: TrainScheduler - A vonatok elindításáért felelős objektum.

• Metódusok

  • +Map(): - Konstruktor

  • +subscribe(timer: SimulationTimer):void - A maphoz tartozó vonatok, TrainScheduler feliratkoztatása az időzítőre.

  • +addNode(n: Node):void - Csomópont hozzáadása a nodeListhez.

  • +addTrainList(t: List<Train>): void - Trainlist hozzáadása a pályához.

  • +addStatistics(s: Statisctics): void - Statisztika hozzáadása a pályához.

  • +addNotifiable(n: Notifiable): void - Hozzáad egy értesítendő objektumot a pályához.

  • +getTrainList(): List<Train> - Visszaadja a vonatokat

  • +activateNode(c: Coordinate): void - Megkeresi ahhoz a koordinátához legközelebb eső Node-ot (egy környezeten belül), amit kapott. Ezen meghívja az activate() függvényt, amire az adott node logkája végrehajtódik

• Felelősség

  • Ő végzi az I/O műveleteket. Létrehozza magát a pályát és feltölti a rajta lévő, és a hozzá kapcsolódó elemekkel.

• Metódusok

  • +MapBuilder(mapName: String): void - Konstruktor. Beállítja a felépíteni kívánt pálya nevét.

  • +buildMap(g: Game): Map - Létrehozza a pálya működéséhez szükséges összetevőket és elvégzi a fájl olvasás műveletet az adatok feldolgozásával.

• Felelősség

  • A pályák kezeléséért felelős. Képes menteni egy játékállást, betölteni egy korábban lementettet, vagy újat, és kezeli az ezzel járó feliratkoztatásokat (ld. subscription szekvencia). Tárolja a jelenlegi Map-ot.

• Attribútumok

  • -timer: SimualtionTimer - A MapManager ezen az attribútumon keresztül éri el az időzítőt.

  • -map: Map - A létrehozott pálya.

• Metódusok

  • +MapManager(timer: SimualtionTimer, g: Game): Konstruktor, amiben beállításra kerül az időzítő és a játék.

  • +newMap(mapName: String): void - Betölti a paraméterül kapott nevű pályát egy MapBuilder segítségével.

  • +saveMap(mapName: String): void - Lementi az aktuális játékállást a paraméterben kapott néven.

  • +loadMap(mapName: String): void - Betölt egy korábban lementett játékállást.

• Felelősség

  • A TrainPartok következő úticélját határozza meg. A csomópontok gráfot alkotnak.

• Attribútumok

  • -neighborNodeList: List<Node> - A szomszédos csomópontokat tárolja.

  • -lastTrain: Train - A csomóponttal utoljára kapcsolatba lépett vonat.

  • -pos: Coordinate - A Node helyzetét adja meg.

• Metódusok

  • +Node() - Konstruktor

  • +accept(te: TrainEngine): void - A csomópont irányítja a TrainEnginet a következő állomás felé, ha az létezik.

  • +accept(tc: TrainCart): void - A csomópont irányítja a TrainCartot a következő állomás felé, ha az létezik.

  • +accept(tc: TrainCoalWagon): void - A csomópont irányítja a TraiCoalWagont a következő állomás felé, ha az létezik.

  • route(): Node - Megnézi honnan jött az aktuális TrainPart, és a másik node felé irányítja, mint ahonnan jött.

  • +activate(): void - A felhaszáló ezzel tudja a node-hoz tartozó logikát aktiválni. Alapértelmezetten ugyan semmi nem történik, de a leszármazottak felüldefiniálják ezt.

  • checkForTrain(): boolean - Ellenörzi, hogy van-e a node-on vonat jelenleg.

  • A node minden parttal történt interakciónál megjegyzi, hogy mi volt a hozzá tartozó vonat. (lastTrain) Az ellenőrzésnél lekéri ennek a vonatnak az utolsó partját, és megnézi, annak a getNextNode() függvényével, hogy mi a következő célja. Ha nem a node saját maga, akkor már nincs rajta a vonat.

• Felelősség

  • Interfész. Felületet nyújt az időzítőre feliratkozni kívánó osztályok számára.

• Metódusok

  • +update(): boolean - Az időzítéskor meghívott metódus. A SimualtionTimer hívja meg a Notifiable-t megvalósító osztályoknak.

• Felelősség

  • A szimuláció időzítéséért felelős. Meghatározott időközönként értesíti a szimulációban részt vevő objektumokat.

• Metódusok

  • +SimualtionTimer() - Inicializálja az időzítőt.

  • +start(): void - Elindítja az időzítőt.

  • +stop(): void - Megállítja az időzítőt.

  • +addSubscriber(sub: Notifiable): void - Az ütemezni kívánt objektumokhoz adja a paraméterül kapott Notifiable interfészt megvalósító interfészt.

  • +deleteSubscription(): void Törli a feliratkozásokat.

  • +step(): void - Lépteti a szimunálcót. Egy szimulációs lépést hajt végre.

• Felelősség

  • Ezeken a speciális csomópontokon tud a felhasználó alagútszájakat építeni. A pályán maximum 2 alagútszáj lehet aktív, amiket alagút köt össze. Megépített alagútszájat le is lehet rombolni, ha nem tartózkodik az alagútban vonat.

• Ősosztályok

  • Node

• Attribútumok

  • -spList: List<SpecialPlace> - Az összes SpecialPlace-et tartalmazó lista.

• Metódusok

  • +SpecialPlace(spList: List<SpecialPlace>) - Konstruktor. Beállítja, hogy az összes SpecialPlace ismerje az összes többi SpecialPlacet.

  • +activate(): void Elvégzi az alagútszáj építéséhez köthető logikát, ha az lehetséges. Egy privát statikus változóban tárolódik, hogy mely szájak vannak felépítve a pályán (maximum 2 lehetséges). Ez alapján eldönti, hogy lehetséges-e. Alagútszáj lerombolásánál gondoskodik róla, hogy csak akkor lehessen lerombolni, ha az alagútban nem tartózkodik vonat.

• Felelősség

  • A vonat sebességét leíró osztály.

• Attribútumok

  • speed: int - A sebesség

• Metódusok

  • +Speed(speed:int) - Konstruktor

  • +getSpeed() - Getter a sebességhez

• Felelősség

  • Ezeken a helyeken tudnak leszállni az emberek a kocsiból, de csak akkor, ha az állomás színével megegyező az adott kocsi, és nincs előtte nem üres. Ha adott színű kocsiból több van egymás után, az összes kiürül.

• Ősosztályok

  • Node

• Attribútumok

  • -color: Color - Az állomás színe.

• Metódusok

  • +Station(color: Color) - Konstruktor. Beállítja az állomás színét.

• Felelősség

  • A játékról vezet statisztikát. A TrainPart-ok őt értesítik, ha felrobbantak vagy kiürültek.

• Attribútumok

  • -numberOfCarts: Integer - Az összes kocsi száma a pályán.

  • -emptyCarts: Integer - Üres kocsik száma.

  • -mapList: List<String> - Pályák hogyan következnek egymás után.

  • -currentLevel: String - Az aktuális szint.

  • -game: Game - Rajta keresztül módosítható a játék állapota. (pl. új játék indítása).

• Metódusok

  • +Statistics(g: Game) - Konstruktor. Beállítja a game attribútumot.

  • +trainExplode(): void - Train hívja amikor felrobban. Kiadja a pálya újraindítása parancsot.

  • +cartUnloaded(): void - Egy TrainPart hívja, amikor kiürült. Vizsgálja, hogy sikerült-e teljesíteni a pályát.

  • +cartLoaded(): void - Egy TrainPart hívja, amikor utasok szálltak fel rá.

• Felelősség

  • Egy kereszteződésben ezek segítségével állítható, merre szeretnénk, hogy a vonat továbbhaladjon. Ha a két irány, amelyek irányába állítható a váltó, egyikéből jön a vonat, mindig a harmadik irányba halad tovább. A váltó nem állítható, ha vonat tartózkodik rajta.

• Ősosztályok

  • Node

• Attribútumok

  • -rootNode: void - A váltó gyökércsomópontja, ahonnan az elágazás indul.

  • -activeNode: Node - A váltó aktív kimenete.

• Metódusok

  • route(): void - Meghatározza a vonat továbbhaladási irányát. Ha a vonat a root felől jön, akkor az aktív node felé irányíja, ha pedig a másik irányok valamelyikéből, akkor a root felé fog vezetni az irány.

  • +activate(): void - Elvégzi a váltó állításhoz szükséges logikát. Kiválasztja a haladási irányt, ha a nem tartozkódik rajta vonat.

• Felelősség

  • A vonat felrobbantásáért felelős, ekkor hívja a Statistics osztály figyelő függvényét. Tárolja a kocsikat, mozdonyt. Mozgatja saját magát.

• Interfészek

  • Notifiable

• Attribútumok

  • -trainPartList: List<TrainPart> - Tartalmazza, hogy milyen egységekből áll a vonat.

  • -trainList: List<Train> - Vonatok listája, ütközésvizsgálathoz.

  • -colorToUnload: Color - A következő színű kocsi, amit ki lehet üríteni.

  • -running: Boolean - A vonat a pályán van-e.

  • -stat: Statisctics - Statisztikát kezelő objektum.

• Metódusok

  • +Train(s: Staistics, trainList: List<Train>) - Konstruktor. Beállítja a statistics attribútumot.

  • +move(): void - Mozgatja a vonatelemeket.

  • +explode(): void - Felrobbantja a vonatot, megsemmisíti a vonatelemeket, triggereli Statistics-ot.

  • +isRunning(): boolean - Visszadja, hogy a vonat a pályán van-e már.

  • +addPart(p: TrainPart): void - Hozzáad egy kocsit a vonathoz.

  • +getColor(): Color - Visszaadja az utolsó nem üres vonatelem színét.

  • +startTrain(): void - Elindítja a vonatot.

  • +checkCollision(): void - Ütközés vizsgálata a vonatok között. A vonat minden TrainPart-ját összehasonlítja a az összes többi vonat TrainPart-jával. Minden szimulációs lépésben végrehajtódik.

  • +getPartList(): List<TrainPart> - Visszaadja a Train-hez tartozó TrainPartok listáját.

  • +update(): void - A Notifiable interfész megvalósításából származik. Ezen belül történik a mozgatás (move()) és az ütközésvizsgálat (checkCollision()) műveletek hívása.

• Felelősség

  • A vonat része a kocsi, utasokat szállít, meghatározott színe van.

• Ősosztályok

  • TrainPart

• Attribútumok

  • -color: Color - A kocsi színe.

  • -stat: Statistics - Statisztika a játékról.

  • -train: Train - Megadja melyik vonat része a kocsi.

• Metódusok

  • +TrainCart(t: Train, st: Statistics, color: Color) - Konstruktor, a Statistics osztályt ismeri, itt kapja meg. Beállításra kerül még, hogy melyik vonathoz tartozik.

  • +getColor(): Color - Visszaadja a kocsi színét.

  • +unload(): void - Kiüríti a kocsit. Ha szükséges beállítja semleges színűre és triggereli a Statistics osztály ürítéseket számláló függvényét.

  • +load(): void - A kocsiba új utasok szállnak fel. Triggerelni a Statistics osztály beszállásokat számontartó metódusát.

• Felelősség

  • Szeneskocsi, amit figyelmen kívül kell hagyni az utasok fel- és leszállásánál.

• Ősosztályok

  • TrainPart

• Attribútumok

• Metódusok

• Felelősség

  • A vonat része a mozdony, meghatározza a vonat sebességét. Ha több mozdony lenne, tetszőleges logika szerint lehetne vonat eredő sebességét számolni.

• Ősosztályok

  • TrainPart

• Attribútumok

  • -speed: Speed - A mozdony sebességét adja meg.

• Metódusok

  • +TrainEngine(t: Train, s: Speed) - Konstruktor, beállítja a sebességet.

  • +getSpeed(): Speed - Visszaadja a mozdony sebességét.

• Felelősség

  • Absztrakt bázisosztály vonatelemekhez. A vonatok TrainPartokból állnak, a vonatok mozgatása a TrainPartok mozgatására vezethetö vissza, ezért minden TrainPart mozgatja saját magát. Mozgatáskor érheti el a célpontjául szolgáló adott állomást, és visitor minta szerint meglátogatja, azaz triggereli a node-okat ha elért hozzájuk.

• Attribútumok

  • -nextNode: Node - Következő cél Node-ja, ahová tart.

  • -prevNode: Node - A Node, amit a TrainPart utoljára elhagyott.

  • -pos: Coordinate - A TrainPart helyzetét határozza meg.

  • -train: Train - A vonat, amihez a TrainPart tartozik.

• Metódusok

  • +TrainPart(t: Train) - Konstruktor, beállítja, hogy a TrainPart melyik vonathoz tartozik.

  • +move(): void - Mozgatja a TrainPartot. Absztrakt, a leszármazottak valósítják meg.

  • +setNextNode(n: Node): void - Beállítja a kapott Node-ot az adott kocsi következő céljának.

  • +getTrain(): Train - Visszaadja a Vonatot aminek a TrainPart a része.

  • +checkCollision(tp: TrainPart): Boolean - Megvizsgálja, hogy a paraméterül kapott másik trainParttal összeütközött-e.

  • +getPrevNode(): Node - Visszaadja, hogy melyik csomóponton volt utoljára a TrainPart.

  • +getNextNode(): Node - Visszaadja, hogy melyik csomópont felé halad a TrainPart.

  • +isEmpty(): Boolean - Visszaadja, hogy a kocsi üres-e.

• Felelősség

  • Vonatok indításának ütemezéséért felelős osztály. A SimulationTimer triggereli, ekkor ha szükséges indítja a következő vonatot.

• Interfészek

  • Notifiable

• Attribútumok

  • -trainList: List<Train> - Vonatok listája.

• Metódusok

  • +TrainScheduler(list: List<Train>) - Konstruktor, itt kapja meg a vonatok listáját, innen keres vonatot, amit tud indítani.

  • +update(): void Notifiable interfész megvalósítása, itt történik a vonatindítási logika.

• Leírás Vonatok ütközésének vizsgálata. Az ütközés sikeres lezajlásának vizsgálata. Az ütközés utáni műveletek végrehajtása. Két vonat játszik szerepet, egymással összeütköznek. Kereszteződés erre a legalkalmasabb, mivel tetszőlegesen alakítható. Konkrétan: (1,1) koordinátákon a vonatok ütközni fognak.

• Ellenőrzött funkcionalitás, várható hibahelyek
  Egy vonat kocsija összeüközik egy másik vonat kocsijával. Hiba lehet: Egymáshoz képest tetszőleges pozíciót felvett vonatok esete.

• Bemenet

  • User input

new utkozes
listTrains
step 2

-   *Pálya*

<level>
  <nodes>
      <node>
          <type>node</type>
          <name>node1</name>
          <position>
              <x>1</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node2</name>
          <position>
              <x>1</x>
              <y>2</y>
          </position>
          <neighbours>
              <neighbour_name>node1</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node3</name>
          <position>
              <x>0</x>
              <y>1</y>
          </position>
          <neighbours>
              <neighbour_name>node4</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node4</name>
          <position>
              <x>2</x>
              <y>1</y>
          </position>
          <neighbours>
              <neighbour_name>node3</neighbour_name>
          </neighbours>
      </node>
  </nodes>
  <trains>
      <train>
          <trainPart>
              <type>engine</type>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>0</startTime>
      </train>
      <train>
          <trainPart>
              <type>engine</type>
          </trainPart>
          <startNode>node3</startNode>
          <startTime>0</startTime>
      </train>
  </trains>
</level>

• Elvárt kimenet

MAP_CREATED
train1 train2
EXPLODE

• Leírás
  Egy vakvágányra futott vonat felrobbanása. A vonatot vakvágányra terelve, az valóban felrobban, a játék véget ér. A test 2 node-ból áll, node1-en kezd, majd átlép node2-re a vonat, következö lépés semmibe vezet, ezért fel kell robbanjon.

• Ellenőrzött funkcionalitás, várható hibahelyek

• Bemenet

  • User input

new vakvaganyra_futas
step 2

-   *Pálya*

<level>
    <nodes>
        <node>
            <type>node</type>
            <name>node1</name>
            <position>
                <x>0</x>
                <y>0</y>
            </position>
            <neighbours>
                <neighbour_name>node2</neighbour_name>
            </neighbours>
        </node>
        <node>
            <type>node</type>
            <name>node2</name>
            <position>
                <x>0</x>
                <y>1</y>
            </position>
            <neighbours>
                <neighbour_name>node1</neighbour_name>
            </neighbours>
        </node>
    </nodes>
    <trains>
        <train>
            <trainPart>
                <type>engine</type>
            </trainPart>
            <startNode>node1</startNode>
            <startTime>0</startTime>
        </train>
    </trains>
</level>

• Elvárt kimenet

MAP_CREATED
train1 node2
EXPLODE

• Leírás
  A váltó állapotát megváltoztatjuk, ezzel más irányba tereljük a vonatot. Teszteljük a váltás sikerességét és azt, hogy a váltás sikertelen lesz, ha a vonat a váltón tartózkodik.

• Ellenőrzött funkcionalitás, várható hibahelyek
  A teszt ellenőrzi, hogy a vonat a váltást követően a váltó által meghatározott irányban halad tovább továbbá, hogy a váltás meghíusul, amikor a vonat rajta tartózkodik. Hibát eredményezhet a váltás, a váltón tartózkodó vonat esetén.

• Bemenet

  • User input

new valto_mukodes
activate switch1
step 3
activate switch1

-   *Pálya*

<level>
  <nodes>
      <node>
          <type>node</type>
          <name>node1</name>
          <position>
              <x>1</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node2</name>
          <position>
              <x>2</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node1</neighbour_name>
              <neighbour_name>switch1</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>switch</type>
          <name>switch1</name>
          <position>
              <x>3</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
              <neighbour_name>node3</neighbour_name>
              <neighbour_name>node4</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node3</name>
          <position>
              <x>3</x>
              <y>1</y>
          </position>
          <neighbours>
              <neighbour_name>switch1</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node4</name>
          <position>
              <x>4</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>switch1</neighbour_name>
          </neighbours>
      </node>
  </nodes>
  <trains>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>0</startTime>
      </train>
  </trains>
</level>

• Elvárt kimenet

MAP_CREATED
switch1 node4
train node2
train switch1
train node4

• Leírás
  A tesztben az alagutak helyes működését vizsgáljuk. A felépített pályán található 3 alagútszáj, amiket egymás után aktiválunk, ezekből az első kettő lesz az aktív, mert csak 2 építhető fel. Miután az alagutat elirányítottuk az első alagútszájhoz megpróbáljuk lerombolni az alagutat, ami sikertelen lesz, mert tartózkodik benne vonat.

• Ellenőrzött funkcionalitás, várható hibahelyek
  Ellenőrzi, hogy a megengedett számú alagútszáj építhető fel és, hogy az alagút nem rombolható le, amíg vonat tartózkodik benne. Hiba lehet az alagútszáj lerombolásának vizsgálatánál, amikor az alagútban tartózkodik vonat.

• Bemenet

  • User input

new alagut_mukodes
activate specialPlace1
activate specialPlace2
activate specialPlace3  // Tesztelni, hogy nem lehet 3 aktív.
step 3
activate specialPlace1  // Rombolás próba

-   *Pálya*

<level>
  <nodes>
      <node>
          <type>node</type>
          <name>node1</name>
          <position>
              <x>1</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node2</name>
          <position>
              <x>2</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node1</neighbour_name>
              <neighbour_name>specialPlace1</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>specialPlace</type>
          <name>specialPlace1</name>
          <position>
              <x>3</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
              <neighbour_name>specialPlace2</neighbour_name>
              <neighbour_name>specialPlace3</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>specialPlace</type>
          <name>specialPlace2</name>
          <position>
              <x>3</x>
              <y>1</y>
          </position>
          <neighbours>
              <neighbour_name>specialPlace1</neighbour_name>
              <neighbour_name>specialPlace3</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>specialPlace</type>
          <name>specialPlace3</name>
          <position>
              <x>4</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>specialPlace1</neighbour_name>
              <neighbour_name>specialPlace2</neighbour_name>
          </neighbours>
      </node>
  </nodes>
  <trains>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>0</startTime>
      </train>
  </trains>
</level>

• Elvárt kimenet

MAP_CREATED
specialPlace1 CONSTRUCTED
specialPlace2 CONSTRUCTED
train1 node2
train1 specialPlace1
train1 specialPlace2

• Leírás
  Elindítunk egy vonatota, aminek az első zöld kocsijából leszállnak az utasok az első állomáson, majd a rá következő állomáson ebbe a kocsiba újra fel fognak szállni utasok. A két kocsira azért van szükség, hogy a játék ne érjen véget az első kocsi kiürülésével.

• Ellenőrzött funkcionalitás, várható hibahelyek
  Az utasok felszállását végző logika tesztelése. Az utsok csak az állomással megegyező színű a vonat elejétől nézve első üres kocsiba szállhatnak fel.

• Bemenet

  • User input

new utasok_felszallasa
step 3

-   *Pálya*

<level>
  <nodes>
      <node>
          <type>node</type>
          <name>node1</name>
          <position>
              <x>1</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>stationGreen</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>station</type>
          <name>stationGreen</name>
          <position>
              <x>2</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node1</neighbour_name>
              <neighbour_name>loaderStationGreen</neighbour_name>
          </neighbours>
          <color>GREEN</color>
      </node>
      <node>
          <type>loaderStation</type>
          <name>loaderStationGreen</name>
          <position>
              <x>3</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>stationGreen</neighbour_name>
              <neighbour_name>node2</neighbour_name>
          </neighbours>
          <color>GREEN</color>
      </node>
      <node>
          <type>node</type>
          <name>node2</name>
          <position>
              <x>4</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>loaderStationGreen</neighbour_name>
          </neighbours>
      </node>
  </nodes>
  <trains>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <trainPart>
              <type>trainCart</type>
              <color>GREEN</color>
          </trainPart>
          <trainPart>
              <type>trainCart</type>
              <color>BLUE</color>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>0</startTime>
      </train>
  </trains>
</level>

• Elvárt kimenet

MAP_CREATED
train1 stationGreen
trainCartGreen1 UNLOAD
train1 loaderStationGreen
trainCartGreen1 LOAD
train1 node2

• Leírás
  A pályán található egy piros állomás és egy piros és kék kocsiból álló vonat. A vonat az állomás irányába tart. Teszteljük, hogy a piros kocsiból leszállnak-e az utasok az állomáshoz érve.

• Ellenőrzött funkcionalitás, várható hibahelyek
  A teszt ellenőrzi, hogy az utasok leszálnnak-e a szabálynak megfelelően (A piros kocsiból leszállnak viszont a kékből nem.). Hiba lehet, hogy a leszállás nem történik meg.

• Bemenet

  • User input

new utasok_leszallasa
step 2

-   *Pálya*

<level>
  <nodes>
      <node>
          <type>node</type>
          <name>node1</name>
          <position>
              <x>1</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>stationRed</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>station</type>
          <name>stationRed</name>
          <position>
              <x>2</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node1</neighbour_name>
              <neighbour_name>node2</neighbour_name>
          </neighbours>
          <color>RED</color>
      </node>
      <node>
          <type>node</type>
          <name>node2</name>
          <position>
              <x>3</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>stationRed</neighbour_name>
          </neighbours>
      </node>
  </nodes>
  <trains>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <trainPart>
              <type>trainCart</type>
              <color>RED</color>
          </trainPart>
          <trainPart>
              <type>trainCart</type>
              <color>BLUE</color>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>0</startTime>
      </train>
  </trains>
</level>

• Elvárt kimenet

MAP_CREATED
train1 stationRed
traincartRed1 UNLOAD
train1 node2

• Leírás
  A pályán található egy piros és egy zöld állomás valamint egy vonat piros és zöld kocsikkal. A vonatot elindítjuk a pályán, amin érinteni fogja az állomásokat, ezzel sorban kiürülnek a kocsik, amikor mindegyik leszállás végbement a játékos teljesítette a pályát.

• Ellenőrzött funkcionalitás, várható hibahelyek
  Statistics osztály megfelelő működését vizsgálja. Feladatai közé tartozik az üres kocsik számának nyilvántartása és a felhasználó értesítése a játék megnyeréséről. A kocsi a kiürülés után értesíti a Statistics osztályt az eseményről. Hiba merülhet fel az értesítés során vagy a nyilvántartásban.

• Bemenet

  • User input

new jatek_megnyeres
step 3

-   *Pálya*

<level>
  <nodes>
      <node>
          <type>node</type>
          <name>node1</name>
          <position>
              <x>1</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>stationRed</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>station</type>
          <name>stationRed</name>
          <position>
              <x>2</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node1</neighbour_name>
              <neighbour_name>stationGreen</neighbour_name>
          </neighbours>
          <color>RED</color>
      </node>
      <node>
          <type>station</type>
          <name>stationGreen</name>
          <position>
              <x>2</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>stationRed</neighbour_name>
          </neighbours>
          <color>GREEN</color>
      </node>
  </nodes>
  <trains>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <trainPart>
              <type>trainCart</type>
              <color>RED</color>
          </trainPart>
          <trainPart>
              <type>trainCart</type>
              <color>GREEN</color>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>0</startTime>
      </train>
  </trains>
</level>

• Elvárt kimenet

MAP_CREATED
train1 stationRed
trainCartRed1 UNLOAD
train1 stationGreen
trainCartGreen1 UNLOAD
MAP_COMPLETED

• Leírás
  A több csomóponton átívelő vonatok megfelelően lesznek-e elirányítva. Adott 3 hosszú vonat, 4 node 1 váltó, úgy hogy egyszerre a váltó és egy másik node felett is lesz a vonat.

• Ellenőrzött funkcionalitás, várható hibahelyek
  Váltót ne lehessen állítani ha rajta van a vonat. Megfelelöen irányítsák a node-ok a vonatokat. Hiba lehet ha akkor is lehet váltani ha rajta van a vonat.

• Bemenet

  • User input

new hosszu
step 2
activate switch1
step 2

-   *Pálya*

<level>
      <nodes>
          <node>
              <type>node</type>
              <name>node1</name>
              <position>
                  <x>0</x>
                  <y>0</y>
              </position>
              <neighbours>
                  <neighbour_name>switch1</neighbour_name>
              </neighbours>
          </node>
          <node>
              <type>switch</type>
              <name>switch1</name>
              <position>
                  <x>1</x>
                  <y>0</y>
              </position>
              <neighbours>
                  <neighbour_name>node1</neighbour_name>
                  <neighbour_name>node2</neighbour_name>
                  <neighbour_name>node3</neighbour_name>
              </neighbours>
          </node>
          <node>
              <type>node</type>
              <name>node2</name>
              <position>
                  <x>2</x>
                  <y>0</y>
              </position>
              <neighbours>
                  <neighbour_name>switch1</neighbour_name>
                  <neighbour_name>node4</neighbour_name>
              </neighbours>
          </node>
          <node>
              <type>node</type>
              <name>node3</name>
              <position>
                  <x>1</x>
                  <y>1</y>
              </position>
              <neighbours>
                  <neighbour_name>switch1</neighbour_name>
              </neighbours>
          </node>
          <node>
              <type>node</type>
              <name>node4</name>
              <position>
                  <x>3</x>
                  <y>0</y>
              </position>
              <neighbours>
                  <neighbour_name>node2</neighbour_name>
              </neighbours>
          </node>
      </nodes>
      <trains>
          <train>
              <trainPart>
                  <type>engine</type>
              </trainPart>
              <trainPart>
                  <type>cart</type>
              </trainPart>
              <trainPart>
                  <type>cart</type>
              </trainPart>
              <startNode>node1</startNode>
              <startTime>0</startTime>
          </train>
      </trains>
</level>

• Elvárt kimenet

MAP_CREATED
train1 node1
train1 switch1
train1 node2
train1 node4

• Leírás
  A pályán két vonat indul el, különböző időkben, azonos belépési ponton. A vonatok az időkülönbség miatt nem fognak ütközni, a pályán haladnak. A pályán 4 csomópont található, amik között a vonatok haladni fognak.

• Ellenőrzött funkcionalitás, várható hibahelyek
  A teszt ellenőrzi a vonatok indításáért felelős logika működését. Hiba lehet a funkcionalitás nem megfelelő működése.

• Bemenet

  • User input

new vonatok_inditasa
step 6

-   *Pálya*

<level>
  <nodes>
      <node>
          <type>node</type>
          <name>node1</name>
          <position>
              <x>1</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node2</name>
          <position>
              <x>2</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node1</neighbour_name>
              <neighbour_name>node3</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node3</name>
          <position>
              <x>3</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
              <neighbour_name>node4</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node4</name>
          <position>
              <x>4</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node3</neighbour_name>
          </neighbours>
      </node>
  </nodes>
  <trains>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>3</startTime>
      </train>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>5</startTime>
      </train>
  </trains>
</level>

• Elvárt kimenet

MAP_CREATED
train1 node2
train1 node3
train2 node2
train1 node4
train2 node3

• Leírás
  A pályákat leíró XML fájlból olvassuk be a pályát. A teszthez készített pálya 3 csomópontból (2db node, 1db switch) és 2 vonatból áll. Minden egység betöltődését vizsgáljuk.

• Ellenőrzött funkcionalitás, várható hibahelyek
  A teszt ellenőrzi, hogy a pálya a megfelelő csomópontokkal és vonatokkal jött létre, nézi az összes egység létrejöttét. Hiba lehet, hogy nem minden csomópont vagy vonat töltődik be.

• Bemenet

  • User input

new palya_betoltese
listNodes
listTrains

-   *Pálya*

<level>
  <nodes>
      <node>
          <type>node</type>
          <name>node1</name>
          <position>
              <x>1</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node2</name>
          <position>
              <x>2</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node1</neighbour_name>
              <neighbour_name>switch1</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>switch</type>
          <name>switch1</name>
          <position>
              <x>3</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
          </neighbours>
      </node>
  </nodes>
  <trains>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>0</startTime>
      </train>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <startNode>node3</startNode>
          <startTime>0</startTime>
      </train>
  </trains>
</level>

• Elvárt kimenet

MAP_CREATED
node1, node2, switch1
train1, train2

• Leírás
  Játékállás mentése szerializálásból áll. Ellenörizni úgy lehet hogy lementjük a játékot, majd betöltjük, ahogy az a következö tesztesetnél is történik.

• Ellenőrzött funkcionalitás, várható hibahelyek
  Mentés sikeressége. Hiba lehet a file i/o esetén szokásosan elöfordulató hibák.

• Bemenet

  • User input

new jatekallas_mentes
step 1
save save1

-   *Pálya*

<level>
    <nodes>
        <node>
            <type>node</type>
            <name>node1</name>
            <position>
                <x>0</x>
                <y>0</y>
            </position>
            <neighbours>
                <neighbour_name>node2</neighbour_name>
            </neighbours>
        </node>
        <node>
            <type>node</type>
            <name>node2</name>
            <position>
                <x>1</x>
                <y>0</y>
            </position>
            <neighbours>
                <neighbour_name>node1</neighbour_name>
            </neighbours>
        </node>
    </nodes>
    <trains>
        <train>
            <trainPart>
                <type>engine</type>
            </trainPart>
            <startNode>node1</startNode>
            <startTime>0</startTime>
        </train>
    </trains>
</level>

• Elvárt kimenet

MAP_LOADED
train node1
MAP_SAVED

• Leírás
  A játékállás betöltődésének vizsgálatához először elindítunk egy pályát, futtatjuk a szimulációt, mentést hajtunk végre, majd betöltjük az előbb lementett játékállást és folyatjuk a szimulációt. Ellenőrizn tudjuk, hogy a játék abból a helyzetből folytatódik, ahol lementettük. A pályán találhatóak speciális helyes is, ezek állapota is betöltésre kerül.

• Ellenőrzött funkcionalitás, várható hibahelyek
  A teszt ellenőrzi, hogy egy korábban mentett állás betöltése helyesen működik és minden elem továbbra is létezik a pályán. Hibák lehetnek, hogy a vonat nem onnan folytatja a futását, ahol abbahagyta, ezen kívük az elemek betöltődésének a hiánya is hibát okoz.

• Bemenet

  • User input

new jatekallas_betoltes
activate specialPlace1
activate specialPlace2
step 2
save save1
load save1
listNodes
listTrains
step 1

-   *Pálya*

<level>
  <nodes>
      <node>
          <type>node</type>
          <name>node1</name>
          <position>
              <x>1</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>specialPlace1</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>specialPlace</type>
          <name>specialPlace1</name>
          <position>
              <x>2</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node1</neighbour_name>
              <neighbour_name>specialPlace2</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>specialPlace</type>
          <name>specialPlace2</name>
          <position>
              <x>3</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>node2</neighbour_name>
              <neighbour_name>specialPlace1</neighbour_name>
          </neighbours>
      </node>
      <node>
          <type>node</type>
          <name>node2</name>
          <position>
              <x>4</x>
              <y>0</y>
          </position>
          <neighbours>
              <neighbour_name>specialPlace2</neighbour_name>
          </neighbours>
      </node>
  </nodes>
  <trains>
      <train>
          <trainPart>
              <type>engine</type>
              <speed>1</speed>
          </trainPart>
          <startNode>node1</startNode>
          <startTime>3</startTime>
      </train>
   </trains>
</level>

• Elvárt kimenet

MAP_CREATED
specialPlace1 CONSTRUCTED
specialPlace2 CONSTRUCTED
train1 specialPlace1
train1 specialPlace2
MAP_SAVED
MAP_LOADED
node1, specialPlace1, specialPlace2, node2
train1
train1 node 2

• Leírás
  A vonatok ütközhetnek kereszteződésekben is. A teszt ennek a sikerességét vizsgálja. Ez a teszt megegyezik a legelsö, vonat ütközésre vonatkozó tesztesettel. Az vizsgálja ezt az esetet is.

A teszteket a tesztelő program szöveges bemenetként várja, ezeket előre elkészítve egy-egy szövegfájlban tároljuk.
A tesztelés ellenőrzése szövegösszehasonlításon alapul, ehhez az előre megírt teszteket futtatjuk, majd az összehasonlító programmal összevetjük őket egy előre elkészített szövegfájllal, amiben az elvárt kimenetet listázzuk. Ahol a két fájl között eltérés van, ott a tesztelt működés hibásnak bizonyul. A tesztelést ellenőrző programnak tehát két paramétere van, az első a teszt futása során kapott kimenet szövegfájl elérési útvonala, a második pedig az elvárt kimenet szövegfájl elérési útvonala.
A program a nem egyező sorokat kiírja a standard kimenetre (ha van ilyen), valamint kiírja, hogy hány sor nem egyezett meg az elvárt kimenettel. A tesztelés teljesen automatizálható parancssori szkripttel, amiben lefuttatjuk a teszteket, majd a kapott kimeneteket fájlba írva, azokat az összehasonlító programnak átadva ellenőrizzük az eredményt.