Návrhové vzory design patterns význam a použití

Transkript

1 OOPR_06 1

2 Obsah přednášky Refaktorování Návrhové vzory význam, použití Návrhový vzor přepravka (Messenger) Testování programů testovací třída JUnit Návrhový vzor singleton jedináček Návrhový vzor výčtový typ Další možnosti třídy JUnit na testování programů 2

3 Refaktorování Refaktorování kódu programu je proces, změny zdrojového kódu, bez modifikace externího funkčního chování za účelem zlepšení některých nefunkčních parametrů software. Výhody dále zahrnují zlepšení čitelnosti kódu, snížení složitosti, zlepšení udržovatelnosti (maintainability) kódu, zlepšení rozšiřitelnosti. 3

4 Návrhové vzory design patterns význam a použití nejdůležitější zásada produktivního programátora nevynalézat již vynalezené, OOP podporuje znovupoužitelnost na úrovni kódu znovupoužití vytvořených tříd, návrhové vzory návody na řešení, některých typických, často se opakujících úloh na úrovni mentálních bloků, 1995 první kniha Design Patterns přeložená do češtiny obsahující prvních 23 návrhových vzorů, 4

5 Návrhové vzory design patterns význam a použití stále rostoucí důraz na návrhové vzory, které zlepšují a zpřehledňují programové řešení. zakladatel vzorů architekt Christopher Alexander jeho kniha: A Pattern Language: Towns, Buildings, Constructions pokoj se dvěma okny místo s jedním ovlivnil také programátorskou komunitu. Jeho práce ukázaly, že vzory jsou výbornou cestou k pochopení a transportu moudrosti daného řemesla. 5

6 Návrhové vzory design patterns Další literatura: Bruce Eckel: Thinking in Patterns web adresa: Základní popis návrhových vzorů: kontext ve kterém problém vzniká problém, který je třeba vyřešit řešení daného problému 6

7 Vzor Messenger Přepravka (Posel, kurýr) Problém: pracovat s několika hodnotami jako hodnotou jednou a umožnit tak snadné přenášení této skupiny hodnot mezi jednotlivými instancemi a jejich metodami (návrat objektu z metody). Kontext: práce v objektově orientovaném prostředí Řešení: všechny hodnoty jakoby naskládáme do přepravky (objektu) s danou strukturou a předáme žadateli hodnot. Přepravky jsou určeny pro předem definovanou sadu hodnot každý druh nářadí má připraven vlastní úchyt. 7

8 Přepravka & skládání agregace Řešení návrhového vzoru přepravka se podobá do jisté míry skládání objektů typu agregace. Přepravka je celek, části jsou jednotlivé objekty atributy. u částí je však použit modifikátor public (místo private) pro všechny části jsou vždy uvedeny všechny C a s t _ 1 přístupové a modifikační metody 1 C e le k + g e tm e to d a ( ) + s e tm e to d a ( ) C a s t _ 2 C a s t _ 3 1 8

9 Vzor Messenger Přepravka (Posel, kurýr) Třída, jejíž instance mají sloužit jako přepravky předem známé sady hodnot, by měla mít následující vlastnosti: pro každou přenášenou hodnotu bude definován vlastní atribut, do kterého se hodnota (objekt) uloží, účelem třídy je přenos a snadná dostupnost k přenášeným atributům, jsou tyto deklarované jako public, veřejné (dodržovat přístupové metody), datové atributy jsou jednoduché nebo objektové typy. 9

10 Vzor Messenger Přepravka (Posel, kurýr) Kromě metod nastavujících jednotlivé atributy, mají třídy přepravky metody pro kopírování hodnot atributů instance, předávané jako parametr např. setpozice(pozice) podobně jako tzv. kopírovací konstruktor 10

11 // prepravka public class Bod public int x, y, z; public Bod(int x, int y, int z) this.x = x; this.y = y; this.z = z; // kopirovaci konstruktor public Bod(Bod p) this.x = p.x; this.y = p.y; this.z = p.z; public String tostring() return "x: " + x + " y: " + y + " z: " + z; 11

