Przykłady bibliotek Apache

pom.xml

@@ -21,6 +21,21 @@
             <version>3.12.0</version>
         </dependency>
         <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.13.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>3.6.1</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-csv</artifactId>
+            <version>1.10.0</version>
+        </dependency>
+        <dependency>
             <groupId>org.glassfish</groupId>
             <artifactId>jakarta.json</artifactId>
             <version>2.0.1</version>

src/main/java/biblioteki/CommonsLang.java

+package biblioteki;
+
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+
+public class CommonsLang {
+
+    public static void main(String[] args) {
+        String[] t = {null, "Ala", "Agnieszka", "Zenon", "Żaneta", "Łukasz", "Łucja", "ala", "łukasz", "", "   "};
+        
+        // Gdy w Javie porównujemy Stirngi (i inne obiekty), robimy to za pomocą equals.
+        // Gdybyśmy próbowali wywołać equals na zmiennej, która może by nullem, to doprowadzimy do błędu NPE
+        
+//        for(int i = 2; i >= 0; i--) {
+//        	if(t[i].equals("Ala")) {
+//        		System.out.println(i + " to jest Ala");
+//        	} else {
+//        		System.out.println(i + " to nie jest Ala");
+//        	}
+//        }
+        
+        // Dlatego zalecane jest, aby zmienne porównywać z konkretnymi napisami w tej kolejności:
+        // "Napis".equals(zmienna)
+        // a nie zmienna.equals("Napis")
+        for(int i = 2; i >= 0; i--) {
+        	if("Ala".equals(t[i])) {
+        		System.out.println(i + " to jest Ala");
+        	} else {
+        		System.out.println(i + " to nie jest Ala");
+        	}
+        }
+        // Jednak czasami porównujemy dwie zmienne, z których obie mogą być nullem, wtedy jest trudniej.
+        // Biblioteka commons-lang i klasa StringUtils pomaga w operacjach porównywania, sprawdzania czy napis jest pusty itd.
+        
+        
+        System.out.println();
+        
+        // Porównania stringów, które są odporne na wartości null (nie pojawiają się błędy)
+        System.out.println(StringUtils.equalsIgnoreCase(t[0], t[7])); // false, bo null != ala
+        System.out.println(StringUtils.equalsIgnoreCase(t[1], t[7]));
+        System.out.println(StringUtils.equalsIgnoreCase(t[5], t[8])); // Łukasz == łukasz
+        System.out.println();
+        
+        System.out.println(StringUtils.isEmpty(t[0])); // tak, bo jest nullem
+        System.out.println(StringUtils.isEmpty(t[9])); // tak, bo jest pustym stringiem
+        System.out.println(StringUtils.isEmpty(t[10])); // false, bo zawiera 3 spacje
+        System.out.println(StringUtils.isBlank(t[10]));
+        System.out.println(StringUtils.isBlank(t[0]));
+        System.out.println(StringUtils.isBlank(t[1]));
+        System.out.println();
+        
+        // są też wersje dla wielu wartości na raz
+        System.out.println(StringUtils.isAllBlank(t[0], t[9], t[10]));
+        System.out.println(StringUtils.isAllBlank(t[0], t[8], t[10]));
+        // praktyczne zastosowanie: walidacja danych wprowadzonych przez użytkownika:
+        
+        String imie = "Ala", nazwisko = "Kowalska", adres = " ";
+        if(StringUtils.isAnyBlank(imie, nazwisko, adres)) {
+            System.out.println("Nie podałeś danych");
+        } else {
+            // robimy coś ważnego
+        }
+        System.out.println();
+
+        for (String s : t) {
+            if(StringUtils.isNotEmpty(s)) {
+                System.out.println("|" + StringUtils.center(s, 20, '.') + "|");
+            }
+        }
+        System.out.println();
+        
+        System.out.println(ObjectUtils.firstNonNull(t));
+    }
+
+}
+
+

src/main/java/biblioteki/CommonsMath.java

+package biblioteki;
+
+import java.util.Arrays;
+
+import org.apache.commons.math3.stat.StatUtils;
+
+public class CommonsMath {
+
+	public static void main(String[] args) {
+		double[] a = {2, 10, 4.44, 3.14, 0, 25.5};
+		System.out.println(Arrays.toString(a));
+		
+		double srednia = StatUtils.mean(a);
+		System.out.println(srednia);
+
+	}
+
+}

