Programowanie Obiektowe - Laboratorium 7

Definiowania klas abstrakcyjnych, metod abstrakcyjnych oraz wymuszania implementacji konkretnych zachowań w klasach pochodnych.

Jako deweloper zaawansowanego silnika graficznego dla projektantów wnętrz, musisz stworzyć solidny fundament pod system rysowania obiektów dwuwymiarowych. Każdy element w Twojej aplikacji, od prostego koła po skomplikowany wielokąt, musi posiadać ściśle zdefiniowany zestaw operacji matematycznych do obliczania zajmowanej powierzchni. Twoim zadaniem jest opracowanie klasy abstrakcyjnej, która posłuży jako niezmienny kontrakt dla wszystkich przyszłych figur geometrycznych wprowadzanych do systemu. Dzięki zastosowaniu modułu ABC, wymusisz na innych programistach zaimplementowanie specyficznej logiki obliczeniowej dla każdego nowego kształtu, zapobiegając powstawaniu niekompletnych obiektów. Klasa bazowa powinna pełnić rolę czystego szablonu, uniemożliwiając tworzenie instancji, które nie mają jasno określonej formy i wymiarów. Takie podejście gwarantuje, że silnik obliczeniowy będzie mógł bezpiecznie operować na dowolnej kolekcji figur, wywołując ujednolicony zestaw metod. Jest to doskonały przykład wykorzystania abstrakcji do zarządzania złożonością w dużych projektach inżynierskich. Poprawnie zrealizowane zadanie pokaże Ci, jak budować przewidywalne i stabilne struktury danych w profesjonalnym oprogramowaniu.

• Zaimportuj klasy ABC oraz dekorator abstractmethod z modułu abc.
• Zdefiniuj klasę abstrakcyjną Figura, która będzie służyć jako wzorzec dla kształtów geometrycznych.
• Oznacz metodę oblicz_pole() jako metodę abstrakcyjną przy użyciu dekoratora @abstractmethod.
• Skonstruuj klasę pochodną Kolo, implementującą specyficzną logikę obliczania pola powierzchni.
• Stwórz klasę Prostokat jako kolejną konkretną realizację nadrzędnego szablonu figury.
• Udowodnij, że nie można utworzyć instancji samej klasy Figura, przechwytując błąd TypeError.
• Sprawdź, co się stanie, jeśli klasa pochodna nie zaimplementuje wymaganej metody oblicz_pole().
• Wywołaj obliczenia na obiektach kół i prostokątów, demonstrując spójność interfejsu.

• Zaimportuj ABC oraz abstractmethod bezpośrednio z wbudowanego modułu abc.
• Definiując class Figura(ABC):, wskazujesz systemowi, że klasa jest czysto abstrakcyjna.
• Metoda oblicz_pole(self) nie powinna posiadać żadnego kodu – użyj instrukcji pass.
• W klasie Kolo(Figura) musisz obowiązkowo dostarczyć definicję metody oblicz_pole.
• Pamiętaj, że zapomnienie o implementacji metody abstrakcyjnej uniemożliwi Ci stworzenie obiektu podklasy.
• Spróbuj celowo wywołać instrukcję f = Figura() i zaobserwuj wygenerowany błąd TypeError.
• Wykorzystaj moduł math w celu uzyskania precyzyjnej wartości liczby Pi (math.pi).
• To zadanie uczy, jak tworzyć bezpieczne "kontrakty" dla innych programistów pracujących w Twoim zespole.
• Przetestuj, czy po dodaniu nowej metody abstrakcyjnej do bazy, wszystkie klasy pochodne zgłoszą błąd.
• Zauważ, że klasy abstrakcyjne pomagają wcześnie wykrywać braki projektowe w architekturze całego systemu.