12 public class Vektor private int velikost, smer; public Vektor(int velikost, int smer) this.velikost = velikost; this.smer = smer; public int getvelikost() return velikost; public int getsmer() return smer; 12

13 public class Plocha public static Bod translate(bod p, Vektor v) p = new Bod(p); // nemodifikuje objekt v parametru // vykonani smyslenych operaci: p.x = p.x + v.getvelikost(); p.y = p.y + v.getsmer(); p.z = p.z + v.getvelikost() * v.getsmer(); return p;

14 public class Prepravka public static void main(string[] args) Bod p1 = new Bod(1, 2, 3); Bod p2 = Plocha.translate(p1, new Vektor(11, 47)); String vysledek = "p1: " + p1 + "\np2: " + p2; System.out.println(vysledek); 14

15 Testování programů knihovna JUnit Tvorba aplikace vytvoření knihovních tříd; vytvoření testovací třídy s hlavní metodou, testovací třída (přípona Test) by měla otestovat vytvořené knihovní třídy. Moderní programování preferovaná myšlenka definovat nejprve sadu testů a teprve pak psát testovaný program, jakmile program projde, programátor přemýšlí, jak by jej měl zlepšit. 15

16 Testování programů knihovna JUnit Napíše testy a snaží se upravit program, aby vyhověl testům. Cyklus se může několikrát opakovat. Agilní metody vývoje. 16

17 Testování programů knihovna JUnit Zkušenosti ukazují, že připravená sada testů vede k vyšší efektivnosti při tvorbě programů. Automatizace testování knihovna JUnit polovina 90. let. V současné době je jednou z povinných součástí profesionálních vývojových prostředí je součástí prostředí BlueJ i Eclipse. 17

18 Zprovoznění JUnit v BlueJ 1. V hlavní nabídce vyberete Tools (Nástroje)- > Preferences (Nastavení) 2. Následně v Preferences vyberete záložku Miscellaneous (Různé) 3. Zaškrtnete políčko Show unit testing tools (Zobrazit nástroje pro testování) 4. Stiskem OK své zadání potvrďte 18

19 Run Tests spustit testy recording záznam End Ukončit Cancel Storno 19

20 Testovací třída V nabídce new class (nová třída) můžeme zadat, že chceme vytvořit Unit Test třídu (jedná se o test jednotky) <<unit test>> je tzv. stereotyp, který se používá v jazyce UML, v případě specifikace nějaké speciální vlastnosti (na první pohled odlišíme testovací třídu od ostatních tříd) 20

21 Vytvoření testovacích tříd 21

22 Knihovna JUnit a metody assertequals a asserttrue tzv. potvrzovací metody (série potvrzovacích metod), pomocí potvrzovacích metod ověříme, zda je vše během testování v pořádku, assertequals(t, o, s) resp. assertequals(t, o, s, r) parametr t je text, který se vytiskne v případě, že náš předpoklad nebude potvrzen. Tento parametr není povinný (existují přetížené metody, které ho nemají). 22

23 Knihovna JUnit a metody assertequals a asserttrue parametr o je očekávaná hodnota parametr s je spočtená hodnota, o které předpokládáme, že bude rovna očekávané hodnotě parametr r se použije pouze při porovnávání reálných čísel. Je v něm uložen rozdíl, o který se dvě reálná čísla mohou lišit, abychom jej pokládali za shodná. 23

24 Knihovna JUnit a metody assertequals a asserttrue Pokud se očekávaná hodnota a spočtená hodnota liší, metoda vypíše v testovacím okně zadaný text, očekávanou a obdrženou hodnotu a daný test ukončí. Metoda asserttrue(boolean) zestručnělá verze asserttrue(boolean, boolean), které předáváme jako první parametr očekávanou hodnotu a druhá je obdržená hodnota. 24

25 Napsání testu pomocí knihovny JUnit Učinit danou třídu podtřídou třídy JUnit.framework.TestCase - klíčové slovo extends Testovací třída obsahuje připravený konstruktor a dvě prázdné metody: setup() a teardown(). 25