src/main/java/biblioteki/CzytajPlikCSV.java

+package biblioteki;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVParser;
+import org.apache.commons.csv.CSVRecord;
+
+public class CzytajPlikCSV {
+
+	public static void main(String[] args) {
+		File plik = new File("emps.csv");
+		
+		CSVFormat format = CSVFormat.Builder.create()
+				.setDelimiter(';')
+				.setHeader().setSkipHeaderRecord(true)
+				.build();
+				
+		try(CSVParser parser = CSVParser.parse(plik, Charset.forName("UTF-8"), format)) {
+			for(CSVRecord record : parser) {
+//				System.out.println(record);
+//				System.out.printf("Pracownik %s %s (%s) zarabia %s\n",
+//						record.get(1), record.get(2), record.get(3), record.get(4));
+				System.out.printf("Pracownik %s %s (%s) zarabia %s\n",
+						record.get("first_name"), record.get("last_name"), record.get("job_title"), record.get("salary"));
+			}
+			
+		} catch (IOException e) {
+			e.printStackTrace();
+		};
+
+	}
+
+}

src/main/java/biblioteki/EksportCSV.java

+package biblioteki;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.apache.commons.csv.CSVFormat;
+import org.apache.commons.csv.CSVPrinter;
+
+public class EksportCSV {
+
+	public static void main(String[] args) {
+		System.out.println("Zadaję zapytanie");
+
+		try(Connection c = DriverManager.getConnection("jdbc:sqlite:hr.db");
+				PreparedStatement stmt = c.prepareStatement("SELECT * FROM employees");
+				ResultSet rs = stmt.executeQuery()) {
+			
+			System.out.println("Zapisuję do pliku");
+			eksportujDoCSV(rs, "out/eksport.csv");
+			System.out.println("Gotowe");
+		} catch (SQLException | IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	static void eksportujDoCSV(ResultSet rs, String sciezka) throws SQLException, IOException {
+		CSVFormat format = CSVFormat.Builder.create()
+				.setDelimiter(';')
+				.setHeader(rs)
+				.build();
+		
+		try(PrintWriter out = new PrintWriter(sciezka);
+			CSVPrinter printer = new CSVPrinter(out, format)) {
+			printer.printRecords(rs);
+		}
+	}
+
+}

src/main/java/biblioteki/SkopiujKatalog.java

+package biblioteki;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.apache.commons.io.FileUtils;
+
+public class SkopiujKatalog {
+	// W standardowej bibliotece Javy nie ma operacji, która kopiowałaby na dysku cały katalog z plikami.
+	// W tym przykładzie użyjemy biblioteki Apache Commons IO, która taką operację zawiera.
+	public static void main(String[] args) {
+
+		try {
+			File zrodlo = new File("src/main/java");
+			File cel = new File("/home/patryk/Pulpit/zrodla");
+			FileUtils.copyDirectory(zrodlo, cel);
+			System.out.println("Gotowe");
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/main/java/biblioteki/Sqlite1.java

+package biblioteki;
+
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class Sqlite1 {
+
+	public static void main(String[] args) {
+		try {
+			Connection c = DriverManager.getConnection("jdbc:sqlite:hr.db");
+			System.out.println("Mam połączenie: " + c);
+			PreparedStatement stmt = c.prepareStatement("SELECT * FROM employees");
+			ResultSet rs = stmt.executeQuery();
+			while(rs.next()) {
+				int id = rs.getInt("employee_id");
+				String firstName = rs.getString("first_name");
+				String lastName = rs.getString("last_name");
+				BigDecimal salary = rs.getBigDecimal("salary");
+				System.out.println("Pracownik nr " + id + ": " + firstName + " " + lastName + " zarabia " + salary);
+			}
+			c.close();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/biblioteki/Sqlite2.java

+package biblioteki;
+
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class Sqlite2 {
+
+	public static void main(String[] args) {
+		try(Connection c = DriverManager.getConnection("jdbc:sqlite:hr.db");
+			PreparedStatement stmt = c.prepareStatement("SELECT * FROM employees");
+			ResultSet rs = stmt.executeQuery()) {
+			while(rs.next()) {
+				int id = rs.getInt("employee_id");
+				String firstName = rs.getString("first_name");
+				String lastName = rs.getString("last_name");
+				BigDecimal salary = rs.getBigDecimal("salary");
+				System.out.println("Pracownik nr " + id + ": " + firstName + " " + lastName + " zarabia " + salary);
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/biblioteki/SqliteMetadane.java

+package biblioteki;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+
+public class SqliteMetadane {
+/* Nawet nie wiedząc jaka jest struktura bazy danych, można te informacje odczytać z połączenia */
+	public static void main(String[] args) {
+		try(Connection c = DriverManager.getConnection("jdbc:sqlite:hr.db")) {
+
+			System.out.println("Otwarto połączenie. c = " + c);
+			
+			DatabaseMetaData dbMetaData = c.getMetaData();
+			
+			System.out.println(dbMetaData.getDatabaseProductName());
+			System.out.println(dbMetaData.getDatabaseMajorVersion()
+					+ "." + dbMetaData.getDatabaseMinorVersion());
+			System.out.println();
+			
+			String[] coCzytac = {"TABLE"};
+			try(ResultSet tables = dbMetaData.getTables(null, "public", null, coCzytac)) {
+				wypiszTabele(tables);
+			}
+			System.out.println("\n\nNormalna tabela:");
+			
+			try(ResultSet rs = c.createStatement().executeQuery("SELECT * FROM jobs")) {
+				wypiszTabele(rs);				
+			}
+			System.out.println();
+			
+			try(ResultSet rs = c.createStatement().executeQuery("SELECT * FROM departments JOIN locations USING(location_id)")) {
+				wypiszTabele(rs);				
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+	private static void wypiszTabele(ResultSet rs) throws SQLException {
+		// Odczytanie "metadanych wyniku"
+		ResultSetMetaData rsMetaData = rs.getMetaData();
+
+		final int n = rsMetaData.getColumnCount();
+		System.out.println("Wynik ma " + n + " kolumn:");
+		for(int i = 1; i <= n; i++) {
+			System.out.printf("%-30s", rsMetaData.getColumnName(i));
+		}
+		System.out.println();
+		for(int i = 1; i <= n; i++) {
+			System.out.printf("%-30s", rsMetaData.getColumnType(i));
+		}
+		System.out.println();
+		for(int i = 1; i <= n; i++) {
+			System.out.printf("%-30s", rsMetaData.getColumnTypeName(i));
+		}
+		System.out.println();
+		
+		while(rs.next()) {
+			for(int i = 1; i <= n; i++) {
+				System.out.printf("%-30s", rs.getString(i));
+			}
+			System.out.println();
+		}
+	}
+}

src/main/java/konto/BrakSrodkow.java

+package konto;
+
+public class BrakSrodkow extends Exception {
+
+	public BrakSrodkow() {
+		super();
+	}
+
+	public BrakSrodkow(String message) {
+		super(message);
+	}
+
+	
+}

src/main/java/konto/Konto.java

+package konto;
+
+public class Konto {
+	private int numer;
+	private String wlasciciel;
+	private int saldo;
+	
+	public Konto(int numer, String wlasciciel, int saldo) {
+		this.numer = numer;
+		this.wlasciciel = wlasciciel;
+		this.saldo = saldo;
+	}
+
+	public int getNumer() {
+		return numer;
+	}
+
+	public String getWlasciciel() {
+		return wlasciciel;
+	}
+
+	public int getSaldo() {
+		return saldo;
+	}
+
+	@Override
+	public String toString() {
+		return "Konto nr " + this.numer + ", saldo: " + this.saldo + ", wł.: " + this.wlasciciel;
+	}
+
+	public void wplata(int kwota) {
+		if(kwota <= 0) {
+			throw new IllegalArgumentException("Niedodatnia kwota w metodzie wplata");
+		}
+		this.saldo += kwota;
+	}
+
+	public void wyplata(int kwota) throws BrakSrodkow {
+		if(kwota <= 0) {
+			throw new IllegalArgumentException("Niedodatnia kwota w metodzie wyplata");
+		}
+		if(kwota > saldo) {
+			throw new BrakSrodkow("Brak środków na koncie nr " + numer);
+		}
+		this.saldo -= kwota;
+	}
+	
+}

src/main/java/p07_funkcje/Funkcje.java

+package p07_funkcje;
+
+public class Funkcje {
+	
+	public static long silnia(int n) {
+		long wynik = 1;
+		for(int i = 1; i <= n; i++) {
+			wynik *= i;
+		}
+		return wynik;
+	}
+	
+	public static long fib(int n) {
+		if(n <= 1) return n;
+		return fib(n-2) + fib(n-1);
+	}
+
+}

src/main/java/pogoda/06_pobierz_pogode_dla_miasta.py

+import requests
+
+miasto = input('Podaj nazwę miasta: ')
+
+# Dokończ: wyślij zapytanie o miasto, odczytaj współrzędne
+# zadaj zapytanie o prognozę
+# wypisz bieżacą pogodę oraz listę temperatur
+
+json = requests.get(f'https://geocoding-api.open-meteo.com/v1/search?name={miasto}').json()
+miejsce = json['results'][0]
+# Jeśli nie znajdzie żadnego takiego miejsca, to tu program się wykrzaczy
+lat, lon, country, name = miejsce['latitude'], miejsce['longitude'], miejsce['country'], miejsce['name']
+
+print(f'Znalazłem miejscowość {name} w kraju {country}')
+
+json = requests.get(f'https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&current_weather=true&hourly=temperature_2m').json()
+current = json['current_weather']
+print('Temperatura:', current['temperature'])
+print('Wiatr:', current['windspeed'])
+
+# print('Daty:', json['hourly']['time'])
+# print('Temperatury:', json['hourly']['temperature_2m'])
+
+# Przeglądanie dwóch list na raz: funkcja zip
+print('\nPrognozowane temperatury:')
+for dt, temp in zip(json['hourly']['time'], json['hourly']['temperature_2m']):
+    print(dt, temp)

src/main/java/pogoda/PobierzPogodeDlaMiasta.java

+package pogoda;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Scanner;
+
+import jakarta.json.Json;
+import jakarta.json.JsonArray;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonReader;
+import jakarta.json.JsonValue;
+
+public class PobierzPogodeDlaMiasta {
+	private Scanner scanner = new Scanner(System.in);
+	private double lat;
+	private double lon;
+	private String miasto;
+	
+
+	public static void main(String[] args) {
+		new PobierzPogodeDlaMiasta().run();
+	}
+
+	public void run() {
+		try {
+		System.out.print("Podaj nazwę miasta: ");
+		String szukane = scanner.nextLine();
+		if(znajdzMiasto(szukane)) {
+			pobierzIWypiszPogode();
+		}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private boolean znajdzMiasto(String szukane) throws IOException {
+		URL url = new URL("https://geocoding-api.open-meteo.com/v1/search?name=" + szukane);
+		try(InputStream input = url.openStream();
+			JsonReader reader = Json.createReader(input)) {
+			JsonObject json = reader.readObject();
+			JsonArray results = json.getJsonArray("results");
+			if(results.isEmpty()) {
+				System.out.println("Brak znalezionych lokalizacji");
+				return false;
+			}
+			System.out.println("Znalezione lokalizacje:");
+			int i = 0;
+			for(JsonValue result : results) {
+				JsonObject resulto = result.asJsonObject();
+				//System.out.print(result);
+				System.out.printf("%2d: <%+.3f %+.3f> → %s, %s%n", i++,
+						resulto.getJsonNumber("latitude").doubleValue(),
+						resulto.getJsonNumber("longitude").doubleValue(),
+						resulto.getString("name"), resulto.getString("country"));
+			}
+			System.out.print("Wybierz numer lokalizacji: ");
+			i = scanner.nextInt();
+			if(i < 0 || i >= results.size()) {
+				return false;
+			}
+			JsonObject loc = results.getJsonObject(i);
+			lat = loc.getJsonNumber("latitude").doubleValue();
+			lon = loc.getJsonNumber("longitude").doubleValue();
+			miasto = loc.getString("name");
+			return true;
+		}
+	}
+	
+	private void pobierzIWypiszPogode() throws IOException {
+		URL url = new URL("https://api.open-meteo.com/v1/forecast?latitude=" + lat + "&longitude="+ lon +"&current_weather=true&hourly=temperature_2m");
+		try(InputStream input = url.openStream();
+			JsonReader reader = Json.createReader(input)) {
+			JsonObject json = reader.readObject();
+			JsonObject weather = json.getJsonObject("current_weather");
+			
+			System.out.printf("Bieżąca pogoda dla miasta %s:%n", miasto);
+			System.out.println(weather);
+			System.out.printf("Temperatura %.1f °C%n", weather.getJsonNumber("temperature").doubleValue());
+			System.out.printf("Wiatr:      %.1f m/s%n", weather.getJsonNumber("windspeed").doubleValue());
+		}
+	}
+	
+}

src/main/java/rozne/KlasaOptional.java

+package p21_optional;
+
+import java.time.LocalTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class KlasaOptional {
+
+	public static void main(String[] args) {
+		Optional<String> napis0 = Optional.empty();
+		System.out.println(napis0);
+		
+		Optional<String> napis1 = Optional.of("Ala");
+		System.out.println(napis1);
+		
+		// Można też tworzyć Optional w oparciu o wartość, która może być nullem (null oznacza empty)
+		String a = "Ola", b = null;
+		
+		Optional<String> napis2 = Optional.ofNullable(a);
+		Optional<String> napis3 = Optional.ofNullable(b);
+		System.out.println(napis2);
+		System.out.println(napis3);
+		System.out.println();
+		
+		// Wartość, która jest w Optionalu, najprościej odczytać operacją get
+		System.out.println(napis1.get());
+		
+		// ale w przypadku pustego Optionala spowodowałoby to wyjątek
+		try {
+			System.out.println(napis0.get());
+		} catch (Exception e) {
+			System.err.println("próba odczytu napis0.get(): " + e);
+		}
+		System.out.println();
+		
+		// Aby porównać działanie dla pustych i niepustych, operacje uruchamiam w pętli dla 3 przykładowych obiektów.
+		List<Optional<String>> lista = new ArrayList<>(Arrays.asList(napis1, napis2, napis3));
+		// Od Javy 9 możnaby (lista jest niemutowalna)
+		// List<Optional<String>> lista = List.of(napis1, napis2, napis3);
+		
+		
+		// Dla każdego Optionala można za pomocą if sprawdzić czy on zawiera wartość:
+		for(Optional<String> opt : lista) {
+			if(opt.isPresent()) {
+				System.out.println("Jest wartość " + opt.get());
+			} else {
+				System.out.println("Brak wartości");
+			}
+		}
+		System.out.println();
+		
+		// Można też pobierając wartość zastąpić ją wartością domyślną w przypadku braku danych:
+		for(Optional<String> opt : lista) {
+			String napis = opt.orElse("nieznana osoba");
+			System.out.println("Witaj osobo " + napis);
+		}
+		System.out.println();
+		
+		// Ponieważ utworzenie domyślnej wartości może być czasami kosztowne,
+		// albo musi być zrobione w czasie działania programu,
+		// można też przekazać funkcję, która utworzy tę wartość - najczęściej jako wyrażenienie lambda:
+		for(Optional<String> opt : lista) {
+			String napis = opt.orElseGet(() -> "Brak danych stwierdzony o godzinie " + LocalTime.now());
+			System.out.println("Halo halo " + napis);
+		}
+		System.out.println();
+		
+		// Można też wyrzucić wyjątek, ale własny zamiast standardowego
+		try {
+			for(Optional<String> opt : lista) {
+				String napis = opt.orElseThrow(() -> new RuntimeException("Brak danych stwierdzony o godzinie " + LocalTime.now()));
+				System.out.println("Helo helo " + napis);
+			}
+		} catch (Exception e) {
+			System.err.println(e);
+		}
+		System.out.println();
+		
+		
+		// Są też operacje "funkcyjne", które przypominają operacje na strumieniach.
+		// Uwaga wstępna - wszystkie te operacjie noe modyfikują obiektu Optional w środku,
+		// tylko w wyniku zwracają nowego Optionala.
+		
+		// Operacja map zamienia wartość w Optionalu na wynik funkcji,
+		// ale w przypadku pustego Optionala zwraca pustego Optionala
+		
+		Optional<String> wynikMap0 = napis0.map(String::toUpperCase);
+		Optional<String> wynikMap1 = napis1.map(String::toUpperCase);
+		System.out.println(wynikMap0);
+		System.out.println(wynikMap1);
+		
+		for(Optional<String> opt : lista) {
+			System.out.println("hej " + opt.map(String::toLowerCase).orElse("nieznajomy"));
+		}
+		System.out.println();
+		// 
+
+		for(Optional<String> opt : lista) {
+			String napis = opt.filter(s -> s.startsWith("O")).map(String::toUpperCase).orElse("---");
+			System.out.println(napis); 
+		}
+	}
+
+}

src/test/java/konto/KontoTest.java

+package konto;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class KontoTest {
+	private Konto konto;
+	
+	@BeforeEach
+	void setUp() {
+		// metoda wykona się bezpośrednio przed każdy testem
+		// istnieje też @AfterEach tearDown() - wykonuje się po każdym teście
+		// Zazwyczaj w setUp przygotowuje się wspólne dane potrzebne przed każdym testem, taki stan początkowy (w literaturze: "fixture").
+		konto = new Konto(1, "Ala", 1000);
+	}
+
+	@Test
+	void testKonstruktorIGettery() {
+		assertEquals(1, konto.getNumer());
+		assertEquals("Ala", konto.getWlasciciel());
+		assertEquals(1000, konto.getSaldo());
+	}
+	
+	@Test
+	void testToString() {
+		String napis = konto.toString();
+		assertEquals("Konto nr 1, saldo: 1000, wł.: Ala", napis);
+	}
+	
+	@Test
+	void testWplata() {
+		konto.wplata(400);
+		assertEquals(1400, konto.getSaldo());
+	}
+
+	@Test
+	void testWyplata() throws BrakSrodkow {
+		konto.wyplata(400);
+		assertEquals(600, konto.getSaldo());
+	}
+	
+	// Temat sprawdzania wyjątków w testach.
+	
+	// Aby stwierdzić, że w pewnej sytuacji metoda POWINNA skończyć się wyjątkiem,
+	// możemy użyć odpowiednio try-catch (testWplataTry)
+	// albo użyć dedykowanych rozwiązań JUnit - dalsze przykłady
+	
+	@Test
+	void testWplataTry() {
+		try {
+			konto.wplata(-100);
+			// Gdyby nie było wyjątku i program doszedłby do tego miejsca,
+			// test powinien skończyć się porażką
+			fail("Powinien być wyjątek, a nie ma.");
+		} catch(IllegalArgumentException e) {
+			// Jeśli wyłapiemy wyjątek, możemy sprawdzić w teście jego szczegóły,
+			// np. jaki jest message (bardzo rzadko takie rzeczy sprawdza się w testach, ale można):
+			assertEquals("Niedodatnia kwota w metodzie wplata", e.getMessage());
+		} finally {
+			// Możemy też upewnić się, że w przypadku wystąpienia wyjątku stan konta się nie zmienił.
+			assertEquals(1000, konto.getSaldo());
+		}
+	}
+	
+	// Analogiczny test można też napisać wykorzystując nową funkcjonalność JUnit 5:
+	@Test
+	void testWplataUjemna_v1() {
+		// assertThrows wykonuje podany fragment kodu (w praktyce podaje się wyrażenie lambda)
+		// i sprawdza czy ten kończy się podanym rodzajem wyjątku.
+		// Jeśli jest wyjątek - dobrze
+		// Jeśli nie ma wyjątku - test failuje
+		
+		assertThrows(IllegalArgumentException.class, () -> {
+			konto.wplata(-100);			
+		});
+
+		// Dodatkowo po wykonaniu assertThrows możemy sprawdzić jaki jest stan końcowy,
+		// np. czy saldo się nie zmieniło.
+		assertEquals(1000, konto.getSaldo());
+	}
+	
+	// Aby sprawdzić jaki jest message w wyjątku itp, możemy odebrać obiekt wyjątku i sprawdzić bezpośrednio
+	@Test
+	void testWplataUjemna_v2() {
+		IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+			konto.wplata(-100);			
+		});
+
+		assertEquals("Niedodatnia kwota w metodzie wplata", exception.getMessage());
+		assertEquals(1000, konto.getSaldo());
+	}
+	
+	@Test
+	void testWyplataUjemna() {
+		assertThrows(IllegalArgumentException.class, () -> {
+			konto.wyplata(-100);			
+		});
+		assertEquals(1000, konto.getSaldo());
+	}
+	
+	@Test
+	void testBrakSrodkow() {
+		assertThrows(BrakSrodkow.class, () -> {
+			konto.wyplata(1300);			
+		});
+		assertEquals(1000, konto.getSaldo());
+	}
+}

src/test/java/konto/KontoTest_v0.java

+package konto;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+class KontoTest_v0 {
+	// W tej wersji nie używamy setUp, tylko na początku każdej metody z testem
+	// tworzymy przykładowe konto.
+
+	@Test
+	void testKonstruktorIGettery() {
+		Konto konto = new Konto(1, "Ala", 1000);
+		assertEquals(1, konto.getNumer());
+		assertEquals("Ala", konto.getWlasciciel());
+		assertEquals(1000, konto.getSaldo());
+	}
+	
+	@Test
+	void testToString() {
+		Konto konto = new Konto(1, "Ala", 1000);
+		String napis = konto.toString();
+		assertEquals("Konto nr 1, saldo: 1000, wł.: Ala", napis);
+	}
+	
+	@Test
+	void testWplata() {
+		Konto konto = new Konto(1, "Ala", 1000);
+		konto.wplata(400);
+		assertEquals(1400, konto.getSaldo());
+	}
+
+}

src/test/java/p07_funkcje/FunkcjeTest.java

+package p07_funkcje;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class FunkcjeTest {
+
+	@Test
+	void testSilnia0() {
+		// normalnie w testach nie robi się żadnych printów
+		// tu tylko eksperyment, żeby zobaczyć, że ten kod naprawdę się wykonuje
+		System.out.println("a kuku");
+		
+		// W typowym teście wykonujemy scenariusz testowy - tutaj tylko wywołanie funkcji, ale bywają bardziej rozbudowane przykłady
+		long wynik = p07_funkcje.Funkcje.silnia(0);
+		
+		// A pod koniec testu za pomocą asercji sprawdzamy czy kod zadziałał prawidłowo.
+		// Tutaj sprawdzamy wynik, ale często sprawdza się też stan obiektów itp. rzeczy
+		
+		// W języku Java istnieje prosta konstrukcja assert:
+		// assert wynik == 1;
+		// ale rzadko się jej używa, bo daje marne komunikaty w razie błędu; tylko numer linii
+		// można podać własny komunikat, ale jest to dużo roboty:
+		// assert wynik == 1 : "dla silnia 0 wyszedł zły wynik " + wynik;
+		
+		// Najczęście używa się assertEquals pochodzącej z biblioteki JUnit,
+		assertEquals(1, wynik);
+		
+		// albo dedykowanych bibliotek do pisania asercji, np. AssertJ
+		
+		// Technicznie to działa tak:
+		// - gdy asercja stwierdza, że warunek jest spełniony (jest OK), to nic się dzieje i test idzie dalej
+		// - gdy asercja stwierdza, że warunek nie jest spełniony, coś się nie zgadza,
+		//   to wyrzucany jest wyjątek AssertionError i dalsza część testu się nie wykona
+		// Gdy cały test dojdzie do końca bez wyjątku, to jest sukces.
+		// Gdy test kończy się wyjątkiem AssertionError - to "failuje"
+		// Gdy test kończy się innym wyjątkiem (np. NPE) - jest to liczone jako "error"
+	}
+	
+	@Test
+	void testSilnia5() {
+		long wynik = p07_funkcje.Funkcje.silnia(5);
+		assertEquals(120, wynik);
+	}
+
+	@Test
+	void testFib1() {
+		long wynik = p07_funkcje.Funkcje.fib(1);
+		assertEquals(1, wynik);
+	}
+
+	@Test
+	void testFib10() {
+		long wynik = p07_funkcje.Funkcje.fib(10);
+		assertEquals(55, wynik);
+	}
+
+}