• Wyjaśnij szczegółowo, dlaczego Python kategorycznie uniemożliwia utworzenie instancji klasy Figura posiadającej metody abstrakcyjne.
• Opisz potencjalne skutki wywołania metody abstrakcyjnej na obiekcie, gdyby jego utworzenie było technicznie dopuszczone przez interpreter.
• Omów strategiczne zalety stosowania modułu abc w skutecznym zapobieganiu tworzeniu niekompletnych i niespójnych obiektów technicznych.
• Przeanalizuj rolę klasy abstrakcyjnej jako nadrzędnego "kontraktu", który wymusza na deweloperach zachowanie konkretnej struktury podklas.
• Zastanów się i uzasadnij, w jaki sposób wykorzystanie ABC ułatwia bardzo wczesne wykrywanie błędów projektowych w złożonych systemach.
• Wnioskuj o przydatności abstrakcji w profesjonalnym zarządzaniu rosnącą złożonością dużych projektów inżynierskich i architektonicznych.
• Porównaj klasę abstrakcyjną do zwykłej klasy bazowej, która posiada jedynie puste metody (bez użycia dekoratora @abstractmethod).
• Opisz, w jaki sposób wbudowany moduł math wspiera precyzję obliczeń geometrycznych w konkretnych implementacjach figur.
• Sprawdź doświadczalnie, czy dodanie nowej metody abstrakcyjnej do bazy wymusza natychmiastową aktualizację kodu wszystkich jej klas pochodnych.

Łączenia dekoratorów @property oraz @abstractmethod w celu wymuszania istnienia atrybutów logicznych w klasach potomnych.

Podczas projektowania kompleksowych systemów symulacji ruchu drogowego, kluczowe jest zapewnienie, aby każdy obiekt poruszający się po mapie posiadał precyzyjnie określone parametry fizyczne. Twoim celem jest stworzenie hierarchii klas dla pojazdów, która wymusza na deweloperach nie tylko implementację metod akcji, ale również posiadanie konkretnych atrybutów konfiguracyjnych. Musisz wykorzystać połączenie dekoratorów właściwości i abstrakcji, aby upewnić się, że każdy model samochodu czy roweru posiada jawnie zadeklarowaną prędkość maksymalną. Takie podejście eliminuje ryzyko zapomnienia o kluczowych danych technicznych podczas rozbudowy systemu o nowe typy środków transportu. Klasa bazowa staje się dzięki temu rygorystycznym strażnikiem spójności danych, odrzucając wszelkie próby stworzenia niekompletnych obiektów już na etapie inicjalizacji. System wymuszania właściwości jest znacznie bezpieczniejszy od zwykłych metod pobierających, ponieważ integruje się bezpośrednio z mechanizmem dostępu do atrybutów instancji. Twoje rozwiązanie pokaże, jak zaawansowane techniki dekorowania kodu mogą wspierać utrzymanie wysokiej jakości architektury w dynamicznie rozwijających się projektach. Gotowy moduł będzie stanowił wzorcowy przykład nowoczesnego projektowania opartego na kontraktach atrybutowych.

• Zadeklaruj klasę abstrakcyjną Pojazd, wykorzystując moduł ABC.
• Zaimplementuj abstrakcyjną właściwość predkosc_max przy użyciu dekoratorów @property oraz @abstractmethod.
• Zwróć uwagę na poprawną kolejność dekoratorów, aby Python prawidłowo zinterpretował atrybut.
• Utwórz klasę Samochod i dostarcz konkretną implementację właściwości predkosc_max (getter).
• Spróbuj zdefiniować klasę Motocykl bez tej właściwości i zweryfikuj błąd podczas próby tworzenia obiektu.
• Dodaj do klasy bazowej drugą właściwość abstrakcyjną, np. liczba_kol, i uaktualnij podklasy.
• Przetestuj odczyt właściwości na poprawnie zaimplementowanych obiektach pojazdów.
• Wyjaśnij, dlaczego wymuszanie właściwości (properties) jest bezpieczniejsze od zwykłych metod zwracających dane.

• Zastosuj dekoratory w ścisłej parze: @property oraz @abstractmethod dla atrybutu.
• Ważne: dekorator @property musi znajdować się wyżej (dalej od definicji metody) niż abstrakcja.
• W klasie pochodnej zaimplementuj konkretny getter: @property def predkosc_max(self): return 200.
• Możesz również zwracać wartość z atrybutu instancji chronionego, np.: return self._v_max.
• Spróbuj stworzyć klasę pochodną bez tej właściwości i zobacz, jak Python zablokuje jej inicjalizację.
• Właściwości abstrakcyjne są idealne do definiowania "stałych" parametrów specyficznych dla każdej podklasy.
• Przetestuj odczyt właściwości s.predkosc_max tak, jakby był to zupełnie zwyczajny atrybut obiektu.
• To zadanie pokazuje, jak wymuszać w kodzie strukturę danych, a nie tylko konkretne zachowania (metody).
• Zauważ, że @abstractmethod może być z powodzeniem stosowane również do setterów i deleterów.
• Wyjaśnij, dlaczego mechanizm property skutecznie chroni przed przypadkową modyfikacją stałych modelu.