26 Napsání testu pomocí knihovny JUnit Kód potřebný pro definici přípravku se vloží do metody setup() tělo metody setup() je většinou naplněno vytváření potřebných objektů a přiřazení odkazů na tyto objekty při dalším použití je lépe restartovat JVM Metoda teardown() slouží pro úklid po testování (odstranění nepotřebných objektů). 26

27 public class TestTestu extends junit.framework.testcase private int i1; private String s1; private Bod b1; //Priprava a uklid pripravku /*********************************************************************** * Vytvoreni pripravku (fixture), tj. sady objektu, s nimiz budou vsechny * testy pracovat a ktera se proto vytvori pred spustenim kazdeho testu. */ protected void setup() System.out.println( "\n=== Priprava testu " + getname() ); i1 = 1; s1 = "Jedna"; b1 = new Bod(); /******************************************************************* * Uklid po testu - tato metoda se spusti po vykonani kazdeho testu. */ protected void teardown() b1 = null; //pouziti metod napr. pro mazani System.out.println( "XXX Uklizeno po testu " + getname() ); 27

28 //== VLASTNI TESTY ============================================================= public void testcisel() System.out.println( "Cisla souhlasi" ); assertequals( "Neshoda celeho cisla", 1, i1 ); System.out.println( "Cisla nesouhlasi" ); assertequals( "Neshoda celeho cisla", 0, i1 ); //chyba System.out.println( "Konec testu cisel" ); public void testsouradnic() System.out.println( "Souradnice souhlasi" ); assertequals( "Neshoda souradnic", 0, b1.getx() ); System.out.println( "Souradnice nesouhlasi" ); assertequals( "Objekty se lisi", null, b1 ); //chyba assertequals( "Neshoda souradnic", 1, b1.gety() ); //chyba System.out.println( "Konec testu souradnic" ); public void testretezcu() System.out.println( "Retezce souhlasi" ); assertequals( "Neshoda textu", "Jedna", s1 ); System.out.println( "Retezce souhlasi" ); assertequals( "Neshoda textu", "Dva", s1 ); //chyba System.out.println( "Konec testu retezcu" ); 28

29 TestRunners testovací spouštěče V JUnit jsou zabudované tři TestRunnery JUnit.awtui.TestRunner zobrazení výsledků (views) používá grafické řízení, které má úzkou vazbu na daný operační systém (nativní) JUnit.swingui.TestRunner - na zobrazení výsledků se používá grafické řízení implementované Java Swing JUnit.textui.TestRunner zobrazení výsledků probíhá v textové formě 29

30 import junit.framework.*; class Point //prepravka public int x, y, z; //prepravni atributy public Point(int x, int y, int z) this.x = x; this.y = y; this.z = z; public Point(Point p)// kopirovaci konstruktor this.x = p.x; this.y = p.y; this.z = p.z; public String tostring() return "x: "+x+" y: "+ y+" z: "+z; public void print() System.out.println(this.toString()); 30

31 class Vector public int magnitude; int direction; public Vector(int magnitude, int direction) this.magnitude = magnitude; this.direction = direction; public String tostring() return "Vector magnitude: "+magnitude+" direction: "+direction; public void print() System.out.println(this.toString()); class Space public static Point translate(point p, Vector v) p = new Point(p);//nova instance pres kopirovaci konstruktor // nemodifikuje original p.x = p.x + 1; p.y = p.y + v.magnitude; p.z = p.z + v.direction; return p; 31

32 public class PrepravkaJUnit extends TestCase public void test() Point p1 = new Point(1, 2, 3); Point p2 = Space.translate(p1, new Vector(11, 32)); String result = "p1: "+ p1 +" p2: "+ p2; p1.print(); p2.print(); System.out.println(result); assertequals(result, "p1: x: 1 y: 2 z: 3 p2: x: 2 y: 13 z: 35"); public static void main(string[] args) junit.textui.testrunner.run(prepravkajunit.class); 32

33 Problém: Jedináček - Singleton definovat třídy tak, aby uživatel nemohl svobodně ovlivňovat počet jejich instancí chceme např. aby se vytvořila pouze jedna instance dané třídy Kontext: v mnoha aplikacích potřebujeme, aby vznikla pouze jedna instance (objekt) sdílený celou aplikací 33

