diff --git a/pom.xml b/pom.xml
index 2614c6984..2897350b0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,8 +21,8 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
+                    <source>11</source>
+                    <target>11</target>
                 </configuration>
             </plugin>
         </plugins>
diff --git a/src/main/java/pl/edu/agh/mwo/invoice/Invoice.java b/src/main/java/pl/edu/agh/mwo/invoice/Invoice.java
index 56fe02359..d4fab4ac4 100644
--- a/src/main/java/pl/edu/agh/mwo/invoice/Invoice.java
+++ b/src/main/java/pl/edu/agh/mwo/invoice/Invoice.java
@@ -1,30 +1,57 @@
 package pl.edu.agh.mwo.invoice;
 
 import java.math.BigDecimal;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Map;
 
 import pl.edu.agh.mwo.invoice.product.Product;
 
 public class Invoice {
-    private Collection<Product> products;
+    //private Map<Product, Integer> products;
+    private Collection<Product> products = new ArrayList<>();
 
     public void addProduct(Product product) {
-        // TODO: implement
+        if (product == null) {
+            throw new IllegalArgumentException();
+        }
+        this.products.add(product);
     }
 
     public void addProduct(Product product, Integer quantity) {
-        // TODO: implement
+        if (quantity <= 0) {
+            throw new IllegalArgumentException();
+        }
+        for (var i = 0; i < quantity; i++) {
+            products.add(product);
+        }
     }
 
-    public BigDecimal getSubtotal() {
-        return null;
+    public BigDecimal getNetPrice() {
+        var sumNet = BigDecimal.ZERO;
+        for (var product : products) {
+            sumNet = sumNet.add(product.getPrice());
+        }
+        return sumNet;
     }
 
     public BigDecimal getTax() {
-        return null;
+        var sumTax = BigDecimal.ZERO;
+        for (var product : products) {
+            sumTax = sumTax.add(product.getTaxPercent().multiply(product.getPrice()));
+        }
+        return sumTax;
     }
 
-    public BigDecimal getTotal() {
-        return null;
+    public BigDecimal getGrossPrice() {
+        var sumGross = BigDecimal.ZERO;
+        for (var product : products) {
+            sumGross = sumGross.add(product.getPriceWithTax());
+        }
+        return sumGross;
+    }
+
+    public Collection<Product> getProducts() {
+        return products;
     }
 }
diff --git a/src/main/java/pl/edu/agh/mwo/invoice/product/Product.java b/src/main/java/pl/edu/agh/mwo/invoice/product/Product.java
index 318de9ac9..c3b92c40d 100644
--- a/src/main/java/pl/edu/agh/mwo/invoice/product/Product.java
+++ b/src/main/java/pl/edu/agh/mwo/invoice/product/Product.java
@@ -10,24 +10,33 @@ public abstract class Product {
     private final BigDecimal taxPercent;
 
     protected Product(String name, BigDecimal price, BigDecimal tax) {
+        if (name == null || name.isEmpty()) {
+            throw new IllegalArgumentException("Product name cannot be null or empty.");
+        }
+        if (price == null || price.compareTo(BigDecimal.valueOf(0)) < 0) {
+            throw new IllegalArgumentException("Price name cannot be null or negative.");
+        }
+        if (tax == null) {
+            throw new IllegalArgumentException("Tax name cannot be null.");
+        }
         this.name = name;
         this.price = price;
         this.taxPercent = tax;
     }
 
     public String getName() {
-        return null;
+        return name;
     }
 
     public BigDecimal getPrice() {
-        return null;
+        return price;
     }
 
     public BigDecimal getTaxPercent() {
-        return null;
+        return taxPercent;
     }
 
     public BigDecimal getPriceWithTax() {
-        return null;
+        return getPrice().add(getPrice().multiply(getTaxPercent()));
     }
 }
diff --git a/src/test/java/pl/edu/agh/mwo/invoice/InvoiceTest.java b/src/test/java/pl/edu/agh/mwo/invoice/InvoiceTest.java
new file mode 100644
index 000000000..3697b460c
--- /dev/null
+++ b/src/test/java/pl/edu/agh/mwo/invoice/InvoiceTest.java
@@ -0,0 +1,127 @@
+package pl.edu.agh.mwo.invoice;
+
+import java.math.BigDecimal;
+
+import org.hamcrest.Matchers;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import pl.edu.agh.mwo.invoice.product.DairyProduct;
+import pl.edu.agh.mwo.invoice.product.OtherProduct;
+import pl.edu.agh.mwo.invoice.product.Product;
+import pl.edu.agh.mwo.invoice.product.TaxFreeProduct;
+
+public class InvoiceTest {
+    private Invoice invoice;
+
+    @Before
+    public void createEmptyInvoiceForTheTest() {
+        invoice = new Invoice();
+    }
+
+    @Test
+    public void testEmptyInvoiceHasEmptySubtotal() {
+        Assert.assertThat(BigDecimal.ZERO, Matchers.comparesEqualTo(invoice.getNetPrice()));
+    }
+
+    @Test
+    public void testEmptyInvoiceHasEmptyTaxAmount() {
+        Assert.assertThat(BigDecimal.ZERO, Matchers.comparesEqualTo(invoice.getTax()));
+    }
+
+    @Test
+    public void testEmptyInvoiceHasEmptyTotal() {
+        Assert.assertThat(BigDecimal.ZERO, Matchers.comparesEqualTo(invoice.getGrossPrice()));
+    }
+
+    @Test
+    public void testInvoiceSubtotalWithTwoDifferentProducts() {
+        Product onions = new TaxFreeProduct("Warzywa", new BigDecimal("10"));
+        Product apples = new TaxFreeProduct("Owoce", new BigDecimal("10"));
+        invoice.addProduct(onions);
+        invoice.addProduct(apples);
+        Assert.assertThat(invoice.getNetPrice(), Matchers.comparesEqualTo(new BigDecimal("20")));
+    }
+
+    @Test
+    public void testInvoiceSubtotalWithManySameProducts() {
+        Product onions = new TaxFreeProduct("Warzywa", BigDecimal.valueOf(10));
+        invoice.addProduct(onions, 100);
+        Assert.assertThat(invoice.getNetPrice(), Matchers.comparesEqualTo(new BigDecimal("1000")));
+    }
+
+    @Test
+    public void testInvoiceHasTheSameSubtotalAndTotalIfTaxIsZero() {
+        Product taxFreeProduct = new TaxFreeProduct("Warzywa", new BigDecimal("199.99"));
+        invoice.addProduct(taxFreeProduct);
+        Assert.assertThat(invoice.getNetPrice(), Matchers.comparesEqualTo(invoice.getGrossPrice()));
+    }
+
+    @Test
+    public void testInvoiceHasProperSubtotalForManyProducts() {
+        invoice.addProduct(new TaxFreeProduct("Owoce", new BigDecimal("200")));
+        invoice.addProduct(new DairyProduct("Maslanka", new BigDecimal("100")));
+        invoice.addProduct(new OtherProduct("Wino", new BigDecimal("10")));
+        Assert.assertThat(invoice.getNetPrice(), Matchers.comparesEqualTo(new BigDecimal("310")));
+    }
+
+    @Test
+    public void testInvoiceHasProperTaxValueForManyProduct() {
+        // tax: 0
+        invoice.addProduct(new TaxFreeProduct("Pampersy", new BigDecimal("200")));
+        // tax: 8
+        invoice.addProduct(new DairyProduct("Kefir", new BigDecimal("100")));
+        // tax: 2.30
+        invoice.addProduct(new OtherProduct("Piwko", new BigDecimal("10")));
+        Assert.assertThat(invoice.getTax(), Matchers.comparesEqualTo(new BigDecimal("10.30")));
+    }
+
+    @Test
+    public void testInvoiceHasProperTotalValueForManyProduct() {
+        // price with tax: 200
+        invoice.addProduct(new TaxFreeProduct("Maskotki", new BigDecimal("200")));
+        // price with tax: 108
+        invoice.addProduct(new DairyProduct("Maslo", new BigDecimal("100")));
+        // price with tax: 12.30
+        invoice.addProduct(new OtherProduct("Chipsy", new BigDecimal("10")));
+        Assert.assertThat(invoice.getGrossPrice(), Matchers.comparesEqualTo(new BigDecimal("320.30")));
+    }
+
+    @Test
+    public void testInvoiceHasPropoerSubtotalWithQuantityMoreThanOne() {
+        // 2x kubek - price: 10
+        invoice.addProduct(new TaxFreeProduct("Kubek", new BigDecimal("5")), 2);
+        // 3x kozi serek - price: 30
+        invoice.addProduct(new DairyProduct("Kozi Serek", new BigDecimal("10")), 3);
+        // 1000x pinezka - price: 10
+        invoice.addProduct(new OtherProduct("Pinezka", new BigDecimal("0.01")), 1000);
+        Assert.assertThat(new BigDecimal("50"), Matchers.comparesEqualTo(invoice.getNetPrice()));
+    }
+
+    @Test
+    public void testInvoiceHasPropoerTotalWithQuantityMoreThanOne() {
+        // 2x chleb - price with tax: 10
+        invoice.addProduct(new TaxFreeProduct("Chleb", new BigDecimal("5")), 2);
+        // 3x chedar - price with tax: 32.40
+        invoice.addProduct(new DairyProduct("Chedar", new BigDecimal("10")), 3);
+        // 1000x pinezka - price with tax: 12.30
+        invoice.addProduct(new OtherProduct("Pinezka", new BigDecimal("0.01")), 1000);
+        Assert.assertThat(new BigDecimal("54.70"), Matchers.comparesEqualTo(invoice.getGrossPrice()));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvoiceWithZeroQuantity() {
+        invoice.addProduct(new TaxFreeProduct("Tablet", new BigDecimal("1678")), 0);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testInvoiceWithNegativeQuantity() {
+        invoice.addProduct(new DairyProduct("Zsiadle mleko", new BigDecimal("5.55")), -1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testAddingNullProduct() {
+        invoice.addProduct(null);
+    }
+}
diff --git a/src/test/java/pl/edu/agh/mwo/invoice/product/ProductTest.java b/src/test/java/pl/edu/agh/mwo/invoice/product/ProductTest.java
new file mode 100644
index 000000000..9b3c5bd6e
--- /dev/null
+++ b/src/test/java/pl/edu/agh/mwo/invoice/product/ProductTest.java
@@ -0,0 +1,57 @@
+package pl.edu.agh.mwo.invoice.product;
+
+import java.math.BigDecimal;
+
+import org.hamcrest.Matchers;
+import org.junit.Assert;
+import org.junit.Test;
+
+import pl.edu.agh.mwo.invoice.product.Product;
+
+public class ProductTest {
+    @Test
+    public void testProductNameIsCorrect() {
+        Product product = new OtherProduct("buty", new BigDecimal("100.0"));
+        Assert.assertEquals("buty", product.getName());
+    }
+
+    @Test
+    public void testProductPriceAndTaxWithDefaultTax() {
+        Product product = new OtherProduct("Ogorki", new BigDecimal("100.0"));
+        Assert.assertThat(new BigDecimal("100"), Matchers.comparesEqualTo(product.getPrice()));
+        Assert.assertThat(new BigDecimal("0.23"), Matchers.comparesEqualTo(product.getTaxPercent()));
+    }
+
+    @Test
+    public void testProductPriceAndTaxWithDairyProduct() {
+        Product product = new DairyProduct("Szarlotka", new BigDecimal("100.0"));
+        Assert.assertThat(new BigDecimal("100"), Matchers.comparesEqualTo(product.getPrice()));
+        Assert.assertThat(new BigDecimal("0.08"), Matchers.comparesEqualTo(product.getTaxPercent()));
+    }
+
+    @Test
+    public void testPriceWithTax() {
+        Product product = new DairyProduct("Oscypek", new BigDecimal("100.0"));
+        Assert.assertThat(new BigDecimal("108"), Matchers.comparesEqualTo(product.getPriceWithTax()));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testProductWithNullName() {
+        new OtherProduct(null, new BigDecimal("100.0"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testProductWithEmptyName() {
+        new TaxFreeProduct("", new BigDecimal("100.0"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testProductWithNullPrice() {
+        new DairyProduct("Banany", null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testProductWithNegativePrice() {
+        new TaxFreeProduct("Mandarynki", new BigDecimal("-1.00"));
+    }
+}