• Wyjaśnij kluczowe korzyści wynikające z wymuszania istnienia właściwości (properties) zamiast stosowania zwykłych metod pobierających dane (getters).
• Opisz poprawną kolejność stosowania dekoratorów @property oraz @abstractmethod i uzasadnij tę kolejność technicznie.
• Omów mechanizm rygorystycznego pilnowania spójności danych modelu fizycznego już na etapie definiowania struktury klasy.
• Przeanalizuj sposób implementacji konkretnego gettera w podklasie dla atrybutu, który został zadeklarowany jako abstrakcyjny u rodzica.
• Zastanów się i opisz, jak właściwości abstrakcyjne skutecznie chronią stałe parametry modelu przed ich przypadkową modyfikacją.
• Wnioskuj o znacznie większym bezpieczeństwie kodu, który integruje się bezpośrednio z wbudowanym mechanizmem dostępu do atrybutów instancji.
• Porównaj elastyczność właściwości abstrakcyjnych do tradycyjnych pól danych ustawianych na sztywno w konstruktorze __init__.
• Opisz zachowanie interpretera Pythona przy próbie inicjalizacji klasy, która pominęła implementację wymaganej właściwości abstrakcyjnej.
• Sprawdź, czy dekorator @abstractmethod może być z powodzeniem stosowany również do wymuszania obecności setterów w podklasach.

Projektowania architektury opartej na interfejsach oraz programowania "do interfejsu, a nie do implementacji".

Współczesne aplikacje biznesowe muszą komunikować się z użytkownikami za pomocą wielu różnorodnych kanałów, takich jak poczta elektroniczna, wiadomości tekstowe czy komunikatory internetowe. Twoim zadaniem jest zaprojektowanie uniwersalnego interfejsu powiadomień, który pozwoli na bezproblemową wymianę usług dostawczych bez ingerencji w główną logikę programu. Musisz stworzyć czysto abstrakcyjną klasę, definiującą standardową metodę wysyłki, która stanie się wspólnym mianownikiem dla wszystkich implementacji technicznych. Takie podejście promuje zasadę programowania "do interfejsu", co w praktyce oznacza, że reszta Twojego systemu nie musi wiedzieć, czy wiadomość trafi do skrzynki e-mail, czy na telefon klienta. Dzięki temu, dodanie nowej metody komunikacji w przyszłości sprowadzi się jedynie do napisania jednej podklasy spełniającej ustalony kontrakt. System staje się niezwykle elastyczny i odporny na zmiany w zewnętrznych bibliotekach API dostawców usług. Twoje rozwiązanie pokaże potęgę polimorfizmu opartego na abstrakcji w rozwiązywaniu rzeczywistych problemów integracyjnych. Gotowy projekt będzie dowodem na to, że dobrze przemyślana architektura jest kluczem do skalowalności nowoczesnych systemów informatycznych.

• Zaprojektuj interfejs Powiadomienie jako klasę czysto abstrakcyjną (bez kodu w metodach).
• Zdefiniuj w interfejsie metodę abstrakcyjną wyslij(tekst), która musi zostać zaimplementowana przez dostawców.
• Skonstruuj konkretną usługę EmailService realizującą wysyłkę wiadomości drogą elektroniczną.
• Opracuj usługę SmsService jako alternatywny kanał komunikacji spełniający ten sam kontrakt.
• Napisz uniwersalną funkcję wyslij_do_wszystkich(), która operuje wyłącznie na obiektach typu Powiadomienie.
• Przekaż do funkcji listę różnych usług i zaobserwuj poprawne działanie polimorficzne.
• Dodaj nową usługę (np. PushNotification) bez modyfikowania istniejącej funkcji wysyłającej.
• Udowodnij przewagę programowania "do interfejsu" w kontekście łatwości rozbudowy systemów informatycznych.