34 Řešení: Jedináček - Singleton definovat konstruktor jako soukromý private tím je zabezpečeno, že se ke konstruktoru dostaneme pouze prostřednictvím jiné metody, která bude veřejná, použít při deklaraci takové třídy modifikátor final, který zabezpečí, že třída již nemůže mít potomky (nedovolí deklaraci dalších podtříd), 34

35 Jedináček - Singleton Přímo v deklaraci třídy se vytvoří nová instance (objekt) s daným označením, které je přístupné např. prostřednictvím metody getreference(). Metoda pro získání odkazu na jediný objekt, jedináček se deklaruje jako statická, což umožňuje vytvářet instance s využitím názvu třídy. 35

36 final class Singleton private int i; private static Singleton s = new Singleton(47); private Singleton(int x) i = x; //konstruktor s jednim argumentem public static Singleton getreference() return s; //ziskani reference public int getvalue() return i; public void setvalue(int x) i = x; public String tostring() return "Singleton i: "+this.getvalue(); public void tisk() System.out.println(this.toString()); 36

37 public class SingletonTest public void test() Singleton s = Singleton.getReference(); //vytvoreni nove instance String result = "" + s.getvalue(); System.out.println(result); Singleton s2 = Singleton.getReference(); s2.setvalue(9); result = "" + s.getvalue(); System.out.println(result); s.tisk(); s2.tisk(); if(s == s2)system.out.println("rovnaji se"); else System.out.println("Nerovnaji se"); public static void main(string[] args) new SingletonTest().test(); 37

38 import junit.framework.*; // Since this isn't inherited from a Cloneable // base class and cloneability isn't added, // making it final prevents cloneability from // being added through inheritance: Vzor Singleton a knihovna JUnit final class Singleton private static Singleton s = new Singleton(47); private int i; private Singleton(int x) i = x; public static Singleton getreference() return s; public int getvalue() return i; public void setvalue(int x) i = x; 38

39 public class SingletonPattern extends TestCase public void test() Singleton s = Singleton.getReference(); String result = "" + s.getvalue(); System.out.println(result); assertequals(result, "47"); Singleton s2 = Singleton.getReference(); s2.setvalue(9); result = "" + s.getvalue(); System.out.println(result); assertequals(result, "9"); Vzor Singleton a knihovna JUnit try // Can't do this: compile-time error. // Singleton s3 = (Singleton)s2.clone(); catch(exception e) throw new RuntimeException(e); public static void main(string[] args) junit.textui.testrunner.run(singletonpattern.class); 39

40 public class Ucet private int cislo; private double stav; private static Ucet ucetsingleton; // konstruktory private Ucet(int cislo, double stav) this.cislo = cislo; this.stav = stav; private Ucet() this(100, 0.0); private Ucet(int cislo) this(cislo, 0.0); private Ucet(double castka) this(0, castka); // tovarni metoda pro ziskani instance uctu public static Ucet getinstance() if(ucetsingleton == null) ucetsingleton = new Ucet(1, new Koruny(0.0)); return ucetsingleton; Třída Účet jako singleton 40

41 public class Osoba private String jmeno; private int roknarozeni; private static Ucet ucet = Ucet.getInstance(); public void vlozeni(double castka) ucet.vlozeni(castka); public double vyber(double castka) return ucet.vyber(castka); Třída Účet jako singleton Použití globálního odkazu 41

42 public class OsobaX private String jmeno; private int roknarozeni; //private static Ucet ucet = Ucet.getInstance(); public String tostring() Ucet ucet = Ucet. getinstance(); return String.format("%s %s %s %d\n%s", "Jmeno: ", getjmeno(), "vek: ", getvek(), ucet.tostring()); public void tisk() System.out.println(toString()); public void vlozeni(koruny koruny) Ucet ucet = Ucet.getInstance(); ucet.vlozeni(koruny); public void vyber(koruny koruny) Ucet ucet = Ucet.getInstance(); ucet.vyber(koruny); Třída Účet jako singleton Použití lokálních odlazů 42

43 Výčtové typy Problém: Definovat předem daný (známý) počet instancí, jež se zveřejní jako statické (třídní) atributy třídy. Tyto třídy představují většinou neměnné hodnotové typy. Kontext: implementace konkrétních problémů. Předem stanovený počet objektů (instancí), které se chovají jako konstanty 43

44 Výčtové typy Řešení: Výčtové typy mají předdeklarované některé atributy a metody viz přednáška OOP_4 Pravidla: 1.V těle třídy musíme nejprve deklarovat seznam jeho hodnot, všechny ostatní atributy a metody musíme deklarovat až za vím. 2.V nejjednodušším případě se jedná pouze o seznam názvů oddělených čárkami 44

45 Složitější definice výčtových typů výčtový typ může mít své podtypy, to znamená, že může obsahovat ještě další data, např. výčtový typ Barva může obsahovat celočíselný identifikátor id, textový výraz a cenu jako double, kromě tohoto popisu, musí mít výčtový typ soukromý konstruktor, soukromé neměnné datové atributy (final) přístupové metody k podtypům. 45

46 public enum Barva ZELENA(23, "green", ), CERVENA(19, "red", 38.60), ZLUTA(68, "yellow", ), SVETLE_CERVENA(41,"light-red", 87.30); private final int id; private final String jmeno; private final double cena; Barva(int c, String s, double d) // nesmi byt public id = c; jmeno = s; cena = d; public int getid() return id; public String getjmeno() return jmeno; public double getcena() return cena; 46

47 public class BarvaTest public static void main(string[] args) System.out.println("Tisk vsech hodnot"); for (Barva bv : Barva.values()) System.out.printf("\nid: %d text: %s cena: %.2f", bv.getid(), bv.getjmeno(), bv.getcena()); Barva b = Barva.ZLUTA; System.out.println("cena zluta: "+b.getcena()); 47

48 import javax.swing.joptionpane; public class JablkoTest public static void main(string[] args) Jablko j = new Jablko(); j.tisk(); Jablko j1 = new Jablko(Barva.valueOf("ZELENA"), 12, Chut.valueOf("VYBORNA")); Chut c; j1.tisk(); Jablko j2 = new Jablko(Barva.SVETLE_CERVENA, 15, Chut.ODPORNA); j2.tisk(); int k = j2.getchut().ordinal(); System.out.println("Poradi chuti: "+k); String t = j2.getchut().name(); System.out.println("Chut objektu j2 textove: "+t); c = j.getchut(); System.out.printf("Objekt j chut poradi: %d textove: %s", c.ordinal(), c.name()); String nazev = JOptionPane.showInputDialog("Zadejte barvu jablka:"); nazev = nazev.touppercase(); Barva b = Barva.valueOf(nazev); System.out.printf("\nZadana barva: %s poradi: %d", b.name(),b.ordinal()); double d = j1.getbarva().getcena(); String s = j2.getbarva().getjmeno(); 48

49 public enum Book // declare constants of enum type JHTP6( "Java How to Program 6e", "2005" ), CHTP4( "C How to Program 4e", "2004" ), IW3HTP3( "Internet & World Wide Web How to Program 3e", "2004" ), CPPHTP4( "C++ How to Program 4e", "2003" ), VBHTP2( "Visual Basic.NET How to Program 2e", "2002" ), CSHARPHTP( "C# How to Program", "2002" ); Další příklad s výčtovým typem kniha // instance fields private final String title; // book title private final String copyrightyear; // copyright year // enum constructor Book( String booktitle, String year ) title = booktitle; copyrightyear = year; // end enum Book constructor 49

50 // accessor for field title public String gettitle() return title; // end method gettitle // accessor for field copyrightyear public String getcopyrightyear() return copyrightyear; // end method getcopyrightyear // end enum Book 50