• Interfejs zdefiniuj jako klasę ABC, w której absolutnie wszystkie metody są abstrakcyjne i puste.
• Metoda wyslij(self, tekst) musi zostać oznaczona dekoratorem @abstractmethod.
• Klasy EmailService oraz SmsService muszą implementować tę metodę zgodnie z własną logiką.
• Funkcja wyslij_do_wszystkich(serwisy, msg) powinna przyjmować generyczną listę obiektów serwisów.
• Wewnątrz pętli wywołuj s.wyslij(msg) bez sprawdzania konkretnego typu obiektu – to esencja polimorfizmu.
• Dzięki interfejsowi, główna funkcja nie musi znać szczegółów technicznych poszczególnych kanałów wysyłki.
• Spróbuj dodać nową klasę SlackService bez modyfikowania ani jednej linii w głównej funkcji wysyłającej.
• To zadanie uczy fundamentalnej zasady Dependency Inversion: polegaj na abstrakcjach, a nie na konkretach.
• Przetestuj scenariusz, w którym przekazujesz pustą listę serwisów – system powinien zachować pełną stabilność.
• Zastanów się, jak obsłużyć ewentualne błędy transmisji w sposób spójny dla wszystkich kanałów komunikacji.

• Opisz, jak łatwo i bezpiecznie można rozbudować system o nowe kanały komunikacji (np. WhatsAppService) bez zmiany logiki głównej.
• Wyjaśnij fundamentalne pojęcie programowania "do interfejsu" (coding to an interface) i jego wpływ na ogólną elastyczność oprogramowania.
• Omów zasadę Dependency Inversion (odwrócenie zależności) na konkretnym przykładzie Twojego systemu powiadomień.
• Przeanalizuj kluczową rolę polimorfizmu w uniwersalnej funkcji wyslij_do_wszystkich operującej na generycznej liście serwisów.
• Zastanów się nad zaletami całkowitej izolacji technicznej logiki wysyłki od głównego przepływu sterowania i logiki biznesowej aplikacji.
• Wnioskuj o wysokiej odporności systemu na zmiany w zewnętrznych bibliotekach API dostawców usług komunikacyjnych.
• Porównaj strukturę opartą na interfejsach do monolitycznych i trudnych w utrzymaniu instrukcji if/else sprawdzających typ powiadomienia.
• Opisz sposób zapewnienia stabilności systemu w przypadku przekazania pustej listy obiektów spełniających wymagany interfejs.
• Sprawdź, czy wymuszenie kontraktu za pomocą metody abstrakcyjnej gwarantuje poprawną obsługę błędów transmisji w konkretnych podklasach.

Rozróżniania dziedziczenia formalnego od rejestracji wirtualnej oraz sprawdzania typów za pomocą isinstance().

Często w pracy programisty zdarza się sytuacja, w której musimy zintegrować nasz system z zewnętrznymi bibliotekami, których kodu źródłowego nie możemy bezpośrednio modyfikować. Twoim wyzwaniem jest stworzenie mechanizmu wtyczek, który pozwoli na uznanie obcych klas za legalne elementy Twojego systemu, mimo braku formalnego dziedziczenia po Twoich klasach bazowych. Wykorzystaj zaawansowaną metodę rejestracji wirtualnej, aby "podpiąć" istniejące już obiekty pod Twój kontrakt abstrakcyjny bez naruszania ich pierwotnej struktury. Dzięki temu rozwiązaniu, standardowe testy typów będą zwracać pozytywne wyniki, co umożliwi płynną współpracę różnych modułów oprogramowania. Jest to technika szczególnie przydatna przy budowaniu systemów pluginów, gdzie zależy nam na maksymalnej elastyczności i wsparciu dla gotowych już komponentów. Musisz zadbać o to, aby proces rejestracji był jasny i czytelny dla innych deweloperów korzystających z Twojej architektury. Takie podejście pokazuje, że abstrakcja w Pythonie jest narzędziem niezwykle plastycznym i potrafi radzić sobie z ograniczeniami tradycyjnego modelu dziedziczenia. Poprawne wykonanie tego zadania nauczy Cię, jak budować mosty technologiczne między różnymi standardami kodu w jednym projekcie.

• Skonstruuj klasę abstrakcyjną PluginABC, definiującą wymagania dla wtyczek systemowych.
• Opracuj klasę ThirdPartyPlugin, która technicznie nie dziedziczy po PluginABC.
• Wykorzystaj metodę klasową PluginABC.register(), aby wirtualnie zarejestrować obcą klasę jako podklasę.
• Zweryfikuj relację za pomocą funkcji isinstance(), sprawdzając czy obiekt obcej klasy jest uznawany za PluginABC.
• Przetestuj funkcję issubclass(), aby potwierdzić formalne powiązanie typów w hierarchii Pythona.
• Zaimplementuj w zewnętrznej klasie metody wymagane przez interfejs (mimo braku dziedziczenia).
• Wyjaśnij różnicę między dziedziczeniem nominalnym (formalnym) a rejestracją wirtualną.
• Wskaż praktyczne zastosowania tej techniki przy integracji bibliotek, których kodu nie można edytować.

• Zdefiniuj class PluginABC(ABC): z co najmniej jedną metodą oznaczoną jako @abstractmethod.
• Opracuj klasę ThirdPartyPlugin, która w swojej definicji w ogóle nie dziedziczy po Twojej klasie bazowej.
• Wywołaj instrukcję PluginABC.register(ThirdPartyPlugin) po definicji obu tych klas w kodzie.
• Od tego momentu test issubclass(ThirdPartyPlugin, PluginABC) będzie zwracał wartość True.
• Pamiętaj: metoda register() nie sprawdza automatycznie, czy klasa faktycznie posiada wymagane metody.
• Musisz jako programista samodzielnie zadbać o to, aby "zarejestrowana" klasa spełniała założony interfejs.
• To zadanie pokazuje, jak można elastycznie zarządzać systemem typów Pythona bez zmiany struktury dziedziczenia.
• Sprawdź działanie funkcji isinstance(obj, PluginABC) na obiekcie klasy zewnętrznej.
• Wykorzystuj tę technikę zawsze, gdy integrujesz kod z bibliotek zewnętrznych, których nie możesz swobodnie edytować.
• Zauważ, że rejestracja wirtualna jest znacznie mniej rygorystyczną formą kontraktu niż tradycyjne dziedziczenie.

• Wyjaśnij precyzyjnie, kiedy i dlaczego warto zdecydować się na użycie metody register() zamiast standardowego dziedziczenia formalnego.
• Opisz techniczne różnice między dziedziczeniem nominalnym (formalnym) a rejestracją wirtualną w hierarchii typów języka Python.
• Omów praktyczne zastosowanie techniki rejestracji wirtualnej przy integracji zamkniętych bibliotek zewnętrznych, których kodu nie można edytować.
• Przeanalizuj zachowanie systemowych funkcji isinstance() oraz issubclass() po zarejestrowaniu nowej klasy wirtualnej.
• Zastanów się nad ryzykiem projektowym wynikającym z braku automatycznej weryfikacji obecności metod w zarejestrowanej wirtualnie klasie.
• Wnioskuj o plastyczności systemu typów Pythona i jego zdolności do budowania mostów technologicznych między różnymi standardami kodu.
• Porównaj rygorystyczny kontrakt klasycznego dziedziczenia do luźniejszej formy powiązania typów poprzez mechanizm rejestracji.
• Opisz sposób poprawnej implementacji metod wymaganych przez interfejs w klasie, która formalnie go nie dziedziczy w swojej definicji.
• Sprawdź doświadczalnie, czy usunięcie rejestracji wirtualnej w trakcie działania programu natychmiastowo zrywa relację typów w oczach interpretera.

Budowania złożonych hierarchii klas z metodami abstrakcyjnymi i konkretnymi, oraz stosowania wzorca projektowego "Metoda Szablonowa".

Pracujesz nad zaawansowaną platformą do masowego przetwarzania dokumentów o różnych strukturach, takich jak pliki tekstowe, arkusze kalkulacyjne czy raporty finansowe. Mimo różnic w formatach, proces analizy każdego z nich zawsze przebiega według tego samego, ściśle określonego schematu operacyjnego. Twoim zadaniem jest zaimplementowanie wzorca projektowego "Metoda Szablonowa", który ujednolici przepływ pracy przy jednoczesnym pozostawieniu swobody w implementacji detali technicznych. Klasa abstrakcyjna powinna definiować główny algorytm sterujący, który zajmie się otwieraniem i zamykaniem zasobów, delegując samo przetwarzanie danych do wyspecjalizowanych metod w klasach pochodnych. Dzięki temu unikniesz powielania kodu odpowiedzialnego za obsługę plików i zyskasz pewność, że każda nowa wtyczka będzie działać zgodnie z narzuconym standardem bezpieczeństwa. System wymusza na deweloperach skupienie się na meritum analizy, zdejmując z ich barków ciężar zarządzania infrastrukturą operacyjną. Takie podejście znacząco skróci czas wdrażania wsparcia dla nowych formatów danych i ułatwia późniejsze utrzymanie całego systemu. Gotowe rozwiązanie będzie doskonałym przykładem profesjonalnego łączenia metod konkretnych i abstrakcyjnych w celu osiągnięcia maksymalnej reużywalności kodu.