51 public class EnumTest public static void main( String args[] ) System.out.println( "All books:\n" ); // print all books in enum Book for ( Book book : Book.values() ) System.out.printf( "%-10s%-45s%s\n", book, book.gettitle(), book.getcopyrightyear() ); System.out.println( "\ndisplay a range of enum constants:\n" ); // print first four books for ( Book book : EnumSet.range( Book.JHTP6, Book.CPPHTP4 ) ) System.out.printf( "%-10s%-45s%s\n", book, book.gettitle(), book.getcopyrightyear() ); // end main // end class EnumTest 51

52 All books: JHTP6 Java How to Program 6e 2005 CHTP4 C How to Program 4e 2004 IW3HTP3 Internet & World Wide Web How to Program 3e 2004 CPPHTP4 C++ How to Program 4e 2003 VBHTP2 Visual Basic.NET How to Program 2e 2002 CSHARPHTP C# How to Program 2002 Display a range of enum constants: JHTP6 Java How to Program 6e 2005 CHTP4 C How to Program 4e 2004 IW3HTP3 Internet & World Wide Web How to Program 3e 2004 CPPHTP4 C++ How to Program 4e

53 Metody knihovny JUnit aplikované na třídě Zlomek statická třída Funkce obsahuje další třídní metody dostupné bez vytvoření instance od třídy Funkce základní třída Zlomek metoda ZlomekTest 53

54 /************************************************************************* * Trida Funkce obsahuje pomocne staticke metody pro tridu Zlomek. Resi * vypocet nejmensiho spolecneho nasobku a nejvetsiho spolecneho delitele. Rudolf Pecinovsky , 30. brezen 2004, 23:17 */ public final class Funkce Funkce 1/2 /*********************************************************************** * Vrati nejvetsiho spolecneho delitele dvou zadanych cisel. * Vracene cislo je vzdy kladne nezavisle na znamenku parametru. * i1 Prvni cislo i2 Druhe cislo * Nejvetsi spolecny delitel zadanych cisel */ public static int nsd(int i1, int i2) i1 = Math.abs( i1 ); i2 = Math.abs( i2 ); while( i2 > 0 ) int pom = i1 % i2; i1 = i2; i2 = pom; return i1; 54

55 /*********************************************************************** * Vrati nejmensi spolecny nasobek zadanych cisel. * Vracene cislo je vzdy kladne nezavisle na znamenku parametru. * i1 Prvni cislo i2 Druhe cislo * Nejmensi spolecny nasobek zadanych cisel */ public static int nsn(int i1, int i2) if( (i1 == 0) (i2 == 0) ) return 0; return i2 * Math.abs(i1) / nsd(i1,i2); Funkce 2/2 //######################################################################## //== KONSTRUKTORY A TOVARNI METODY ============================================= private Funkce() 55

56 public class Zlomek_4 private final int citatel; private final int jmenovatel; Třída Zlomek public Zlomek_4(int c, int j) //při vytvoreni noveho objektu se provede uprava int delitel = Funkce.nsd( c, j ); if( j < 0 ) c = -c; j = -j; citatel = c / delitel; jmenovatel = j / delitel; public Zlomek_4(Zlomek_4 z) //kopirovaci konstruktor citatel = z.citatel; jmenovatel = z.jmenovatel; public Zlomek_4(int cislo) citatel = cislo; jmenovatel = 1; 56

57 //== PRISTUPOVE METODY VLASTNOSTI INSTANCI ===================================== public int getcitatel() return citatel; public int getjmenovatel() return jmenovatel; public String tostring() return "[" + citatel + "/" + jmenovatel + "]"; public int intvalue() return citatel / jmenovatel; public double doublevalue() return (double)citatel / jmenovatel; 57

58 public Zlomek_4 plus(zlomek_4 z) //int nasobek = Funkce.nsn( this.jmenovatel, z.jmenovatel ); return new Zlomek_4( citatel*z.jmenovatel + z.citatel*jmenovatel, jmenovatel*z.jmenovatel ); public Zlomek_4 plus(int cislo) return new Zlomek_4( citatel + cislo*jmenovatel, jmenovatel ); public Zlomek_4 minus(zlomek_4 z) //int nasobek = Funkce.nsn( this.jmenovatel, z.jmenovatel ); return new Zlomek_4( citatel*z.jmenovatel - z.citatel*jmenovatel, jmenovatel*z.jmenovatel ); public Zlomek_4 minus(int cislo) return new Zlomek_4( citatel - cislo*jmenovatel, jmenovatel ); public Zlomek_4 odectiod(int cislo) return new Zlomek_4( cislo*jmenovatel - citatel, jmenovatel ); 58

59 public Zlomek_4 krat(zlomek_4 z) return new Zlomek_4( citatel * z.citatel, jmenovatel * z.jmenovatel ); public Zlomek_4 krat(int cislo) return new Zlomek_4( citatel * cislo, jmenovatel ); public Zlomek_4 deleno(zlomek_4 z) return new Zlomek_4( citatel * z.jmenovatel, jmenovatel * z.citatel ); public Zlomek_4 deleno(int cislo) return new Zlomek_4( citatel, jmenovatel * cislo ); public Zlomek_4 delcislo(int cislo) return new Zlomek_4( jmenovatel * cislo, citatel ); 59

60 public class Zlomek_4Test extends junit.framework.testcase Zlomek_4 z0, z1, z2, z12, z34, z56; Zlomek_4 v1, v2, v3; ZlomekTest //== PRIPRAVA A UKLID PRIPRAVKU ================================================ /********************************************************************** * Vytvoreni pripravku (fixture), tj. sady objektu, s nimiz budou vsechny * testy pracovat a ktera se proto vytvori pred spustenim kazdeho testu. */ protected void setup() System.out.println( "\n" + getname() ); z0 = new Zlomek_4( 0 ); z1 = new Zlomek_4( 1 ); z2 = new Zlomek_4( 2 ); z12 = new Zlomek_4( 1, 2 ); z34 = new Zlomek_4( 3, 4 ); z56 = new Zlomek_4( 5, 6 ); /********************************************************************* * Uklid po testu - tato metoda se spusti po vykonani kazdeho testu. */ protected void teardown() 60

61 public static void tiskni( Zlomek_4 v, Zlomek_4 z1, char op, Zlomek_4 z2 ) System.out.println( v + " = " + z1 + ' ' + op + ' ' + z2 ); /************************************************************************* * Pomocna metoda tisknouci zadanou operaci na standardni vystup. * cislo Vysledek prevedeny na retezec z Prevadeny zlomek */ public static void tiskni( String cislo, Zlomek_4 z ) System.out.println( cislo + " = " + z ); 61

62 /*************************************************************************** * Testuje konstruktory a prevod zlomku na retezec. */ public void testtostring() z1 = new Zlomek_4( 2 ); System.out.println("Zlomek_4(2) = " + z1); assertequals( "[2/1]", z1.tostring() ); z1 = new Zlomek_4( 1, 2 ); System.out.println("Zlomek_4(1, 2) = " + z1); assertequals( "[1/2]", z1.tostring() ); z1 = new Zlomek_4( 2, 4 ); System.out.println("Zlomek_4(2, 4) = " + z1); assertequals( "[1/2]", z1.tostring() ); z2 = new Zlomek_4( z1 ); System.out.println("Zlomek_4(" + z1 + ") = " + z2); assertequals(z1.getcitatel(), z2.getcitatel()); assertequals(z1.getjmenovatel(), z2.getjmenovatel()); 62

63 /*************************************************************************** * Testuje scitani zlomku a zlomku a cisla. */ public void testplus() v1 = z1.plus( z2 ); tiskni( v1, z1, '+', z2 ); assertequals( "[3/1]", v1.tostring() ); v2 = z12.plus( z34 ); tiskni( v2, z12, '+', z34 ); assertequals( "[5/4]", v2.tostring() ); v2 = z34.plus( z12 ); tiskni( v2, z34, '+', z12 ); assertequals( "[5/4]", v2.tostring() ); v3 = v1.plus(v2); tiskni( v3, v1, '+', v2 ); assertequals( "[17/4]", v3.tostring() ); v3 = v2.plus(v2); tiskni( v3, v2, '+', v2 ); assertequals( "[5/2]", v3.tostring() ); v3 = v2.plus(2); tiskni( v3, v2, '+', new Zlomek_4(2) ); assertequals( "[13/4]", v3.tostring() ); 63