• Zaimplementuj klasę abstrakcyjną Analizator, stosując wzorzec projektowy "Metoda Szablonowa".
• Opracuj konkretną metodę proces_analizy(), która definiuje stały szkielet algorytmu przetwarzania pliku.
• Zdefiniuj w szablonie metody abstrakcyjne: otworz_plik(), wyodrebnij_dane() oraz formatuj_wynik().
• Skonstruuj klasę AnalizatorPDF dostarczającą specyficznych mechanizmów dla plików tekstowych.
• Utwórz klasę AnalizatorExcel jako kolejną specjalizację szablonu dla arkuszy danych.
• Upewnij się, że wspólna logika (np. logowanie czasu startu) znajduje się wyłącznie w klasie bazowej.
• Wywołaj proces analizy na różnych typach dokumentów, obserwując niezmienny przepływ sterowania.
• Udowodnij, że dzięki takiemu podejściu dodanie nowego formatu nie wymaga powielania kodu infrastrukturalnego.

• Metoda proces_analizy(self, sciezka) powinna kolejno wywoływać metody otwarcia, analizy i zamknięcia.
• Wszystkie te kroki pomocnicze (np. otworz_plik) oznacz w klasie bazowej jako @abstractmethod.
• Dzięki temu workflow jest wspólny dla wszystkich dokumentów, ale detale techniczne zależą od ich formatu.
• Możesz dodać metodę konkretną (nie-abstrakcyjną) do logowania postępów, która będzie współdzielona przez podklasy.
• Przetestuj wywołanie pdf_analizator.proces_analizy("dokument.pdf") i przeanalizuj kolejność komunikatów.
• Zauważ, że deweloper tworzący nową wtyczkę nie musi znać całości skomplikowanego procesu sterowania.
• To zadanie uczy wzorca "Template Method", który jest fundamentem działania wielu profesjonalnych frameworków.
• Sprawdź, czy wspólny kod infrastrukturalny wykonuje się poprawnie dla każdego nowego typu dokumentu.
• Wyjaśnij, dlaczego ten wzorzec skutecznie chroni przed zapomnieniem o krytycznych krokach (np. zwalnianiu pamięci).
• Zastanów się, czy niektóre metody mogą posiadać domyślną implementację (tzw. metody haki) w klasie bazowej.

• Wyjaśnij zagrożenia płynące z tzw. "nadmiarowej abstrakcji" (Overengineering) i wskaż sytuacje, w których lepiej pozostać przy zwykłym dziedziczeniu.
• Opisz zasadę działania wzorca projektowego Template Method (Metoda Szablonowa) w skutecznym zarządzaniu skomplikowanym workflowem.
• Omów zalety całkowitego odseparowania stałej logiki sterującej procesem od zmiennych detali technicznych przetwarzania konkretnych formatów danych.
• Przeanalizuj, w jaki sposób klasa abstrakcyjna skutecznie chroni system przed pominięciem krytycznych kroków (np. poprawnego zamykania plików).
• Zastanów się nad rolą tzw. "metod haków" (hook methods) w dostarczaniu opcjonalnych punktów rozszerzeń w zdefiniowanym szablonie działania.
• Wnioskuj o znaczącym skróceniu czasu wdrażania wsparcia dla nowych formatów dokumentów dzięki maksymalnej reużywalności infrastruktury kodu.
• Porównaj wzorzec szablonowy do tradycyjnego podejścia, w którym każda klasa pochodna samodzielnie zarządza całym procesem operacyjnym.
• Opisz znaczenie centralnego logowania postępów operacji, które zostało zaimplementowane wyłącznie w nadrzędnej klasie bazowej.
• Sprawdź, jak system reaguje na błędy techniczne w jednym z kroków szablonu i czy gwarantuje on bezpieczne wyjście z procesu analizy.