64 // Testuje odcitani zlomku a zlomku a cisla. public void testminus() v1 = z1.minus( z2 ); tiskni( v1, z1, '-', z2 ); assertequals( "[-1/1]", v1.tostring() ); v2 = z12.minus( z34 ); tiskni( v2, z12, '-', z34 ); assertequals( "[-1/4]", v2.tostring() ); v2 = z34.minus( z12 ); tiskni( v2, z34, '-', z12 ); assertequals( "[1/4]", v2.tostring() ); v3 = v1.minus(v2); tiskni( v3, v1, '-', v2 ); assertequals( "[-5/4]", v3.tostring() ); v3 = v2.minus(v2); tiskni( v3, v2, '-', v2 ); assertequals( "[0/1]", v3.tostring() ); v3 = v2.minus(2); tiskni( v3, v2, '-', new Zlomek_4(2) ); assertequals( "[-7/4]", v3.tostring() ); v3 = v2.odectiod(2); tiskni( v3, new Zlomek_4(2), '-', v2 ); assertequals( "[7/4]", v3.tostring() ); 64

65 /*************************************************************************** * Testuje nasobeni zlomku a zlomku a cisla. */ public void testkrat() v1 = z1.krat( z2 ); tiskni( v1, z1, '*', z2 ); assertequals( "[2/1]", v1.tostring() ); v2 = z12.krat( z34 ); tiskni( v2, z12, '*', z34 ); assertequals( "[3/8]", v2.tostring() ); v2 = z34.krat( z12 ); tiskni( v2, z34, '*', z12 ); assertequals( "[3/8]", v2.tostring() ); v3 = v1.krat(v2); tiskni( v3, v1, '*', v2 ); assertequals( "[3/4]", v3.tostring() ); v3 = v2.krat(v2); tiskni( v3, v2, '*', v2 ); assertequals( "[9/64]", v3.tostring() ); v3 = v2.krat(2); tiskni( v3, v2, '*', new Zlomek_4(2) ); assertequals( "[3/4]", v3.tostring() ); 65

66 // Testuje deleni zlomku a zlomku a cisla. public void testdeleno() v1 = z1.deleno( z2 ); tiskni( v1, z1, ':', z2 ); assertequals( "[1/2]", v1.tostring() ); v2 = z12.deleno( z34 ); tiskni( v2, z12, ':', z34 ); assertequals( "[2/3]", v2.tostring() ); v2 = z34.deleno( z12 ); tiskni( v2, z34, ':', z12 ); assertequals( "[3/2]", v2.tostring() ); v3 = v1.deleno(v2); tiskni( v3, v1, ':', v2 ); assertequals( "[1/3]", v3.tostring() ); v3 = v2.deleno(v2); tiskni( v3, v2, ':', v2 ); assertequals( "[1/1]", v3.tostring() ); v3 = v2.deleno(2); tiskni( v3, v2, ':', new Zlomek_4(2) ); assertequals( "[3/4]", v3.tostring() ); v3 = v2.delcislo(2); tiskni( v3, new Zlomek_4(2), ':', v2 ); assertequals( "[4/3]", v3.tostring() ); 66

67 // Test prevodu zlomku na cislo public void testprevody() int i; double d; Zlomek_4 z125 = new Zlomek_4( 12, 5 ); i = z1.intvalue(); tiskni( ""+i, z1 ); assertequals( 1, i ); i = z34.intvalue(); tiskni( ""+i, z34 ); assertequals( 0, i ); i = z125.intvalue(); tiskni( ""+i, z125 ); assertequals( 2, i, 0 ); d = z1.doublevalue(); tiskni( ""+d, z1 ); assertequals( 1.0, d, 0 ); d = z12.doublevalue(); tiskni( ""+d, z34 ); assertequals( 0.5, d, 0 ); d = z125.doublevalue(); tiskni( ""+d, z125 ); assertequals( 2.4, d, 0 ); 67