From fceb76fc63116b43aa28a0bc150ffea35631937d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Tue, 27 Feb 2018 23:49:47 +0300
Subject: [PATCH 01/12] =?UTF-8?q?=D0=A1=D0=B4=D0=B5=D0=BB=D0=B0=D0=BB=20?=
 =?UTF-8?q?=D0=BA=D0=BB=D0=B0=D1=81=D1=81=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5?=
 =?UTF-8?q?=D1=80=D0=BD=D0=BE=D1=81=D1=82=D0=B8=20=D0=B8=20=D1=87=D0=B8?=
 =?UTF-8?q?=D1=81=D0=BB=D0=B0=20=D1=81=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5?=
 =?UTF-8?q?=D1=80=D0=BD=D0=BE=D1=81=D1=82=D1=8C=D1=8E.=20=D0=A1=D0=B4?=
 =?UTF-8?q?=D0=B5=D0=BB=D0=B0=D0=BB=20=D0=BF=D0=B0=D1=80=D1=83=20=D0=BF?=
 =?UTF-8?q?=D1=80=D0=BE=D0=B2=D0=B5=D1=80=D0=BE=D1=87=D0=BD=D1=8B=D1=85=20?=
 =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82=D0=BE=D0=B2=20=D0=BD=D0=B0=20=D1=80?=
 =?UTF-8?q?=D0=B0=D0=B1=D0=BE=D1=82=D0=BE=D1=81=D0=BF=D0=BE=D1=81=D0=BE?=
 =?UTF-8?q?=D0=B1=D0=BD=D0=BE=D1=81=D1=82=D1=8C=20=D0=BA=D0=BB=D0=B0=D1=81?=
 =?UTF-8?q?=D1=81=D0=B0.=20=D0=9E=D1=81=D1=82=D0=B0=D0=BB=D0=BE=D1=81?=
 =?UTF-8?q?=D1=8C=20=D1=81=D0=B4=D0=B5=D0=BB=D0=B0=D1=82=D1=8C=20=D1=87?=
 =?UTF-8?q?=D1=82=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=B8=D0=B7=20=D1=81=D1=82?=
 =?UTF-8?q?=D1=80=D0=BE=D0=BA=D0=B8.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Dimension.java  |  98 +++++++++++
 src/main/java/ru/spbstu/kspt/task1/Main.java  |   4 +
 .../java/ru/spbstu/kspt/task1/Numbers.java    | 157 ++++++++++++++++++
 .../ru/spbstu/kspt/task1/DimensionTest.java   |  28 ++++
 .../ru/spbstu/kspt/task1/NumbersTest.java     |  61 +++++++
 5 files changed, 348 insertions(+)
 create mode 100644 src/main/java/ru/spbstu/kspt/task1/Dimension.java
 create mode 100644 src/main/java/ru/spbstu/kspt/task1/Numbers.java
 create mode 100644 src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
 create mode 100644 src/test/java/ru/spbstu/kspt/task1/NumbersTest.java

diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimension.java b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
new file mode 100644
index 0000000..229f470
--- /dev/null
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
@@ -0,0 +1,98 @@
+package ru.spbstu.kspt.task1;
+
+
+import jdk.nashorn.internal.codegen.MapCreator;
+
+import java.util.*;
+
+/**
+ * Класс размерности
+ * equalsDim - сравнение на принадлежность к одному классу
+ * power - вывод вещественного числа
+ */
+public class Dimension {
+
+    private String dim;
+
+    Dimension(){
+        dim = "м";
+    }
+
+    Dimension(String dim) {
+        this.dim = dim;
+    }
+
+    private static final Map<String,Double> metrs;
+    static {
+        metrs = new HashMap<>();
+        metrs.put("см",1.0);
+        metrs.put("дм",10.0);
+        metrs.put("м",100.0);
+        metrs.put("км",1000.0);
+    }
+
+    private static final Map<String,Double> time;
+    static {
+        time = new HashMap<>();
+        time.put("с",1.0);
+        time.put("м",60.0);
+        time.put("ч",3600.0);
+    }
+
+    private static final Map<String,Double> gramms;
+    static {
+        gramms = new HashMap<>();
+        gramms.put("мг",1.0);
+        gramms.put("г",1000.0);
+        gramms.put("кг",1000000.0);
+    }
+
+    private static final Map<Integer,Map<String,Double>> dimens;
+    static {
+        dimens = new HashMap<>();
+        dimens.put(1,metrs);
+        dimens.put(2,time);
+        dimens.put(3,gramms);
+    }
+
+    String getDim() {
+        return dim;
+    }
+
+    boolean equalsDim (Dimension other) {
+        for (int i = 1; i <= dimens.size(); i++) {
+            if (dimens.get(i).containsKey(dim) && dimens.get(i).containsKey(other.dim)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    double power () {
+        for (int i = 1; i <= dimens.size(); i++) {
+            if (dimens.get(i).containsKey(dim)) {
+                return dimens.get(i).get(dim);
+            }
+        }
+        throw new IllegalArgumentException("Неверная размерность");
+    }
+
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj instanceof Dimension) {
+            Dimension other = (Dimension) obj;
+            return dim.equals(other.dim);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return "" + dim;
+    }
+
+
+
+}
diff --git a/src/main/java/ru/spbstu/kspt/task1/Main.java b/src/main/java/ru/spbstu/kspt/task1/Main.java
index 0b91675..9294335 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Main.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Main.java
@@ -14,3 +14,7 @@ public static void main(String[] args) {
         System.out.println("Hello World!");
     }
 }
+
+
+
+
diff --git a/src/main/java/ru/spbstu/kspt/task1/Numbers.java b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
new file mode 100644
index 0000000..649cab2
--- /dev/null
+++ b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
@@ -0,0 +1,157 @@
+package ru.spbstu.kspt.task1;
+
+/**
+ * Класс числа с размерностью
+ *
+ * plus - сложение размерных чисел
+ *
+ * minus - вычитание размерных чисел
+ *
+ * multiplication - умножение размерного числа на вещественное
+ *
+ * division - деление размерного числа на вещественное
+ *
+ * divisionForDim - деление размерных чисел
+ *
+ * whoIsBigger - нахождение наибольшего числа среди размерных чисел
+ *
+ * whoIsLess - нахождение наименьшего числа среди размерных чисел
+ *
+ * transfer - перевод размерного числа из одной размерности в другую
+ *
+ * equalsNum - сравнение размерных чисел
+ *
+ * Чтение из строки в разработке
+ */
+public class Numbers {
+
+    private double number;
+    private String dimen;
+
+    public double getNumber() {
+        return number;
+    }
+
+    public String getDimen() {
+        return dimen;
+    }
+
+    Numbers() {
+        number = 0;
+        dimen = "м";
+    }
+
+    Numbers(double number, String dimen) {
+        this.number = number;
+        this.dimen = dimen;
+    }
+
+    Numbers plus(Numbers other) {
+        if (new Dimension(dimen).equalsDim( new Dimension(other.dimen))) {
+            return new Numbers(number + other.number *
+                    (new Dimension(other.dimen).power() / new Dimension(dimen).power()), dimen);
+        }
+        else {
+            throw new IllegalArgumentException("Разные классы размерностей");
+        }
+    }
+
+    Numbers minus(Numbers other) {
+        if (new Dimension(dimen).equalsDim(new Dimension(other.dimen))) {
+            return new Numbers(number - other.number *
+                    (new Dimension(other.dimen).power() / new Dimension(dimen).power()), dimen);
+        }
+        else {
+            throw new IllegalArgumentException("Разные классы размерностей");
+        }
+    }
+
+    Numbers multiplication(double multi) {
+        return new Numbers(number * multi, dimen);
+    }
+
+    Numbers division(double div) {
+        return new Numbers(number / div, dimen);
+    }
+
+    Numbers divisionForDim(Numbers other) {
+        if (new Dimension(dimen).equalsDim(new Dimension(other.dimen))) {
+            return new Numbers(number /
+                    (other.number * (new Dimension(other.dimen).power() / new Dimension(dimen).power())), dimen);
+        }
+        else {
+            throw new IllegalArgumentException("Разные классы размерностей");
+        }
+    }
+
+
+    Numbers whoIsBigger (Numbers other) {
+        if (new Dimension (dimen).equalsDim(new Dimension(other.dimen))) {
+            if (number * new Dimension(dimen).power() >= other.number * new Dimension(other.dimen).power()) {
+                return this;
+            }
+            else {
+                return other;
+            }
+        }
+        else {
+            throw new IllegalArgumentException("Разные классы размерностей");
+        }
+    }
+
+    Numbers whoIsLess (Numbers other) {
+        if (new Dimension(dimen).equalsDim(new Dimension(other.dimen))) {
+            if (number * new Dimension(dimen).power() <= other.number * new Dimension(other.dimen).power()) {
+                return this;
+            }
+            else {
+                return other;
+            }
+        }
+        else {
+            throw new IllegalArgumentException("Разные классы размерностей");
+        }
+    }
+
+    Numbers transfer (String other) {
+        if (new Dimension(dimen).equalsDim(new Dimension(other))) {
+            if (dimen.equals(other)) {
+                return new Numbers(number *
+                        (new Dimension(other).power() / new Dimension(dimen).power()), other);
+            }
+            else {
+                System.out.println("Перевод не нуждается");
+                return this;
+            }
+        }
+        else {
+            throw new IllegalArgumentException("Разные классы размерностей");
+        }
+    }
+
+    boolean equalsNum (Numbers other) {
+        if (new Dimension(dimen).equalsDim(new Dimension(other.dimen))) {
+            return  (number == other.number * (new Dimension(other.dimen).power() / new Dimension(dimen).power()));
+        }
+        else {
+            throw new IllegalArgumentException("Разные классы размерностей");
+        }
+    }
+
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj instanceof Numbers) {
+            Numbers other = (Numbers) obj;
+            return number == other.number
+                    && dimen.equals(other.dimen);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString(){
+        return "" + number + " " + dimen;
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java b/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
new file mode 100644
index 0000000..db6f9f9
--- /dev/null
+++ b/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
@@ -0,0 +1,28 @@
+package ru.spbstu.kspt.task1;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DimensionTest {
+    @Test
+    void getDim() {
+    }
+
+    @Test
+    void equalsDim() {
+        assertTrue(new Dimension("м").equalsDim(new Dimension("км")));
+        assertTrue(new Dimension("м").equalsDim(new Dimension("см")));
+        assertTrue(new Dimension("г").equalsDim(new Dimension("кг")));
+    }
+
+    @Test
+    void power() {
+        assertEquals(1000.0, new Dimension("км").power());
+    }
+
+    @Test
+    void equals() {
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java b/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
new file mode 100644
index 0000000..9f08ee9
--- /dev/null
+++ b/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
@@ -0,0 +1,61 @@
+package ru.spbstu.kspt.task1;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class NumbersTest {
+    @Test
+    void getNumber() {
+        assertEquals(new Numbers(4.0,"кг"),
+                new Numbers(2.0,"кг").plus(new Numbers(2.0,"кг")));
+        assertEquals(new Numbers(2.002,"кг"),
+                new Numbers(2.0,"кг").plus(new Numbers(2.0,"г")));
+    }
+
+    @Test
+    void getDimen() {
+    }
+
+    @Test
+    void plus() {
+    }
+
+    @Test
+    void minus() {
+    }
+
+    @Test
+    void multiplication() {
+    }
+
+    @Test
+    void division() {
+    }
+
+    @Test
+    void divisionForDim() {
+    }
+
+    @Test
+    void whoIsBigger() {
+    }
+
+    @Test
+    void whoIsLess() {
+    }
+
+    @Test
+    void transfer() {
+    }
+
+    @Test
+    void equalsNum() {
+    }
+
+    @Test
+    void equals() {
+    }
+
+
+}
\ No newline at end of file

From f400c59a89ec9c8796d54f0997c802fa6613b9db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Wed, 28 Feb 2018 16:13:13 +0300
Subject: [PATCH 02/12] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B.=20=D0=98?=
 =?UTF-8?q?=D0=B7=D0=BC=D0=B5=D0=BD=D0=B8=D0=BD=D0=BE=20=D0=BD=D0=B0=D0=B7?=
 =?UTF-8?q?=D0=B2=D0=B0=D0=BD=D0=B8=D0=B5=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5?=
 =?UTF-8?q?=D1=80=D0=BD=D0=BE=D1=81=D1=82=D0=B8=20=D0=B2=20=D0=BA=D0=BB?=
 =?UTF-8?q?=D0=B0=D1=81=D1=81=D0=B5=20Numbers.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Dimension.java  |  2 +-
 .../java/ru/spbstu/kspt/task1/Numbers.java    | 54 +++++++++----------
 .../ru/spbstu/kspt/task1/DimensionTest.java   | 13 +++++
 .../ru/spbstu/kspt/task1/NumbersTest.java     | 52 +++++++++++++++---
 4 files changed, 87 insertions(+), 34 deletions(-)

diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimension.java b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
index 229f470..facc4f9 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Dimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
@@ -35,7 +35,7 @@ public class Dimension {
     static {
         time = new HashMap<>();
         time.put("с",1.0);
-        time.put("м",60.0);
+        time.put("мин",60.0);
         time.put("ч",3600.0);
     }
 
diff --git a/src/main/java/ru/spbstu/kspt/task1/Numbers.java b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
index 649cab2..d3dbc6e 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Numbers.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
@@ -26,30 +26,30 @@
 public class Numbers {
 
     private double number;
-    private String dimen;
+    private String dimension;
 
-    public double getNumber() {
+    double getNumber() {
         return number;
     }
 
-    public String getDimen() {
-        return dimen;
+    String getDimension() {
+        return dimension;
     }
 
     Numbers() {
         number = 0;
-        dimen = "м";
+        dimension = "м";
     }
 
-    Numbers(double number, String dimen) {
+    Numbers(double number, String dimension) {
         this.number = number;
-        this.dimen = dimen;
+        this.dimension = dimension;
     }
 
     Numbers plus(Numbers other) {
-        if (new Dimension(dimen).equalsDim( new Dimension(other.dimen))) {
+        if (new Dimension(dimension).equalsDim( new Dimension(other.dimension))) {
             return new Numbers(number + other.number *
-                    (new Dimension(other.dimen).power() / new Dimension(dimen).power()), dimen);
+                    (new Dimension(other.dimension).power() / new Dimension(dimension).power()), dimension);
         }
         else {
             throw new IllegalArgumentException("Разные классы размерностей");
@@ -57,9 +57,9 @@ Numbers plus(Numbers other) {
     }
 
     Numbers minus(Numbers other) {
-        if (new Dimension(dimen).equalsDim(new Dimension(other.dimen))) {
+        if (new Dimension(dimension).equalsDim(new Dimension(other.dimension))) {
             return new Numbers(number - other.number *
-                    (new Dimension(other.dimen).power() / new Dimension(dimen).power()), dimen);
+                    (new Dimension(other.dimension).power() / new Dimension(dimension).power()), dimension);
         }
         else {
             throw new IllegalArgumentException("Разные классы размерностей");
@@ -67,17 +67,17 @@ Numbers minus(Numbers other) {
     }
 
     Numbers multiplication(double multi) {
-        return new Numbers(number * multi, dimen);
+        return new Numbers(number * multi, dimension);
     }
 
     Numbers division(double div) {
-        return new Numbers(number / div, dimen);
+        return new Numbers(number / div, dimension);
     }
 
     Numbers divisionForDim(Numbers other) {
-        if (new Dimension(dimen).equalsDim(new Dimension(other.dimen))) {
-            return new Numbers(number /
-                    (other.number * (new Dimension(other.dimen).power() / new Dimension(dimen).power())), dimen);
+        if (new Dimension(dimension).equalsDim(new Dimension(other.dimension))) {
+            return new Numbers(number / (other.number *
+                    (new Dimension(other.dimension).power() / new Dimension(dimension).power())), dimension);
         }
         else {
             throw new IllegalArgumentException("Разные классы размерностей");
@@ -86,8 +86,8 @@ Numbers divisionForDim(Numbers other) {
 
 
     Numbers whoIsBigger (Numbers other) {
-        if (new Dimension (dimen).equalsDim(new Dimension(other.dimen))) {
-            if (number * new Dimension(dimen).power() >= other.number * new Dimension(other.dimen).power()) {
+        if (new Dimension (dimension).equalsDim(new Dimension(other.dimension))) {
+            if (number * new Dimension(dimension).power() >= other.number * new Dimension(other.dimension).power()) {
                 return this;
             }
             else {
@@ -100,8 +100,8 @@ Numbers whoIsBigger (Numbers other) {
     }
 
     Numbers whoIsLess (Numbers other) {
-        if (new Dimension(dimen).equalsDim(new Dimension(other.dimen))) {
-            if (number * new Dimension(dimen).power() <= other.number * new Dimension(other.dimen).power()) {
+        if (new Dimension(dimension).equalsDim(new Dimension(other.dimension))) {
+            if (number * new Dimension(dimension).power() <= other.number * new Dimension(other.dimension).power()) {
                 return this;
             }
             else {
@@ -114,10 +114,10 @@ Numbers whoIsLess (Numbers other) {
     }
 
     Numbers transfer (String other) {
-        if (new Dimension(dimen).equalsDim(new Dimension(other))) {
-            if (dimen.equals(other)) {
+        if (new Dimension(dimension).equalsDim(new Dimension(other))) {
+            if (!dimension.equals(other)) {
                 return new Numbers(number *
-                        (new Dimension(other).power() / new Dimension(dimen).power()), other);
+                        (new Dimension(dimension).power() / new Dimension(other).power()), other);
             }
             else {
                 System.out.println("Перевод не нуждается");
@@ -130,8 +130,8 @@ Numbers transfer (String other) {
     }
 
     boolean equalsNum (Numbers other) {
-        if (new Dimension(dimen).equalsDim(new Dimension(other.dimen))) {
-            return  (number == other.number * (new Dimension(other.dimen).power() / new Dimension(dimen).power()));
+        if (new Dimension(dimension).equalsDim(new Dimension(other.dimension))) {
+            return (number == other.number * (new Dimension(other.dimension).power() / new Dimension(dimension).power()));
         }
         else {
             throw new IllegalArgumentException("Разные классы размерностей");
@@ -145,13 +145,13 @@ public boolean equals(Object obj) {
         if (obj instanceof Numbers) {
             Numbers other = (Numbers) obj;
             return number == other.number
-                    && dimen.equals(other.dimen);
+                    && dimension.equals(other.dimension);
         }
         return false;
     }
 
     @Override
     public String toString(){
-        return "" + number + " " + dimen;
+        return "" + number + " " + dimension;
     }
 }
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java b/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
index db6f9f9..b4136fc 100644
--- a/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
+++ b/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
@@ -7,6 +7,13 @@
 class DimensionTest {
     @Test
     void getDim() {
+        assertEquals("км", new Dimension("км").getDim());
+        assertEquals("м", new Dimension("м").getDim());
+        assertEquals("дм", new Dimension("дм").getDim());
+        assertEquals("см", new Dimension("см").getDim());
+        assertEquals("ч", new Dimension("ч").getDim());
+        assertEquals("мин", new Dimension("мин").getDim());
+        assertEquals("с", new Dimension("с").getDim());
     }
 
     @Test
@@ -19,6 +26,12 @@ void equalsDim() {
     @Test
     void power() {
         assertEquals(1000.0, new Dimension("км").power());
+        assertEquals(100.0, new Dimension("м").power());
+        assertEquals(10.0, new Dimension("дм").power());
+        assertEquals(1.0, new Dimension("см").power());
+        assertEquals(3600.0, new Dimension("ч").power());
+        assertEquals(60.0, new Dimension("мин").power());
+        assertEquals(1.0, new Dimension("с").power());
     }
 
     @Test
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java b/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
index 9f08ee9..81a709d 100644
--- a/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
+++ b/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
@@ -7,55 +7,95 @@
 class NumbersTest {
     @Test
     void getNumber() {
-        assertEquals(new Numbers(4.0,"кг"),
-                new Numbers(2.0,"кг").plus(new Numbers(2.0,"кг")));
-        assertEquals(new Numbers(2.002,"кг"),
-                new Numbers(2.0,"кг").plus(new Numbers(2.0,"г")));
+        assertEquals(2434.0,
+                new Numbers(2434.0,"кг").getNumber());
+        assertEquals(2.0,
+                new Numbers(2.0,"кг").getNumber());
     }
 
     @Test
-    void getDimen() {
+    void getDimension() {
+        assertEquals("кг",
+                new Numbers(2.0,"кг").getDimension());
+        assertEquals("мин",
+                new Numbers(2.0,"мин").getDimension());
     }
 
     @Test
     void plus() {
+        assertEquals(new Numbers(4.0,"кг"),
+                new Numbers(2.0,"кг").plus(new Numbers(2.0,"кг")));
+        assertEquals(new Numbers(2.002,"кг"),
+                new Numbers(2.0,"кг").plus(new Numbers(2.0,"г")));
     }
 
     @Test
     void minus() {
+        assertEquals(new Numbers(0.0,"кг"),
+                new Numbers(2.0,"кг").minus(new Numbers(2.0,"кг")));
+        assertEquals(new Numbers(1.998,"кг"),
+                new Numbers(2.0,"кг").minus(new Numbers(2.0,"г")));
     }
 
     @Test
     void multiplication() {
+        assertEquals(new Numbers(5.0,"кг"),
+                new Numbers(2.0,"кг").multiplication(2.5));
+        assertEquals(new Numbers(8.0,"кг"),
+                new Numbers(2.0,"кг").multiplication(4.0));
     }
 
     @Test
     void division() {
+        assertEquals(new Numbers(2.0,"кг"),
+                new Numbers(4.0,"кг").division(2.0));
+        assertEquals(new Numbers(2.0,"кг"),
+                new Numbers(27.0,"кг").division(13.5));
     }
 
     @Test
     void divisionForDim() {
+        assertEquals(new Numbers(4.0,"кг"),
+                new Numbers(2.0,"кг").plus(new Numbers(2.0,"кг")));
+        assertEquals(new Numbers(2.002,"кг"),
+                new Numbers(2.0,"кг").plus(new Numbers(2.0,"г")));
     }
 
     @Test
     void whoIsBigger() {
+        assertEquals(new Numbers(4.0,"кг"),
+                new Numbers(4.0,"кг").whoIsBigger(new Numbers(2.0,"кг")));
+        assertEquals(new Numbers(12000.0,"г"),
+                new Numbers(2.0,"кг").whoIsBigger(new Numbers(12000.0,"г")));
     }
 
     @Test
     void whoIsLess() {
+        assertEquals(new Numbers(2.0,"кг"),
+                new Numbers(4.0,"кг").whoIsLess(new Numbers(2.0,"кг")));
+        assertEquals(new Numbers(2.0,"кг"),
+                new Numbers(2.0,"кг").whoIsLess(new Numbers(12000.0,"г")));
     }
 
     @Test
     void transfer() {
+        assertEquals(new Numbers(2000.0,"г"),
+                new Numbers(2.0,"кг").transfer("г"));
+        assertEquals(new Numbers(120,"с"),
+                new Numbers(2.0,"мин").transfer("с"));
     }
 
     @Test
     void equalsNum() {
+        assertTrue(new Numbers(2.0,"кг").equalsNum(new Numbers(2.0,"кг")));
+        assertTrue(new Numbers(2.0,"кг").equalsNum(new Numbers(2000.0,"г")));
+        assertTrue(new Numbers(2.0,"мин").equalsNum(new Numbers(120.0,"с")));
+        assertTrue(new Numbers(2.0,"м").equalsNum(new Numbers(20.0,"дм")));
+        assertFalse(new Numbers(20.0,"мин").equalsNum(new Numbers(120.0,"с")));
     }
 
     @Test
     void equals() {
     }
 
-
 }
\ No newline at end of file

From f76d261a4606972aee3656e790ebcdca20d1d307 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Wed, 28 Feb 2018 16:28:14 +0300
Subject: [PATCH 03/12] =?UTF-8?q?=D0=98=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5?=
 =?UTF-8?q?=D0=BD=20=D1=82=D0=B8=D0=BF=20=D1=80=D0=B5=D0=B7=D1=83=D0=BB?=
 =?UTF-8?q?=D1=8C=D1=82=D0=B0=D1=82=D0=B0=20=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD?=
 =?UTF-8?q?=D0=B8=D1=8F=20=D0=BD=D0=B0=20=D1=87=D0=B8=D1=81=D0=BB=D0=BE=20?=
 =?UTF-8?q?=D1=81=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5=D1=80=D0=BD=D0=BE=D1=81?=
 =?UTF-8?q?=D1=82=D1=8C=D1=8E.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/ru/spbstu/kspt/task1/Numbers.java     | 5 ++---
 src/test/java/ru/spbstu/kspt/task1/NumbersTest.java | 8 ++++----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/main/java/ru/spbstu/kspt/task1/Numbers.java b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
index d3dbc6e..842bac8 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Numbers.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
@@ -74,10 +74,9 @@ Numbers division(double div) {
         return new Numbers(number / div, dimension);
     }
 
-    Numbers divisionForDim(Numbers other) {
+    double divisionForDim(Numbers other) {
         if (new Dimension(dimension).equalsDim(new Dimension(other.dimension))) {
-            return new Numbers(number / (other.number *
-                    (new Dimension(other.dimension).power() / new Dimension(dimension).power())), dimension);
+            return number / (other.number * (new Dimension(other.dimension).power() / new Dimension(dimension).power()));
         }
         else {
             throw new IllegalArgumentException("Разные классы размерностей");
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java b/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
index 81a709d..27388d0 100644
--- a/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
+++ b/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
@@ -55,10 +55,10 @@ void division() {
 
     @Test
     void divisionForDim() {
-        assertEquals(new Numbers(4.0,"кг"),
-                new Numbers(2.0,"кг").plus(new Numbers(2.0,"кг")));
-        assertEquals(new Numbers(2.002,"кг"),
-                new Numbers(2.0,"кг").plus(new Numbers(2.0,"г")));
+        assertEquals(1000.0,
+                new Numbers(2.0,"кг").divisionForDim(new Numbers(2.0,"г")));
+        assertEquals(2.0,
+                new Numbers(4.0,"кг").divisionForDim(new Numbers(2.0,"кг")));
     }
 
     @Test

From 225f7bb8974e4022f32ba16837bfe2d20e547bdb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Wed, 28 Feb 2018 16:48:54 +0300
Subject: [PATCH 04/12] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20hashCode()=20=D0=B4=D0=BB=D1=8F=20=D0=BA?=
 =?UTF-8?q?=D0=B0=D0=B6=D0=B4=D0=BE=D0=B3=D0=BE=20=D0=BA=D0=BB=D0=B0=D1=81?=
 =?UTF-8?q?=D1=81=D0=B0.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Dimension.java   | 18 +++++++++++-------
 .../java/ru/spbstu/kspt/task1/Numbers.java     | 10 ++++++++++
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimension.java b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
index facc4f9..f6cc704 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Dimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
@@ -77,15 +77,19 @@ boolean equalsDim (Dimension other) {
         throw new IllegalArgumentException("Неверная размерность");
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Dimension dimension = (Dimension) o;
+
+        return dim != null ? dim.equals(dimension.dim) : dimension.dim == null;
+    }
 
     @Override
-    public boolean equals(Object obj) {
-        if (this == obj) return true;
-        if (obj instanceof Dimension) {
-            Dimension other = (Dimension) obj;
-            return dim.equals(other.dim);
-        }
-        return false;
+    public int hashCode() {
+        return dim != null ? dim.hashCode() : 0;
     }
 
     @Override
diff --git a/src/main/java/ru/spbstu/kspt/task1/Numbers.java b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
index 842bac8..69bf4c6 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Numbers.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
@@ -149,6 +149,16 @@ public boolean equals(Object obj) {
         return false;
     }
 
+    @Override
+    public int hashCode() {
+        int result;
+        long temp;
+        temp = Double.doubleToLongBits(number);
+        result = (int) (temp ^ (temp >>> 32));
+        result = 31 * result + (dimension != null ? dimension.hashCode() : 0);
+        return result;
+    }
+
     @Override
     public String toString(){
         return "" + number + " " + dimension;

From 74cc2ada385288bd72e539b0a366b6f29b1331f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Thu, 1 Mar 2018 22:44:30 +0300
Subject: [PATCH 05/12] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8?=
 =?UTF-8?q?=D0=BB=20=D1=84=D0=BE=D1=80=D0=BC=D0=B0=D1=82=D0=B8=D1=80=D0=BE?=
 =?UTF-8?q?=D0=B2=D0=B0=D0=BD=D0=B8=D0=B5.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Numbers.java    | 52 +++++++++++--------
 1 file changed, 29 insertions(+), 23 deletions(-)

diff --git a/src/main/java/ru/spbstu/kspt/task1/Numbers.java b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
index 69bf4c6..3ebb870 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Numbers.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
@@ -26,8 +26,11 @@
 public class Numbers {
 
     private double number;
+
     private String dimension;
 
+    private Dimension dimensionClass = new Dimension(dimension);
+
     double getNumber() {
         return number;
     }
@@ -39,17 +42,19 @@ String getDimension() {
     Numbers() {
         number = 0;
         dimension = "м";
+        dimensionClass = new Dimension(dimension);
     }
 
     Numbers(double number, String dimension) {
         this.number = number;
         this.dimension = dimension;
+        this.dimensionClass = new Dimension(dimension);
     }
 
     Numbers plus(Numbers other) {
-        if (new Dimension(dimension).equalsDim( new Dimension(other.dimension))) {
+        if (dimensionClass.equalsDim(other.dimensionClass)) {
             return new Numbers(number + other.number *
-                    (new Dimension(other.dimension).power() / new Dimension(dimension).power()), dimension);
+                    (other.dimensionClass.power() / dimensionClass.power()), dimension);
         }
         else {
             throw new IllegalArgumentException("Разные классы размерностей");
@@ -57,9 +62,9 @@ Numbers plus(Numbers other) {
     }
 
     Numbers minus(Numbers other) {
-        if (new Dimension(dimension).equalsDim(new Dimension(other.dimension))) {
+        if (dimensionClass.equalsDim(other.dimensionClass)) {
             return new Numbers(number - other.number *
-                    (new Dimension(other.dimension).power() / new Dimension(dimension).power()), dimension);
+                    (other.dimensionClass.power() / dimensionClass.power()), dimension);
         }
         else {
             throw new IllegalArgumentException("Разные классы размерностей");
@@ -75,8 +80,8 @@ Numbers division(double div) {
     }
 
     double divisionForDim(Numbers other) {
-        if (new Dimension(dimension).equalsDim(new Dimension(other.dimension))) {
-            return number / (other.number * (new Dimension(other.dimension).power() / new Dimension(dimension).power()));
+        if (dimensionClass.equalsDim(other.dimensionClass)) {
+            return number / (other.number * (other.dimensionClass.power() / dimensionClass.power()));
         }
         else {
             throw new IllegalArgumentException("Разные классы размерностей");
@@ -85,8 +90,8 @@ Numbers division(double div) {
 
 
     Numbers whoIsBigger (Numbers other) {
-        if (new Dimension (dimension).equalsDim(new Dimension(other.dimension))) {
-            if (number * new Dimension(dimension).power() >= other.number * new Dimension(other.dimension).power()) {
+        if (dimensionClass.equalsDim(other.dimensionClass)) {
+            if (number * dimensionClass.power() >= other.number * other.dimensionClass.power()) {
                 return this;
             }
             else {
@@ -99,8 +104,8 @@ Numbers whoIsBigger (Numbers other) {
     }
 
     Numbers whoIsLess (Numbers other) {
-        if (new Dimension(dimension).equalsDim(new Dimension(other.dimension))) {
-            if (number * new Dimension(dimension).power() <= other.number * new Dimension(other.dimension).power()) {
+        if (dimensionClass.equalsDim(other.dimensionClass)) {
+            if (number * dimensionClass.power() <= other.number * other.dimensionClass.power()) {
                 return this;
             }
             else {
@@ -113,13 +118,12 @@ Numbers whoIsLess (Numbers other) {
     }
 
     Numbers transfer (String other) {
-        if (new Dimension(dimension).equalsDim(new Dimension(other))) {
+        if (dimensionClass.equalsDim(new Dimension(other))) {
             if (!dimension.equals(other)) {
                 return new Numbers(number *
-                        (new Dimension(dimension).power() / new Dimension(other).power()), other);
+                        (dimensionClass.power() / new Dimension(other).power()), other);
             }
             else {
-                System.out.println("Перевод не нуждается");
                 return this;
             }
         }
@@ -129,8 +133,8 @@ Numbers transfer (String other) {
     }
 
     boolean equalsNum (Numbers other) {
-        if (new Dimension(dimension).equalsDim(new Dimension(other.dimension))) {
-            return (number == other.number * (new Dimension(other.dimension).power() / new Dimension(dimension).power()));
+        if (dimensionClass.equalsDim(other.dimensionClass)) {
+            return (number == other.number * (other.dimensionClass.power() / dimensionClass.power()));
         }
         else {
             throw new IllegalArgumentException("Разные классы размерностей");
@@ -139,14 +143,15 @@ boolean equalsNum (Numbers other) {
 
 
     @Override
-    public boolean equals(Object obj) {
-        if (this == obj) return true;
-        if (obj instanceof Numbers) {
-            Numbers other = (Numbers) obj;
-            return number == other.number
-                    && dimension.equals(other.dimension);
-        }
-        return false;
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Numbers numbers = (Numbers) o;
+
+        if (Double.compare(numbers.number, number) != 0) return false;
+        if (dimension != null ? !dimension.equals(numbers.dimension) : numbers.dimension != null) return false;
+        return dimensionClass != null ? dimensionClass.equals(numbers.dimensionClass) : numbers.dimensionClass == null;
     }
 
     @Override
@@ -156,6 +161,7 @@ public int hashCode() {
         temp = Double.doubleToLongBits(number);
         result = (int) (temp ^ (temp >>> 32));
         result = 31 * result + (dimension != null ? dimension.hashCode() : 0);
+        result = 31 * result + (dimensionClass != null ? dimensionClass.hashCode() : 0);
         return result;
     }
 

From b8dda450b09901270f17277cc31a3aec20b3332a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Tue, 6 Mar 2018 22:52:00 +0300
Subject: [PATCH 06/12] =?UTF-8?q?=D0=9F=D0=B5=D1=80=D0=B5=D0=B4=D0=B5?=
 =?UTF-8?q?=D0=BB=D0=B0=D0=BB=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Dimension.java  |  79 +++-----
 .../kspt/task1/NumberWithDimension.java       | 102 +++++++++++
 .../java/ru/spbstu/kspt/task1/Numbers.java    | 172 ------------------
 .../ru/spbstu/kspt/task1/DimensionTest.java   |  30 +--
 .../kspt/task1/NumberWithDimension.java       |  69 +++++++
 .../ru/spbstu/kspt/task1/NumbersTest.java     | 101 ----------
 6 files changed, 194 insertions(+), 359 deletions(-)
 create mode 100644 src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
 delete mode 100644 src/main/java/ru/spbstu/kspt/task1/Numbers.java
 create mode 100644 src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
 delete mode 100644 src/test/java/ru/spbstu/kspt/task1/NumbersTest.java

diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimension.java b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
index f6cc704..916f024 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Dimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
@@ -7,74 +7,40 @@
 
 /**
  * Класс размерности
- * equalsDim - сравнение на принадлежность к одному классу
- * power - вывод вещественного числа
  */
 public class Dimension {
 
-    private String dim;
-
     Dimension(){
-        dim = "м";
-    }
 
-    Dimension(String dim) {
-        this.dim = dim;
     }
 
-    private static final Map<String,Double> metrs;
-    static {
-        metrs = new HashMap<>();
-        metrs.put("см",1.0);
-        metrs.put("дм",10.0);
-        metrs.put("м",100.0);
-        metrs.put("км",1000.0);
+    private Map<String,Double> dimens;
+    {
+        dimens = new HashMap<>();
     }
 
-    private static final Map<String,Double> time;
-    static {
-        time = new HashMap<>();
-        time.put("с",1.0);
-        time.put("мин",60.0);
-        time.put("ч",3600.0);
+    Dimension getLengthDimensions() {
+        return new Dimension().addDimension("км",1000).addDimension("м",100).
+                addDimension("дм",10).addDimension("см",1);
     }
 
-    private static final Map<String,Double> gramms;
-    static {
-        gramms = new HashMap<>();
-        gramms.put("мг",1.0);
-        gramms.put("г",1000.0);
-        gramms.put("кг",1000000.0);
+    Dimension getTimeDimensions() {
+        return new Dimension().addDimension("с",1).addDimension("мин",60).
+                addDimension("ч",3600);
     }
 
-    private static final Map<Integer,Map<String,Double>> dimens;
-    static {
-        dimens = new HashMap<>();
-        dimens.put(1,metrs);
-        dimens.put(2,time);
-        dimens.put(3,gramms);
+    Dimension getWeightDimensions() {
+        return new Dimension().addDimension("кг",1000000).addDimension("г",1000).
+                addDimension("мг",1);
     }
 
-    String getDim() {
-        return dim;
+    Dimension addDimension(String name, double coefficient) {
+        dimens.put(name, coefficient);
+        return this;
     }
 
-    boolean equalsDim (Dimension other) {
-        for (int i = 1; i <= dimens.size(); i++) {
-            if (dimens.get(i).containsKey(dim) && dimens.get(i).containsKey(other.dim)){
-                return true;
-            }
-        }
-        return false;
-    }
-
-    double power () {
-        for (int i = 1; i <= dimens.size(); i++) {
-            if (dimens.get(i).containsKey(dim)) {
-                return dimens.get(i).get(dim);
-            }
-        }
-        throw new IllegalArgumentException("Неверная размерность");
+    double getValue (String dimension){
+        return dimens.get(dimension);
     }
 
     @Override
@@ -84,19 +50,18 @@ public boolean equals(Object o) {
 
         Dimension dimension = (Dimension) o;
 
-        return dim != null ? dim.equals(dimension.dim) : dimension.dim == null;
+        return dimens != null ? dimens.equals(dimension.dimens) : dimension.dimens == null;
     }
 
     @Override
     public int hashCode() {
-        return dim != null ? dim.hashCode() : 0;
+        return dimens != null ? dimens.hashCode() : 0;
     }
 
     @Override
     public String toString() {
-        return "" + dim;
+        return "Dimension{" +
+                "dimens=" + dimens +
+                '}';
     }
-
-
-
 }
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
new file mode 100644
index 0000000..93217fa
--- /dev/null
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -0,0 +1,102 @@
+package ru.spbstu.kspt.task1;
+
+import com.sun.javafx.image.PixelConverter;
+
+/**
+ * Класс числа с размерностью
+ *
+ * plus - сложение размерных чисел
+ *
+ * minus - вычитание размерных чисел
+ *
+ * multiply - умножение размерного числа на вещественное
+ *
+ * divide - деление размерного числа на вещественное
+ *
+ * divideForDim - деление размерных чисел
+ */
+class NumberWithDimension {
+
+    private double number;
+
+    private String dimension;
+
+    private Dimension dimensionClass;
+
+    double getNumber() {
+        return number;
+    }
+
+    Dimension getDimensionClass() {
+        return dimensionClass;
+    }
+
+    String getDimension() {
+        return dimension;
+    }
+
+    NumberWithDimension(double number, String dimension, Dimension dimensionClasses) {
+        this.number = number;
+        this.dimension = dimension;
+        this.dimensionClass = dimensionClasses;
+    }
+
+    NumberWithDimension plus(NumberWithDimension other) { // Сложение размерных чисел
+            return new NumberWithDimension(number + other.number *
+                    (other.dimensionClass.getValue(other.dimension) /
+                            dimensionClass.getValue(dimension)), dimension, dimensionClass);
+    }
+
+    NumberWithDimension minus(NumberWithDimension other) { // Вычитание размерных чисел
+        return new NumberWithDimension(number - other.number *
+                (other.dimensionClass.getValue(other.dimension) /
+                        dimensionClass.getValue(dimension)), dimension, dimensionClass);
+    }
+
+    NumberWithDimension multiply(double multi) {
+        return new NumberWithDimension(number * multi, dimension, dimensionClass);
+    }
+
+    NumberWithDimension divide(double div) {
+        return new NumberWithDimension(number / div, dimension, dimensionClass);
+    }
+
+    double divideForDim(NumberWithDimension other) {
+        return number / (other.number * (other.dimensionClass.getValue(other.dimension) /
+                dimensionClass.getValue(other.dimension)));
+    }
+
+    NumberWithDimension transfer (String other) {
+        return new NumberWithDimension(number *
+                (dimensionClass.getValue(dimension) / dimensionClass.getValue(other)), other, dimensionClass);
+    }
+
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        NumberWithDimension numbers = (NumberWithDimension) o;
+
+        if (Double.compare(numbers.number, number) != 0) return false;
+        if (dimension != null ? !dimension.equals(numbers.dimension) : numbers.dimension != null) return false;
+        return dimensionClass != null ? dimensionClass.equals(numbers.dimensionClass) : numbers.dimensionClass == null;
+    }
+
+    @Override
+    public int hashCode() {
+        int result;
+        long temp;
+        temp = Double.doubleToLongBits(number);
+        result = (int) (temp ^ (temp >>> 32));
+        result = 31 * result + (dimension != null ? dimension.hashCode() : 0);
+        result = 31 * result + (dimensionClass != null ? dimensionClass.hashCode() : 0);
+        return result;
+    }
+
+    @Override
+    public String toString(){
+        return "" + number + " " + dimension;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/ru/spbstu/kspt/task1/Numbers.java b/src/main/java/ru/spbstu/kspt/task1/Numbers.java
deleted file mode 100644
index 3ebb870..0000000
--- a/src/main/java/ru/spbstu/kspt/task1/Numbers.java
+++ /dev/null
@@ -1,172 +0,0 @@
-package ru.spbstu.kspt.task1;
-
-/**
- * Класс числа с размерностью
- *
- * plus - сложение размерных чисел
- *
- * minus - вычитание размерных чисел
- *
- * multiplication - умножение размерного числа на вещественное
- *
- * division - деление размерного числа на вещественное
- *
- * divisionForDim - деление размерных чисел
- *
- * whoIsBigger - нахождение наибольшего числа среди размерных чисел
- *
- * whoIsLess - нахождение наименьшего числа среди размерных чисел
- *
- * transfer - перевод размерного числа из одной размерности в другую
- *
- * equalsNum - сравнение размерных чисел
- *
- * Чтение из строки в разработке
- */
-public class Numbers {
-
-    private double number;
-
-    private String dimension;
-
-    private Dimension dimensionClass = new Dimension(dimension);
-
-    double getNumber() {
-        return number;
-    }
-
-    String getDimension() {
-        return dimension;
-    }
-
-    Numbers() {
-        number = 0;
-        dimension = "м";
-        dimensionClass = new Dimension(dimension);
-    }
-
-    Numbers(double number, String dimension) {
-        this.number = number;
-        this.dimension = dimension;
-        this.dimensionClass = new Dimension(dimension);
-    }
-
-    Numbers plus(Numbers other) {
-        if (dimensionClass.equalsDim(other.dimensionClass)) {
-            return new Numbers(number + other.number *
-                    (other.dimensionClass.power() / dimensionClass.power()), dimension);
-        }
-        else {
-            throw new IllegalArgumentException("Разные классы размерностей");
-        }
-    }
-
-    Numbers minus(Numbers other) {
-        if (dimensionClass.equalsDim(other.dimensionClass)) {
-            return new Numbers(number - other.number *
-                    (other.dimensionClass.power() / dimensionClass.power()), dimension);
-        }
-        else {
-            throw new IllegalArgumentException("Разные классы размерностей");
-        }
-    }
-
-    Numbers multiplication(double multi) {
-        return new Numbers(number * multi, dimension);
-    }
-
-    Numbers division(double div) {
-        return new Numbers(number / div, dimension);
-    }
-
-    double divisionForDim(Numbers other) {
-        if (dimensionClass.equalsDim(other.dimensionClass)) {
-            return number / (other.number * (other.dimensionClass.power() / dimensionClass.power()));
-        }
-        else {
-            throw new IllegalArgumentException("Разные классы размерностей");
-        }
-    }
-
-
-    Numbers whoIsBigger (Numbers other) {
-        if (dimensionClass.equalsDim(other.dimensionClass)) {
-            if (number * dimensionClass.power() >= other.number * other.dimensionClass.power()) {
-                return this;
-            }
-            else {
-                return other;
-            }
-        }
-        else {
-            throw new IllegalArgumentException("Разные классы размерностей");
-        }
-    }
-
-    Numbers whoIsLess (Numbers other) {
-        if (dimensionClass.equalsDim(other.dimensionClass)) {
-            if (number * dimensionClass.power() <= other.number * other.dimensionClass.power()) {
-                return this;
-            }
-            else {
-                return other;
-            }
-        }
-        else {
-            throw new IllegalArgumentException("Разные классы размерностей");
-        }
-    }
-
-    Numbers transfer (String other) {
-        if (dimensionClass.equalsDim(new Dimension(other))) {
-            if (!dimension.equals(other)) {
-                return new Numbers(number *
-                        (dimensionClass.power() / new Dimension(other).power()), other);
-            }
-            else {
-                return this;
-            }
-        }
-        else {
-            throw new IllegalArgumentException("Разные классы размерностей");
-        }
-    }
-
-    boolean equalsNum (Numbers other) {
-        if (dimensionClass.equalsDim(other.dimensionClass)) {
-            return (number == other.number * (other.dimensionClass.power() / dimensionClass.power()));
-        }
-        else {
-            throw new IllegalArgumentException("Разные классы размерностей");
-        }
-    }
-
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        Numbers numbers = (Numbers) o;
-
-        if (Double.compare(numbers.number, number) != 0) return false;
-        if (dimension != null ? !dimension.equals(numbers.dimension) : numbers.dimension != null) return false;
-        return dimensionClass != null ? dimensionClass.equals(numbers.dimensionClass) : numbers.dimensionClass == null;
-    }
-
-    @Override
-    public int hashCode() {
-        int result;
-        long temp;
-        temp = Double.doubleToLongBits(number);
-        result = (int) (temp ^ (temp >>> 32));
-        result = 31 * result + (dimension != null ? dimension.hashCode() : 0);
-        result = 31 * result + (dimensionClass != null ? dimensionClass.hashCode() : 0);
-        return result;
-    }
-
-    @Override
-    public String toString(){
-        return "" + number + " " + dimension;
-    }
-}
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java b/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
index b4136fc..a78a6a2 100644
--- a/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
+++ b/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
@@ -6,36 +6,8 @@
 
 class DimensionTest {
     @Test
-    void getDim() {
-        assertEquals("км", new Dimension("км").getDim());
-        assertEquals("м", new Dimension("м").getDim());
-        assertEquals("дм", new Dimension("дм").getDim());
-        assertEquals("см", new Dimension("см").getDim());
-        assertEquals("ч", new Dimension("ч").getDim());
-        assertEquals("мин", new Dimension("мин").getDim());
-        assertEquals("с", new Dimension("с").getDim());
+    void getValue() {
     }
 
-    @Test
-    void equalsDim() {
-        assertTrue(new Dimension("м").equalsDim(new Dimension("км")));
-        assertTrue(new Dimension("м").equalsDim(new Dimension("см")));
-        assertTrue(new Dimension("г").equalsDim(new Dimension("кг")));
-    }
-
-    @Test
-    void power() {
-        assertEquals(1000.0, new Dimension("км").power());
-        assertEquals(100.0, new Dimension("м").power());
-        assertEquals(10.0, new Dimension("дм").power());
-        assertEquals(1.0, new Dimension("см").power());
-        assertEquals(3600.0, new Dimension("ч").power());
-        assertEquals(60.0, new Dimension("мин").power());
-        assertEquals(1.0, new Dimension("с").power());
-    }
-
-    @Test
-    void equals() {
-    }
 
 }
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
new file mode 100644
index 0000000..130b8e2
--- /dev/null
+++ b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -0,0 +1,69 @@
+package ru.spbstu.kspt.task1;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class NumberWithDimensionTest {
+    @Test
+    void getNumber() {
+    }
+
+    @Test
+    void getDimension() {
+    }
+
+    @Test
+    void plus() {
+        assertEquals(new NumberWithDimension(4.0,"км", new Dimension().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",  new Dimension().getLengthDimensions()).
+                        plus(new NumberWithDimension(2.0,"км",
+                                new Dimension().getLengthDimensions())));
+    }
+
+    @Test
+    void minus() {
+        assertEquals(new NumberWithDimension(4.0,"км", new Dimension().getLengthDimensions()),
+                new NumberWithDimension(6.0,"км",  new Dimension().getLengthDimensions())
+                        .minus(new NumberWithDimension(2.0,"км",
+                                new Dimension().getLengthDimensions())));
+    }
+
+    @Test
+    void multiply() {
+        assertEquals(new NumberWithDimension(26.0,"км", new Dimension().getLengthDimensions()),
+                new NumberWithDimension(1.0,"км",  new Dimension().getLengthDimensions())
+                        .multiply(26.0));
+        assertEquals(new NumberWithDimension(29.0,"м", new Dimension().getLengthDimensions()),
+                new NumberWithDimension(1.0,"м",  new Dimension().getLengthDimensions())
+                        .multiply(29.0));
+    }
+
+    @Test
+    void divide() {
+        assertEquals(new NumberWithDimension(5.0,"км", new Dimension().getLengthDimensions()),
+                new NumberWithDimension(25.0,"км",  new Dimension().getLengthDimensions())
+                        .divide(5.0));
+        assertEquals(new NumberWithDimension(5.0,"м", new Dimension().getLengthDimensions()),
+                new NumberWithDimension(30.0,"м",  new Dimension().getLengthDimensions())
+                        .divide(6.0));
+    }
+
+    @Test
+    void divideForDim() {
+        assertEquals(10.0,
+                new NumberWithDimension(25.0,"км",  new Dimension().getLengthDimensions())
+                        .divideForDim(new NumberWithDimension(2.5,"км",
+                                new Dimension().getLengthDimensions())));
+    }
+
+    @Test
+    void transfer() {
+    }
+
+
+    @Test
+    void equals() {
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java b/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
deleted file mode 100644
index 27388d0..0000000
--- a/src/test/java/ru/spbstu/kspt/task1/NumbersTest.java
+++ /dev/null
@@ -1,101 +0,0 @@
-package ru.spbstu.kspt.task1;
-
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class NumbersTest {
-    @Test
-    void getNumber() {
-        assertEquals(2434.0,
-                new Numbers(2434.0,"кг").getNumber());
-        assertEquals(2.0,
-                new Numbers(2.0,"кг").getNumber());
-    }
-
-    @Test
-    void getDimension() {
-        assertEquals("кг",
-                new Numbers(2.0,"кг").getDimension());
-        assertEquals("мин",
-                new Numbers(2.0,"мин").getDimension());
-    }
-
-    @Test
-    void plus() {
-        assertEquals(new Numbers(4.0,"кг"),
-                new Numbers(2.0,"кг").plus(new Numbers(2.0,"кг")));
-        assertEquals(new Numbers(2.002,"кг"),
-                new Numbers(2.0,"кг").plus(new Numbers(2.0,"г")));
-    }
-
-    @Test
-    void minus() {
-        assertEquals(new Numbers(0.0,"кг"),
-                new Numbers(2.0,"кг").minus(new Numbers(2.0,"кг")));
-        assertEquals(new Numbers(1.998,"кг"),
-                new Numbers(2.0,"кг").minus(new Numbers(2.0,"г")));
-    }
-
-    @Test
-    void multiplication() {
-        assertEquals(new Numbers(5.0,"кг"),
-                new Numbers(2.0,"кг").multiplication(2.5));
-        assertEquals(new Numbers(8.0,"кг"),
-                new Numbers(2.0,"кг").multiplication(4.0));
-    }
-
-    @Test
-    void division() {
-        assertEquals(new Numbers(2.0,"кг"),
-                new Numbers(4.0,"кг").division(2.0));
-        assertEquals(new Numbers(2.0,"кг"),
-                new Numbers(27.0,"кг").division(13.5));
-    }
-
-    @Test
-    void divisionForDim() {
-        assertEquals(1000.0,
-                new Numbers(2.0,"кг").divisionForDim(new Numbers(2.0,"г")));
-        assertEquals(2.0,
-                new Numbers(4.0,"кг").divisionForDim(new Numbers(2.0,"кг")));
-    }
-
-    @Test
-    void whoIsBigger() {
-        assertEquals(new Numbers(4.0,"кг"),
-                new Numbers(4.0,"кг").whoIsBigger(new Numbers(2.0,"кг")));
-        assertEquals(new Numbers(12000.0,"г"),
-                new Numbers(2.0,"кг").whoIsBigger(new Numbers(12000.0,"г")));
-    }
-
-    @Test
-    void whoIsLess() {
-        assertEquals(new Numbers(2.0,"кг"),
-                new Numbers(4.0,"кг").whoIsLess(new Numbers(2.0,"кг")));
-        assertEquals(new Numbers(2.0,"кг"),
-                new Numbers(2.0,"кг").whoIsLess(new Numbers(12000.0,"г")));
-    }
-
-    @Test
-    void transfer() {
-        assertEquals(new Numbers(2000.0,"г"),
-                new Numbers(2.0,"кг").transfer("г"));
-        assertEquals(new Numbers(120,"с"),
-                new Numbers(2.0,"мин").transfer("с"));
-    }
-
-    @Test
-    void equalsNum() {
-        assertTrue(new Numbers(2.0,"кг").equalsNum(new Numbers(2.0,"кг")));
-        assertTrue(new Numbers(2.0,"кг").equalsNum(new Numbers(2000.0,"г")));
-        assertTrue(new Numbers(2.0,"мин").equalsNum(new Numbers(120.0,"с")));
-        assertTrue(new Numbers(2.0,"м").equalsNum(new Numbers(20.0,"дм")));
-        assertFalse(new Numbers(20.0,"мин").equalsNum(new Numbers(120.0,"с")));
-    }
-
-    @Test
-    void equals() {
-    }
-
-}
\ No newline at end of file

From f31f0da840d21e4028ab273d16813d6544809fbe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Wed, 7 Mar 2018 00:02:34 +0300
Subject: [PATCH 07/12] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BD=D0=BE=D0=B2=D1=8B=D0=B5=20=D1=82?=
 =?UTF-8?q?=D0=B5=D1=81=D1=82=D1=8B=20+=20=D1=84=D1=83=D0=BD=D0=BA=D1=86?=
 =?UTF-8?q?=D0=B8=D1=8F=20compareTo().?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Dimension.java  |  5 +-
 .../kspt/task1/NumberWithDimension.java       | 15 +++-
 .../kspt/task1/NumberWithDimension.java       | 86 ++++++++++++++++++-
 3 files changed, 94 insertions(+), 12 deletions(-)

diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimension.java b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
index 916f024..464e385 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Dimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
@@ -1,8 +1,5 @@
 package ru.spbstu.kspt.task1;
 
-
-import jdk.nashorn.internal.codegen.MapCreator;
-
 import java.util.*;
 
 /**
@@ -20,7 +17,7 @@ public class Dimension {
     }
 
     Dimension getLengthDimensions() {
-        return new Dimension().addDimension("км",1000).addDimension("м",100).
+        return new Dimension().addDimension("км",100000).addDimension("м",100).
                 addDimension("дм",10).addDimension("см",1);
     }
 
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
index 93217fa..2e3dbd8 100644
--- a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -1,7 +1,5 @@
 package ru.spbstu.kspt.task1;
 
-import com.sun.javafx.image.PixelConverter;
-
 /**
  * Класс числа с размерностью
  *
@@ -15,7 +13,7 @@
  *
  * divideForDim - деление размерных чисел
  */
-class NumberWithDimension {
+class NumberWithDimension implements Comparable<NumberWithDimension> {
 
     private double number;
 
@@ -66,12 +64,21 @@ NumberWithDimension divide(double div) {
                 dimensionClass.getValue(other.dimension)));
     }
 
-    NumberWithDimension transfer (String other) {
+    NumberWithDimension translate (String other) { //Переводим вещественное число из одной величины в другую
         return new NumberWithDimension(number *
                 (dimensionClass.getValue(dimension) / dimensionClass.getValue(other)), other, dimensionClass);
     }
 
 
+
+    @Override
+    public int compareTo(NumberWithDimension other) { //Cравниваем два числа, подводя их под одну величину
+        return (number * dimensionClass.getValue(dimension)) > (other.number
+                * other.dimensionClass.getValue(other.dimension)) ? 1 : (number
+                * dimensionClass.getValue(dimension)) == (other.number
+                * other.dimensionClass.getValue(other.dimension)) ? 0 : -1;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
index 130b8e2..59602ce 100644
--- a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
+++ b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -7,18 +7,34 @@
 class NumberWithDimensionTest {
     @Test
     void getNumber() {
+        assertEquals(2.0,
+                new NumberWithDimension(2.0,"км",  new Dimension().getLengthDimensions())
+                        .getNumber());
     }
 
     @Test
     void getDimension() {
+        assertEquals("км",
+                new NumberWithDimension(2.0,"км",  new Dimension().getLengthDimensions())
+                        .getDimension());
     }
 
     @Test
     void plus() {
         assertEquals(new NumberWithDimension(4.0,"км", new Dimension().getLengthDimensions()),
-                new NumberWithDimension(2.0,"км",  new Dimension().getLengthDimensions()).
-                        plus(new NumberWithDimension(2.0,"км",
+                new NumberWithDimension(2.0,"км",  new Dimension().getLengthDimensions())
+                        .plus(new NumberWithDimension(2.0,"км",
                                 new Dimension().getLengthDimensions())));
+        assertEquals(new NumberWithDimension(4.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                        .addDimension("А",1).addDimension("мА",0.001)),
+                new NumberWithDimension(2.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                        .addDimension("А",1).addDimension("мА",0.001))
+                        .plus(new NumberWithDimension(2.0,"А",
+                                new Dimension().addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
     }
 
     @Test
@@ -27,6 +43,16 @@ void minus() {
                 new NumberWithDimension(6.0,"км",  new Dimension().getLengthDimensions())
                         .minus(new NumberWithDimension(2.0,"км",
                                 new Dimension().getLengthDimensions())));
+        assertEquals(new NumberWithDimension(5.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001)),
+                new NumberWithDimension(15.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001))
+                        .minus(new NumberWithDimension(10.0,"А",
+                                new Dimension().addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
     }
 
     @Test
@@ -37,6 +63,13 @@ void multiply() {
         assertEquals(new NumberWithDimension(29.0,"м", new Dimension().getLengthDimensions()),
                 new NumberWithDimension(1.0,"м",  new Dimension().getLengthDimensions())
                         .multiply(29.0));
+        assertEquals(new NumberWithDimension(51.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001)),
+                new NumberWithDimension(2.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001))
+                        .multiply(25.5));
     }
 
     @Test
@@ -47,6 +80,13 @@ void divide() {
         assertEquals(new NumberWithDimension(5.0,"м", new Dimension().getLengthDimensions()),
                 new NumberWithDimension(30.0,"м",  new Dimension().getLengthDimensions())
                         .divide(6.0));
+        assertEquals(new NumberWithDimension(2.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001)),
+                new NumberWithDimension(12.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001))
+                        .divide(6.0));
     }
 
     @Test
@@ -55,15 +95,53 @@ void divideForDim() {
                 new NumberWithDimension(25.0,"км",  new Dimension().getLengthDimensions())
                         .divideForDim(new NumberWithDimension(2.5,"км",
                                 new Dimension().getLengthDimensions())));
+        assertEquals(5.5,
+                new NumberWithDimension(11.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001))
+                        .divideForDim(new NumberWithDimension(2.0,"А",
+                                new Dimension().addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
     }
 
     @Test
-    void transfer() {
+    void translate() {
+        assertEquals(new NumberWithDimension(2000.0,"мА",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001)),
+                new NumberWithDimension(2.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001))
+                        .translate("мА"));
+        assertEquals(new NumberWithDimension(6000.0,"м", new Dimension().getLengthDimensions()),
+                new NumberWithDimension(6.0,"км",  new Dimension().getLengthDimensions())
+                        .translate("м"));
     }
 
 
     @Test
-    void equals() {
+    void compareTo() {
+        assertEquals(0,
+                new NumberWithDimension(25.0,"м",  new Dimension().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(0.025,"км",
+                                new Dimension().getLengthDimensions())));
+        assertEquals(1,
+                new NumberWithDimension(25.0,"м",  new Dimension().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(0.024,"км",
+                                new Dimension().getLengthDimensions())));
+        assertEquals(-1,
+                new NumberWithDimension(25.0,"м",  new Dimension().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(0.026,"км",
+                                new Dimension().getLengthDimensions())));
+        assertEquals(1,
+                new NumberWithDimension(2.0,"А",
+                        new Dimension().addDimension("кА",1000)
+                                .addDimension("А",1).addDimension("мА",0.001))
+                        .compareTo(new NumberWithDimension(2.0,"мА",
+                                new Dimension().addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
     }
 
 }
\ No newline at end of file

From 0298296dfe0b8994ef9f0894adb58c91eceb21ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Fri, 9 Mar 2018 00:51:57 +0300
Subject: [PATCH 08/12] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D1=8B=20=D0=BD=D0=B5=D0=BA=D0=BE=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D1=8B=D0=B5=20=D0=BD=D0=B5=D0=B4=D0=BE=D1=87=D1=91=D1=82?=
 =?UTF-8?q?=D1=8B.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Dimension.java  | 13 ++++--
 .../kspt/task1/NumberWithDimension.java       | 46 ++++++++++---------
 .../ru/spbstu/kspt/task1/DimensionTest.java   |  9 +++-
 3 files changed, 39 insertions(+), 29 deletions(-)

diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimension.java b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
index 464e385..dbe6160 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Dimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
@@ -36,8 +36,13 @@ Dimension addDimension(String name, double coefficient) {
         return this;
     }
 
-    double getValue (String dimension){
-        return dimens.get(dimension);
+    double getValueDimension(String dimension) {
+        try {
+            return dimens.get(dimension);
+        }
+        catch (NullPointerException e) {
+            throw new NullPointerException("Размерности не совпадают");
+        }
     }
 
     @Override
@@ -57,8 +62,6 @@ public int hashCode() {
 
     @Override
     public String toString() {
-        return "Dimension{" +
-                "dimens=" + dimens +
-                '}';
+        return "Dimension{" + dimens + '}';
     }
 }
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
index 2e3dbd8..5560c1a 100644
--- a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -1,5 +1,8 @@
 package ru.spbstu.kspt.task1;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
 /**
  * Класс числа с размерностью
  *
@@ -25,58 +28,57 @@ class NumberWithDimension implements Comparable<NumberWithDimension> {
         return number;
     }
 
-    Dimension getDimensionClass() {
-        return dimensionClass;
-    }
-
     String getDimension() {
         return dimension;
     }
 
-    NumberWithDimension(double number, String dimension, Dimension dimensionClasses) {
+    Dimension getDimensionClass() {
+        return dimensionClass;
+    }
+
+    NumberWithDimension(double number, String dimension, Dimension dimensionClass) {
         this.number = number;
         this.dimension = dimension;
-        this.dimensionClass = dimensionClasses;
+        this.dimensionClass = dimensionClass;
     }
 
     NumberWithDimension plus(NumberWithDimension other) { // Сложение размерных чисел
             return new NumberWithDimension(number + other.number *
-                    (other.dimensionClass.getValue(other.dimension) /
-                            dimensionClass.getValue(dimension)), dimension, dimensionClass);
+                    (other.dimensionClass.getValueDimension(other.dimension) /
+                            dimensionClass.getValueDimension(dimension)), dimension, dimensionClass);
     }
 
     NumberWithDimension minus(NumberWithDimension other) { // Вычитание размерных чисел
         return new NumberWithDimension(number - other.number *
-                (other.dimensionClass.getValue(other.dimension) /
-                        dimensionClass.getValue(dimension)), dimension, dimensionClass);
+                (other.dimensionClass.getValueDimension(other.dimension) /
+                        dimensionClass.getValueDimension(dimension)), dimension, dimensionClass);
     }
 
-    NumberWithDimension multiply(double multi) {
+    NumberWithDimension multiply(double multi) { // Умножение на вещественное число
         return new NumberWithDimension(number * multi, dimension, dimensionClass);
     }
 
-    NumberWithDimension divide(double div) {
+    NumberWithDimension divide(double div) { // Деление на вещественное число
         return new NumberWithDimension(number / div, dimension, dimensionClass);
     }
 
-    double divideForDim(NumberWithDimension other) {
-        return number / (other.number * (other.dimensionClass.getValue(other.dimension) /
-                dimensionClass.getValue(other.dimension)));
+    double divideForDim(NumberWithDimension other) { // Деление на другое число с размерностью
+        return number / (other.number * (other.dimensionClass.getValueDimension(other.dimension) /
+                dimensionClass.getValueDimension(other.dimension)));
     }
 
     NumberWithDimension translate (String other) { //Переводим вещественное число из одной величины в другую
         return new NumberWithDimension(number *
-                (dimensionClass.getValue(dimension) / dimensionClass.getValue(other)), other, dimensionClass);
+                (dimensionClass.getValueDimension(dimension) / dimensionClass.getValueDimension(other)),
+                other, dimensionClass);
     }
 
-
-
     @Override
     public int compareTo(NumberWithDimension other) { //Cравниваем два числа, подводя их под одну величину
-        return (number * dimensionClass.getValue(dimension)) > (other.number
-                * other.dimensionClass.getValue(other.dimension)) ? 1 : (number
-                * dimensionClass.getValue(dimension)) == (other.number
-                * other.dimensionClass.getValue(other.dimension)) ? 0 : -1;
+        return (number * dimensionClass.getValueDimension(dimension)) > (other.number
+                * other.dimensionClass.getValueDimension(other.dimension)) ? 1 : (number
+                * dimensionClass.getValueDimension(dimension)) == (other.number
+                * other.dimensionClass.getValueDimension(other.dimension)) ? 0 : -1;
     }
 
     @Override
diff --git a/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java b/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
index a78a6a2..c3dd82e 100644
--- a/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
+++ b/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
@@ -6,8 +6,13 @@
 
 class DimensionTest {
     @Test
-    void getValue() {
+    void getValueDimension() {
+        assertEquals(100000, new Dimension().getLengthDimensions().getValueDimension("км"));
+        assertEquals(1000000, new Dimension().getWeightDimensions().getValueDimension("кг"));
+        assertEquals(3600, new Dimension().getTimeDimensions().getValueDimension("ч"));
+        assertEquals(1, new Dimension().getLengthDimensions().getValueDimension("см"));
+        assertEquals(1000, new Dimension().getWeightDimensions().getValueDimension("г"));
+        assertEquals(60, new Dimension().getTimeDimensions().getValueDimension("мин"));
     }
 
-
 }
\ No newline at end of file

From 3a2ac408df2165b969508981e8a375ec9f8d461f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Sat, 10 Mar 2018 04:30:28 +0300
Subject: [PATCH 09/12] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=B8=D0=BD=D1=82=D0=B5=D1=80=D1=84=D0=B5=D0=B9?=
 =?UTF-8?q?=D1=81.=20=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5=D0=BD=20Lo?=
 =?UTF-8?q?gger=20=D0=B2=20=D1=82=D0=B5=D1=81=D1=82=D1=8B.=20=D0=98=D1=81?=
 =?UTF-8?q?=D0=BF=D1=80=D0=B0=D0=B2=D0=BB=D0=B5=D0=BD=D1=8B=20=D0=BD=D0=B5?=
 =?UTF-8?q?=D0=BA=D0=BE=D1=82=D0=BE=D1=80=D1=8B=D0=B5=20=D0=BD=D0=B5=D1=82?=
 =?UTF-8?q?=D0=BE=D1=87=D0=BD=D0=BE=D1=81=D1=82=D0=B8.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Dimension.java  |  3 ++
 .../kspt/task1/NumberWithDimension.java       | 32 ++++++++-----
 .../task1/NumberWithDimensionInterface.java   | 20 ++++++++
 .../kspt/task1/NumberWithDimension.java       | 47 ++++++++++++++++---
 4 files changed, 82 insertions(+), 20 deletions(-)
 create mode 100644 src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java

diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimension.java b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
index dbe6160..fd3bfb2 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Dimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
@@ -1,5 +1,8 @@
 package ru.spbstu.kspt.task1;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
 import java.util.*;
 
 /**
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
index 5560c1a..bbfa515 100644
--- a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -3,6 +3,8 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import java.util.logging.Level;
+
 /**
  * Класс числа с размерностью
  *
@@ -16,7 +18,7 @@
  *
  * divideForDim - деление размерных чисел
  */
-class NumberWithDimension implements Comparable<NumberWithDimension> {
+class NumberWithDimension implements Comparable<NumberWithDimension>, NumberWithDimensionInterface {
 
     private double number;
 
@@ -24,50 +26,54 @@ class NumberWithDimension implements Comparable<NumberWithDimension> {
 
     private Dimension dimensionClass;
 
-    double getNumber() {
+    @Override
+    public double getNumber() {
         return number;
     }
 
-    String getDimension() {
+    @Override
+    public String getDimension() {
         return dimension;
     }
 
-    Dimension getDimensionClass() {
-        return dimensionClass;
-    }
-
     NumberWithDimension(double number, String dimension, Dimension dimensionClass) {
         this.number = number;
         this.dimension = dimension;
         this.dimensionClass = dimensionClass;
     }
 
-    NumberWithDimension plus(NumberWithDimension other) { // Сложение размерных чисел
+    @Override
+    public NumberWithDimension plus(NumberWithDimension other) { // Сложение размерных чисел
             return new NumberWithDimension(number + other.number *
                     (other.dimensionClass.getValueDimension(other.dimension) /
                             dimensionClass.getValueDimension(dimension)), dimension, dimensionClass);
     }
 
-    NumberWithDimension minus(NumberWithDimension other) { // Вычитание размерных чисел
+    @Override
+    public NumberWithDimension minus(NumberWithDimension other) { // Вычитание размерных чисел
         return new NumberWithDimension(number - other.number *
                 (other.dimensionClass.getValueDimension(other.dimension) /
                         dimensionClass.getValueDimension(dimension)), dimension, dimensionClass);
     }
 
-    NumberWithDimension multiply(double multi) { // Умножение на вещественное число
+    @Override
+    public NumberWithDimension multiply(double multi) { // Умножение на вещественное число
         return new NumberWithDimension(number * multi, dimension, dimensionClass);
     }
 
-    NumberWithDimension divide(double div) { // Деление на вещественное число
+    @Override
+    public NumberWithDimension divide(double div) { // Деление на вещественное число
         return new NumberWithDimension(number / div, dimension, dimensionClass);
     }
 
-    double divideForDim(NumberWithDimension other) { // Деление на другое число с размерностью
+    @Override
+    public double divideForDim(NumberWithDimension other) { // Деление на другое число с размерностью
         return number / (other.number * (other.dimensionClass.getValueDimension(other.dimension) /
                 dimensionClass.getValueDimension(other.dimension)));
     }
 
-    NumberWithDimension translate (String other) { //Переводим вещественное число из одной величины в другую
+    @Override
+    public NumberWithDimension translation (String other) { //Переводим вещественное число из одной величины в другую
         return new NumberWithDimension(number *
                 (dimensionClass.getValueDimension(dimension) / dimensionClass.getValueDimension(other)),
                 other, dimensionClass);
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java
new file mode 100644
index 0000000..3b06b44
--- /dev/null
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java
@@ -0,0 +1,20 @@
+package ru.spbstu.kspt.task1;
+
+interface NumberWithDimensionInterface {
+
+    double getNumber(); // Взятие вещественного числа из класса
+
+    String getDimension(); // Взятие размерности из класса в строковой форме
+
+    NumberWithDimension plus(NumberWithDimension other); // Сложение двух вещественных чисел с размерностью
+
+    NumberWithDimension minus(NumberWithDimension other); // Вычитание двух вещественных чисел с размерностью
+
+    NumberWithDimension multiply(double multi); // Умножение числа с размерностью на вещественное число
+
+    NumberWithDimension divide(double div); // Деление числа с размерностью на вещественное число
+
+    double divideForDim(NumberWithDimension other); // Деление двух вещественных чисел с размерностью
+
+    NumberWithDimension translation (String other); // Перевод числа с размерностью из одной величины в другую
+}
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
index 59602ce..da83470 100644
--- a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
+++ b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -1,10 +1,16 @@
 package ru.spbstu.kspt.task1;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.*;
 
 class NumberWithDimensionTest {
+
+    private static final Logger logger = LogManager.getLogger(NumberWithDimensionTest.class);
+
+
     @Test
     void getNumber() {
         assertEquals(2.0,
@@ -21,10 +27,14 @@ void getDimension() {
 
     @Test
     void plus() {
+        logger.info("Начало теста на сложение с вещественным числом с размерностью, " +
+                "используя уже приготовленные размерности.");
         assertEquals(new NumberWithDimension(4.0,"км", new Dimension().getLengthDimensions()),
                 new NumberWithDimension(2.0,"км",  new Dimension().getLengthDimensions())
                         .plus(new NumberWithDimension(2.0,"км",
                                 new Dimension().getLengthDimensions())));
+        logger.info("Начало теста на сложение вещественного числа с размерностью, " +
+                "используя размерности, написанные пользователем.");
         assertEquals(new NumberWithDimension(4.0,"А",
                         new Dimension().addDimension("кА",1000)
                         .addDimension("А",1).addDimension("мА",0.001)),
@@ -35,14 +45,19 @@ void plus() {
                                 new Dimension().addDimension("кА",1000)
                                         .addDimension("А",1)
                                         .addDimension("мА",0.001))));
+        logger.info("Тест на сложение с вещественным числом с размерностью пройдены.");
     }
 
     @Test
     void minus() {
+        logger.info("Начало теста на вычитание вещественного числа с размерностью, " +
+                "используя уже приготовленные размерности.");
         assertEquals(new NumberWithDimension(4.0,"км", new Dimension().getLengthDimensions()),
                 new NumberWithDimension(6.0,"км",  new Dimension().getLengthDimensions())
                         .minus(new NumberWithDimension(2.0,"км",
                                 new Dimension().getLengthDimensions())));
+        logger.info("Начало теста на вычитание вещественного числа с размерностью, " +
+                "используя размерности, написанные пользователем.");
         assertEquals(new NumberWithDimension(5.0,"А",
                         new Dimension().addDimension("кА",1000)
                                 .addDimension("А",1).addDimension("мА",0.001)),
@@ -53,16 +68,19 @@ void minus() {
                                 new Dimension().addDimension("кА",1000)
                                         .addDimension("А",1)
                                         .addDimension("мА",0.001))));
+        logger.info("Тест на вычитание с вещественным числом с размерностью пройдены.");
     }
 
     @Test
     void multiply() {
+        logger.info("Начало теста на умножение на вещественное число, используя уже приготовленные размерности.");
         assertEquals(new NumberWithDimension(26.0,"км", new Dimension().getLengthDimensions()),
                 new NumberWithDimension(1.0,"км",  new Dimension().getLengthDimensions())
                         .multiply(26.0));
         assertEquals(new NumberWithDimension(29.0,"м", new Dimension().getLengthDimensions()),
                 new NumberWithDimension(1.0,"м",  new Dimension().getLengthDimensions())
                         .multiply(29.0));
+        logger.info("Начало теста на умножение на вещественное число, используя размерности, написанные пользователем.");
         assertEquals(new NumberWithDimension(51.0,"А",
                         new Dimension().addDimension("кА",1000)
                                 .addDimension("А",1).addDimension("мА",0.001)),
@@ -70,16 +88,19 @@ void multiply() {
                         new Dimension().addDimension("кА",1000)
                                 .addDimension("А",1).addDimension("мА",0.001))
                         .multiply(25.5));
+        logger.info("Тест на умножение на вещественное число пройдены.");
     }
 
     @Test
     void divide() {
+        logger.info("Начало теста на деление на вещественное число, используя уже приготовленные размерности.");
         assertEquals(new NumberWithDimension(5.0,"км", new Dimension().getLengthDimensions()),
                 new NumberWithDimension(25.0,"км",  new Dimension().getLengthDimensions())
                         .divide(5.0));
         assertEquals(new NumberWithDimension(5.0,"м", new Dimension().getLengthDimensions()),
                 new NumberWithDimension(30.0,"м",  new Dimension().getLengthDimensions())
                         .divide(6.0));
+        logger.info("Начало теста на деление на вещественное число, используя размерности, написанные пользователем.");
         assertEquals(new NumberWithDimension(2.0,"А",
                         new Dimension().addDimension("кА",1000)
                                 .addDimension("А",1).addDimension("мА",0.001)),
@@ -87,41 +108,52 @@ void divide() {
                         new Dimension().addDimension("кА",1000)
                                 .addDimension("А",1).addDimension("мА",0.001))
                         .divide(6.0));
+        logger.info("Тест на деление на вещественное число пройдены.");
     }
 
     @Test
     void divideForDim() {
+        logger.info("Начало теста на деление на вещественное число с размерностью, " +
+                "используя уже приготовленные размерности.");
         assertEquals(10.0,
                 new NumberWithDimension(25.0,"км",  new Dimension().getLengthDimensions())
                         .divideForDim(new NumberWithDimension(2.5,"км",
                                 new Dimension().getLengthDimensions())));
-        assertEquals(5.5,
-                new NumberWithDimension(11.0,"А",
+        logger.info("Начало теста на деление на вещественное число с размерностью, " +
+                "используя размерности, написанные пользователем.");
+        assertEquals(5.5, new NumberWithDimension(11.0,"А",
                         new Dimension().addDimension("кА",1000)
                                 .addDimension("А",1).addDimension("мА",0.001))
                         .divideForDim(new NumberWithDimension(2.0,"А",
                                 new Dimension().addDimension("кА",1000)
                                         .addDimension("А",1)
                                         .addDimension("мА",0.001))));
+        logger.info("Тест на деление на вещественное число с размерностью пройдены.");
     }
 
     @Test
-    void translate() {
+    void translation() {
+        logger.info("Начало теста на перевод вещественного числа с размерностью, " +
+                "используя размерности, написанные пользователем.");
         assertEquals(new NumberWithDimension(2000.0,"мА",
                         new Dimension().addDimension("кА",1000)
                                 .addDimension("А",1).addDimension("мА",0.001)),
                 new NumberWithDimension(2.0,"А",
                         new Dimension().addDimension("кА",1000)
                                 .addDimension("А",1).addDimension("мА",0.001))
-                        .translate("мА"));
+                        .translation("мА"));
+        logger.info("Начало теста на перевод вещественного числа с размерностью, " +
+                "используя уже приготовленные размерности.");
         assertEquals(new NumberWithDimension(6000.0,"м", new Dimension().getLengthDimensions()),
                 new NumberWithDimension(6.0,"км",  new Dimension().getLengthDimensions())
-                        .translate("м"));
+                        .translation("м"));
+        logger.info("Тест на перевод чисел с размерностью пройдены.");
     }
 
 
     @Test
     void compareTo() {
+        logger.info("Начало теста на сравнение между числами, используя уже приготовленные размерности.");
         assertEquals(0,
                 new NumberWithDimension(25.0,"м",  new Dimension().getLengthDimensions())
                         .compareTo(new NumberWithDimension(0.025,"км",
@@ -134,14 +166,15 @@ void compareTo() {
                 new NumberWithDimension(25.0,"м",  new Dimension().getLengthDimensions())
                         .compareTo(new NumberWithDimension(0.026,"км",
                                 new Dimension().getLengthDimensions())));
-        assertEquals(1,
-                new NumberWithDimension(2.0,"А",
+        logger.info("Начало теста на сравнение между числами, используя размерности, написанные пользователем.");
+        assertEquals(1, new NumberWithDimension(2.0,"А",
                         new Dimension().addDimension("кА",1000)
                                 .addDimension("А",1).addDimension("мА",0.001))
                         .compareTo(new NumberWithDimension(2.0,"мА",
                                 new Dimension().addDimension("кА",1000)
                                         .addDimension("А",1)
                                         .addDimension("мА",0.001))));
+        logger.info("Тест на сравнение пройдены.");
     }
 
 }
\ No newline at end of file

From c785c1d266e5f82e7e8ebf99a6b4907285e17d4b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Sat, 10 Mar 2018 11:08:55 +0300
Subject: [PATCH 10/12] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=B0=20=D0=BF=D0=BE=D0=B2=D0=B5=D1=80=D0=BA=D0=B0?=
 =?UTF-8?q?=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5=D1=80=D0=BD=D0=BE=D1=81=D1=82?=
 =?UTF-8?q?=D0=B5=D0=B9.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Dimension.java  |  4 +++
 .../kspt/task1/NumberWithDimension.java       | 25 +++++++++++++++----
 2 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimension.java b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
index fd3bfb2..420b038 100644
--- a/src/main/java/ru/spbstu/kspt/task1/Dimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
@@ -19,6 +19,10 @@ public class Dimension {
         dimens = new HashMap<>();
     }
 
+    Map<String, Double> getDimens() {
+        return dimens;
+    }
+
     Dimension getLengthDimensions() {
         return new Dimension().addDimension("км",100000).addDimension("м",100).
                 addDimension("дм",10).addDimension("см",1);
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
index bbfa515..43d8f9c 100644
--- a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -44,16 +44,26 @@ public String getDimension() {
 
     @Override
     public NumberWithDimension plus(NumberWithDimension other) { // Сложение размерных чисел
+        if(dimensionClass.getDimens().equals(other.dimensionClass.getDimens())) {
             return new NumberWithDimension(number + other.number *
                     (other.dimensionClass.getValueDimension(other.dimension) /
                             dimensionClass.getValueDimension(dimension)), dimension, dimensionClass);
+        }
+        else {
+            throw new IllegalArgumentException("Размерности не совпадают");
+        }
     }
 
     @Override
     public NumberWithDimension minus(NumberWithDimension other) { // Вычитание размерных чисел
-        return new NumberWithDimension(number - other.number *
-                (other.dimensionClass.getValueDimension(other.dimension) /
-                        dimensionClass.getValueDimension(dimension)), dimension, dimensionClass);
+        if(dimensionClass.getDimens().equals(other.dimensionClass.getDimens())) {
+            return new NumberWithDimension(number - other.number *
+                    (other.dimensionClass.getValueDimension(other.dimension) /
+                            dimensionClass.getValueDimension(dimension)), dimension, dimensionClass);
+        }
+        else {
+            throw new IllegalArgumentException("Размерности не совпадают");
+        }
     }
 
     @Override
@@ -68,8 +78,13 @@ public NumberWithDimension divide(double div) { // Деление на веще
 
     @Override
     public double divideForDim(NumberWithDimension other) { // Деление на другое число с размерностью
-        return number / (other.number * (other.dimensionClass.getValueDimension(other.dimension) /
-                dimensionClass.getValueDimension(other.dimension)));
+        if(dimensionClass.getDimens().equals(other.dimensionClass.getDimens())) {
+            return number / (other.number * (other.dimensionClass.getValueDimension(other.dimension) /
+                    dimensionClass.getValueDimension(other.dimension)));
+        }
+        else {
+            throw new IllegalArgumentException("Размерности не совпадают");
+        }
     }
 
     @Override

From 5e045667259b720d793647ed9a42daab1a5b98d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Sun, 11 Mar 2018 15:39:35 +0300
Subject: [PATCH 11/12] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=B7=D0=B0=D0=BC=D0=B5=D1=87?=
 =?UTF-8?q?=D0=B0=D0=BD=D0=B8=D0=B9.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/ru/spbstu/kspt/task1/Dimension.java  |  74 -----
 .../java/ru/spbstu/kspt/task1/Dimensions.java |  62 ++++
 .../kspt/task1/NumberWithDimension.java       |  95 +++---
 .../task1/NumberWithDimensionInterface.java   |  48 ++-
 .../ru/spbstu/kspt/task1/DimensionTest.java   |  18 --
 .../ru/spbstu/kspt/task1/DimensionsTest.java  |  26 ++
 .../kspt/task1/NumberWithDimension.java       | 180 ------------
 .../kspt/task1/NumberWithDimensionTest.java   | 276 ++++++++++++++++++
 8 files changed, 441 insertions(+), 338 deletions(-)
 delete mode 100644 src/main/java/ru/spbstu/kspt/task1/Dimension.java
 create mode 100644 src/main/java/ru/spbstu/kspt/task1/Dimensions.java
 delete mode 100644 src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
 create mode 100644 src/test/java/ru/spbstu/kspt/task1/DimensionsTest.java
 delete mode 100644 src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
 create mode 100644 src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java

diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimension.java b/src/main/java/ru/spbstu/kspt/task1/Dimension.java
deleted file mode 100644
index 420b038..0000000
--- a/src/main/java/ru/spbstu/kspt/task1/Dimension.java
+++ /dev/null
@@ -1,74 +0,0 @@
-package ru.spbstu.kspt.task1;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import java.util.*;
-
-/**
- * Класс размерности
- */
-public class Dimension {
-
-    Dimension(){
-
-    }
-
-    private Map<String,Double> dimens;
-    {
-        dimens = new HashMap<>();
-    }
-
-    Map<String, Double> getDimens() {
-        return dimens;
-    }
-
-    Dimension getLengthDimensions() {
-        return new Dimension().addDimension("км",100000).addDimension("м",100).
-                addDimension("дм",10).addDimension("см",1);
-    }
-
-    Dimension getTimeDimensions() {
-        return new Dimension().addDimension("с",1).addDimension("мин",60).
-                addDimension("ч",3600);
-    }
-
-    Dimension getWeightDimensions() {
-        return new Dimension().addDimension("кг",1000000).addDimension("г",1000).
-                addDimension("мг",1);
-    }
-
-    Dimension addDimension(String name, double coefficient) {
-        dimens.put(name, coefficient);
-        return this;
-    }
-
-    double getValueDimension(String dimension) {
-        try {
-            return dimens.get(dimension);
-        }
-        catch (NullPointerException e) {
-            throw new NullPointerException("Размерности не совпадают");
-        }
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        Dimension dimension = (Dimension) o;
-
-        return dimens != null ? dimens.equals(dimension.dimens) : dimension.dimens == null;
-    }
-
-    @Override
-    public int hashCode() {
-        return dimens != null ? dimens.hashCode() : 0;
-    }
-
-    @Override
-    public String toString() {
-        return "Dimension{" + dimens + '}';
-    }
-}
diff --git a/src/main/java/ru/spbstu/kspt/task1/Dimensions.java b/src/main/java/ru/spbstu/kspt/task1/Dimensions.java
new file mode 100644
index 0000000..043dec2
--- /dev/null
+++ b/src/main/java/ru/spbstu/kspt/task1/Dimensions.java
@@ -0,0 +1,62 @@
+package ru.spbstu.kspt.task1;
+
+import java.util.*;
+
+/**
+ * Класс размерности
+ */
+public class Dimensions {
+
+    Dimensions(){
+
+    }
+
+    private Map<String,Double> dimens = new HashMap<>();
+
+    static Dimensions getLengthDimensions() {
+        return new Dimensions().addDimension("км",100000).addDimension("м",100).
+                addDimension("дм",10).addDimension("см",1);
+    }
+
+    static Dimensions getTimeDimensions() {
+        return new Dimensions().addDimension("с",1).addDimension("мин",60).
+                addDimension("ч",3600);
+    }
+
+    static Dimensions getWeightDimensions() {
+        return new Dimensions().addDimension("кг",1000000).addDimension("г",1000).
+                addDimension("мг",1);
+    }
+
+    Dimensions addDimension(String name, double coefficient) {
+        dimens.put(name, coefficient);
+        return this;
+    }
+
+    double getDimensionValue(String dimension) {
+        if (!dimens.containsKey(dimension)) {
+            throw new IllegalArgumentException("Данная разменость не содержится в данном Map");
+        }
+        return dimens.get(dimension);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Dimensions dimension = (Dimensions) o;
+
+        return dimens != null ? dimens.equals(dimension.dimens) : dimension.dimens == null;
+    }
+
+    @Override
+    public int hashCode() {
+        return dimens != null ? dimens.hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return "Dimension{" + dimens + '}';
+    }
+}
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
index 43d8f9c..337455f 100644
--- a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimension.java
@@ -1,22 +1,8 @@
 package ru.spbstu.kspt.task1;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import java.util.logging.Level;
 
 /**
  * Класс числа с размерностью
- *
- * plus - сложение размерных чисел
- *
- * minus - вычитание размерных чисел
- *
- * multiply - умножение размерного числа на вещественное
- *
- * divide - деление размерного числа на вещественное
- *
- * divideForDim - деление размерных чисел
  */
 class NumberWithDimension implements Comparable<NumberWithDimension>, NumberWithDimensionInterface {
 
@@ -24,7 +10,7 @@ class NumberWithDimension implements Comparable<NumberWithDimension>, NumberWith
 
     private String dimension;
 
-    private Dimension dimensionClass;
+    private Dimensions dimensionClass;
 
     @Override
     public double getNumber() {
@@ -36,70 +22,79 @@ public String getDimension() {
         return dimension;
     }
 
-    NumberWithDimension(double number, String dimension, Dimension dimensionClass) {
+    NumberWithDimension(double number, String dimension, Dimensions dimensionClass) {
         this.number = number;
         this.dimension = dimension;
         this.dimensionClass = dimensionClass;
     }
 
-    @Override
-    public NumberWithDimension plus(NumberWithDimension other) { // Сложение размерных чисел
-        if(dimensionClass.getDimens().equals(other.dimensionClass.getDimens())) {
-            return new NumberWithDimension(number + other.number *
-                    (other.dimensionClass.getValueDimension(other.dimension) /
-                            dimensionClass.getValueDimension(dimension)), dimension, dimensionClass);
-        }
-        else {
+    /**
+     * Дублирующий метод для вычисления чисел с размерностью. Используется во многих дальнейших функциях.
+     */
+    private double calculation(NumberWithDimension other) {
+        if(!dimensionClass.equals(other.dimensionClass)) {
             throw new IllegalArgumentException("Размерности не совпадают");
         }
+        return other.number * (other.dimensionClass.getDimensionValue(other.dimension)
+                / dimensionClass.getDimensionValue(dimension));
     }
 
+    /**
+     * Сложение двух вещественных чисел с размерностью.
+     */
     @Override
-    public NumberWithDimension minus(NumberWithDimension other) { // Вычитание размерных чисел
-        if(dimensionClass.getDimens().equals(other.dimensionClass.getDimens())) {
-            return new NumberWithDimension(number - other.number *
-                    (other.dimensionClass.getValueDimension(other.dimension) /
-                            dimensionClass.getValueDimension(dimension)), dimension, dimensionClass);
-        }
-        else {
-            throw new IllegalArgumentException("Размерности не совпадают");
-        }
+    public NumberWithDimension plus(NumberWithDimension other) {
+        return new NumberWithDimension(number + calculation(other), dimension, dimensionClass);
     }
 
+    /**
+     * Вычитание двух вещественных чисел с размерностью.
+     */
     @Override
-    public NumberWithDimension multiply(double multi) { // Умножение на вещественное число
+    public NumberWithDimension minus(NumberWithDimension other) {
+        return new NumberWithDimension(number - calculation(other), dimension, dimensionClass);
+    }
+
+    /**
+     * Умножение вещественного числа с размерностью на вещественное число.
+     */
+    @Override
+    public NumberWithDimension multiply(double multi) {
         return new NumberWithDimension(number * multi, dimension, dimensionClass);
     }
 
+    /**
+     * Деление вещественного числа с размерностью на вещественное число.
+     */
     @Override
-    public NumberWithDimension divide(double div) { // Деление на вещественное число
+    public NumberWithDimension divide(double div) {
         return new NumberWithDimension(number / div, dimension, dimensionClass);
     }
 
+    /**
+     * Деление двух вещественных чисел друг на друга. В результате получаем вещественное число.
+     */
     @Override
-    public double divideForDim(NumberWithDimension other) { // Деление на другое число с размерностью
-        if(dimensionClass.getDimens().equals(other.dimensionClass.getDimens())) {
-            return number / (other.number * (other.dimensionClass.getValueDimension(other.dimension) /
-                    dimensionClass.getValueDimension(other.dimension)));
-        }
-        else {
-            throw new IllegalArgumentException("Размерности не совпадают");
-        }
+    public double divideForDim(NumberWithDimension other) {
+        return number / calculation(other);
     }
 
+    /**
+     * Перевод вещественного числа с размерностью из одной размерности в другую.
+     */
     @Override
-    public NumberWithDimension translation (String other) { //Переводим вещественное число из одной величины в другую
+    public NumberWithDimension translate(String other) {
         return new NumberWithDimension(number *
-                (dimensionClass.getValueDimension(dimension) / dimensionClass.getValueDimension(other)),
+                (dimensionClass.getDimensionValue(dimension) / dimensionClass.getDimensionValue(other)),
                 other, dimensionClass);
     }
 
+    /**
+     * Сравнение двух вещественных чисел с размерностью.
+     */
     @Override
-    public int compareTo(NumberWithDimension other) { //Cравниваем два числа, подводя их под одну величину
-        return (number * dimensionClass.getValueDimension(dimension)) > (other.number
-                * other.dimensionClass.getValueDimension(other.dimension)) ? 1 : (number
-                * dimensionClass.getValueDimension(dimension)) == (other.number
-                * other.dimensionClass.getValueDimension(other.dimension)) ? 0 : -1;
+    public int compareTo(NumberWithDimension other) {
+        return (number ) > (calculation(other)) ? 1 : (number) == (calculation(other)) ? 0 : -1;
     }
 
     @Override
diff --git a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java
index 3b06b44..65fe63a 100644
--- a/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java
+++ b/src/main/java/ru/spbstu/kspt/task1/NumberWithDimensionInterface.java
@@ -1,20 +1,36 @@
 package ru.spbstu.kspt.task1;
 
 interface NumberWithDimensionInterface {
-
-    double getNumber(); // Взятие вещественного числа из класса
-
-    String getDimension(); // Взятие размерности из класса в строковой форме
-
-    NumberWithDimension plus(NumberWithDimension other); // Сложение двух вещественных чисел с размерностью
-
-    NumberWithDimension minus(NumberWithDimension other); // Вычитание двух вещественных чисел с размерностью
-
-    NumberWithDimension multiply(double multi); // Умножение числа с размерностью на вещественное число
-
-    NumberWithDimension divide(double div); // Деление числа с размерностью на вещественное число
-
-    double divideForDim(NumberWithDimension other); // Деление двух вещественных чисел с размерностью
-
-    NumberWithDimension translation (String other); // Перевод числа с размерностью из одной величины в другую
+    /**
+     * Взятие вещественного числа из класса.
+     */
+    double getNumber(); //
+    /**
+     * Взятие размерности из класса в строковой форме.
+     */
+    String getDimension();
+    /**
+     * Сложение двух вещественных чисел с размерностью.
+     */
+    NumberWithDimension plus(NumberWithDimension other);
+    /**
+     * Вычитание двух вещественных чисел с размерностью.
+     */
+    NumberWithDimension minus(NumberWithDimension other);
+    /**
+     * Умножение числа с размерностью на вещественное число.
+     */
+    NumberWithDimension multiply(double multi);
+    /**
+     * Деление числа с размерностью на вещественное число.
+     */
+    NumberWithDimension divide(double div);
+    /**
+     * Деление числа с размерностью на другое число с размерностью.
+     */
+    double divideForDim(NumberWithDimension other);
+    /**
+     * Перевод числа с размерностью из одной величины в другую.
+     */
+    NumberWithDimension translate (String other);
 }
diff --git a/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java b/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
deleted file mode 100644
index c3dd82e..0000000
--- a/src/test/java/ru/spbstu/kspt/task1/DimensionTest.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package ru.spbstu.kspt.task1;
-
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class DimensionTest {
-    @Test
-    void getValueDimension() {
-        assertEquals(100000, new Dimension().getLengthDimensions().getValueDimension("км"));
-        assertEquals(1000000, new Dimension().getWeightDimensions().getValueDimension("кг"));
-        assertEquals(3600, new Dimension().getTimeDimensions().getValueDimension("ч"));
-        assertEquals(1, new Dimension().getLengthDimensions().getValueDimension("см"));
-        assertEquals(1000, new Dimension().getWeightDimensions().getValueDimension("г"));
-        assertEquals(60, new Dimension().getTimeDimensions().getValueDimension("мин"));
-    }
-
-}
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/DimensionsTest.java b/src/test/java/ru/spbstu/kspt/task1/DimensionsTest.java
new file mode 100644
index 0000000..668fad4
--- /dev/null
+++ b/src/test/java/ru/spbstu/kspt/task1/DimensionsTest.java
@@ -0,0 +1,26 @@
+package ru.spbstu.kspt.task1;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DimensionsTest {
+    @Test
+    void getValueDimension() {
+        assertEquals(100000, new Dimensions().getLengthDimensions().getDimensionValue("км"));
+        assertEquals(1000000, new Dimensions().getWeightDimensions().getDimensionValue("кг"));
+        assertEquals(3600, new Dimensions().getTimeDimensions().getDimensionValue("ч"));
+        assertEquals(1, new Dimensions().getLengthDimensions().getDimensionValue("см"));
+        assertEquals(1000, new Dimensions().getWeightDimensions().getDimensionValue("г"));
+        assertEquals(60, new Dimensions().getTimeDimensions().getDimensionValue("мин"));
+        try {
+            assertEquals(60, new Dimensions().getTimeDimensions().getDimensionValue("оки"));
+            assertEquals(60, new Dimensions().getTimeDimensions().getDimensionValue("кауаку"));
+            assertEquals(60, new Dimensions().getTimeDimensions().getDimensionValue("минутки"));
+        }
+        catch (IllegalArgumentException e){
+            System.out.println("Ошибка поймана.");
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
deleted file mode 100644
index da83470..0000000
--- a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimension.java
+++ /dev/null
@@ -1,180 +0,0 @@
-package ru.spbstu.kspt.task1;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class NumberWithDimensionTest {
-
-    private static final Logger logger = LogManager.getLogger(NumberWithDimensionTest.class);
-
-
-    @Test
-    void getNumber() {
-        assertEquals(2.0,
-                new NumberWithDimension(2.0,"км",  new Dimension().getLengthDimensions())
-                        .getNumber());
-    }
-
-    @Test
-    void getDimension() {
-        assertEquals("км",
-                new NumberWithDimension(2.0,"км",  new Dimension().getLengthDimensions())
-                        .getDimension());
-    }
-
-    @Test
-    void plus() {
-        logger.info("Начало теста на сложение с вещественным числом с размерностью, " +
-                "используя уже приготовленные размерности.");
-        assertEquals(new NumberWithDimension(4.0,"км", new Dimension().getLengthDimensions()),
-                new NumberWithDimension(2.0,"км",  new Dimension().getLengthDimensions())
-                        .plus(new NumberWithDimension(2.0,"км",
-                                new Dimension().getLengthDimensions())));
-        logger.info("Начало теста на сложение вещественного числа с размерностью, " +
-                "используя размерности, написанные пользователем.");
-        assertEquals(new NumberWithDimension(4.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                        .addDimension("А",1).addDimension("мА",0.001)),
-                new NumberWithDimension(2.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                        .addDimension("А",1).addDimension("мА",0.001))
-                        .plus(new NumberWithDimension(2.0,"А",
-                                new Dimension().addDimension("кА",1000)
-                                        .addDimension("А",1)
-                                        .addDimension("мА",0.001))));
-        logger.info("Тест на сложение с вещественным числом с размерностью пройдены.");
-    }
-
-    @Test
-    void minus() {
-        logger.info("Начало теста на вычитание вещественного числа с размерностью, " +
-                "используя уже приготовленные размерности.");
-        assertEquals(new NumberWithDimension(4.0,"км", new Dimension().getLengthDimensions()),
-                new NumberWithDimension(6.0,"км",  new Dimension().getLengthDimensions())
-                        .minus(new NumberWithDimension(2.0,"км",
-                                new Dimension().getLengthDimensions())));
-        logger.info("Начало теста на вычитание вещественного числа с размерностью, " +
-                "используя размерности, написанные пользователем.");
-        assertEquals(new NumberWithDimension(5.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001)),
-                new NumberWithDimension(15.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001))
-                        .minus(new NumberWithDimension(10.0,"А",
-                                new Dimension().addDimension("кА",1000)
-                                        .addDimension("А",1)
-                                        .addDimension("мА",0.001))));
-        logger.info("Тест на вычитание с вещественным числом с размерностью пройдены.");
-    }
-
-    @Test
-    void multiply() {
-        logger.info("Начало теста на умножение на вещественное число, используя уже приготовленные размерности.");
-        assertEquals(new NumberWithDimension(26.0,"км", new Dimension().getLengthDimensions()),
-                new NumberWithDimension(1.0,"км",  new Dimension().getLengthDimensions())
-                        .multiply(26.0));
-        assertEquals(new NumberWithDimension(29.0,"м", new Dimension().getLengthDimensions()),
-                new NumberWithDimension(1.0,"м",  new Dimension().getLengthDimensions())
-                        .multiply(29.0));
-        logger.info("Начало теста на умножение на вещественное число, используя размерности, написанные пользователем.");
-        assertEquals(new NumberWithDimension(51.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001)),
-                new NumberWithDimension(2.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001))
-                        .multiply(25.5));
-        logger.info("Тест на умножение на вещественное число пройдены.");
-    }
-
-    @Test
-    void divide() {
-        logger.info("Начало теста на деление на вещественное число, используя уже приготовленные размерности.");
-        assertEquals(new NumberWithDimension(5.0,"км", new Dimension().getLengthDimensions()),
-                new NumberWithDimension(25.0,"км",  new Dimension().getLengthDimensions())
-                        .divide(5.0));
-        assertEquals(new NumberWithDimension(5.0,"м", new Dimension().getLengthDimensions()),
-                new NumberWithDimension(30.0,"м",  new Dimension().getLengthDimensions())
-                        .divide(6.0));
-        logger.info("Начало теста на деление на вещественное число, используя размерности, написанные пользователем.");
-        assertEquals(new NumberWithDimension(2.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001)),
-                new NumberWithDimension(12.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001))
-                        .divide(6.0));
-        logger.info("Тест на деление на вещественное число пройдены.");
-    }
-
-    @Test
-    void divideForDim() {
-        logger.info("Начало теста на деление на вещественное число с размерностью, " +
-                "используя уже приготовленные размерности.");
-        assertEquals(10.0,
-                new NumberWithDimension(25.0,"км",  new Dimension().getLengthDimensions())
-                        .divideForDim(new NumberWithDimension(2.5,"км",
-                                new Dimension().getLengthDimensions())));
-        logger.info("Начало теста на деление на вещественное число с размерностью, " +
-                "используя размерности, написанные пользователем.");
-        assertEquals(5.5, new NumberWithDimension(11.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001))
-                        .divideForDim(new NumberWithDimension(2.0,"А",
-                                new Dimension().addDimension("кА",1000)
-                                        .addDimension("А",1)
-                                        .addDimension("мА",0.001))));
-        logger.info("Тест на деление на вещественное число с размерностью пройдены.");
-    }
-
-    @Test
-    void translation() {
-        logger.info("Начало теста на перевод вещественного числа с размерностью, " +
-                "используя размерности, написанные пользователем.");
-        assertEquals(new NumberWithDimension(2000.0,"мА",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001)),
-                new NumberWithDimension(2.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001))
-                        .translation("мА"));
-        logger.info("Начало теста на перевод вещественного числа с размерностью, " +
-                "используя уже приготовленные размерности.");
-        assertEquals(new NumberWithDimension(6000.0,"м", new Dimension().getLengthDimensions()),
-                new NumberWithDimension(6.0,"км",  new Dimension().getLengthDimensions())
-                        .translation("м"));
-        logger.info("Тест на перевод чисел с размерностью пройдены.");
-    }
-
-
-    @Test
-    void compareTo() {
-        logger.info("Начало теста на сравнение между числами, используя уже приготовленные размерности.");
-        assertEquals(0,
-                new NumberWithDimension(25.0,"м",  new Dimension().getLengthDimensions())
-                        .compareTo(new NumberWithDimension(0.025,"км",
-                                new Dimension().getLengthDimensions())));
-        assertEquals(1,
-                new NumberWithDimension(25.0,"м",  new Dimension().getLengthDimensions())
-                        .compareTo(new NumberWithDimension(0.024,"км",
-                                new Dimension().getLengthDimensions())));
-        assertEquals(-1,
-                new NumberWithDimension(25.0,"м",  new Dimension().getLengthDimensions())
-                        .compareTo(new NumberWithDimension(0.026,"км",
-                                new Dimension().getLengthDimensions())));
-        logger.info("Начало теста на сравнение между числами, используя размерности, написанные пользователем.");
-        assertEquals(1, new NumberWithDimension(2.0,"А",
-                        new Dimension().addDimension("кА",1000)
-                                .addDimension("А",1).addDimension("мА",0.001))
-                        .compareTo(new NumberWithDimension(2.0,"мА",
-                                new Dimension().addDimension("кА",1000)
-                                        .addDimension("А",1)
-                                        .addDimension("мА",0.001))));
-        logger.info("Тест на сравнение пройдены.");
-    }
-
-}
\ No newline at end of file
diff --git a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java
new file mode 100644
index 0000000..4335b55
--- /dev/null
+++ b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java
@@ -0,0 +1,276 @@
+package ru.spbstu.kspt.task1;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class NumberWithDimensionTest {
+
+    private static final Logger logger = LogManager.getLogger(NumberWithDimensionTest.class);
+
+    @Test
+    void getNumber() {
+        assertEquals(2.0,
+                new NumberWithDimension(2.0,"км",  new Dimensions().getLengthDimensions())
+                        .getNumber());
+    }
+
+    @Test
+    void getDimension() {
+        assertEquals("км",
+                new NumberWithDimension(2.0,"км",  new Dimensions().getLengthDimensions())
+                        .getDimension());
+    }
+
+    @Test
+    void plus() throws IllegalArgumentException{
+        logger.info("Начало теста на сложение с вещественным числом с размерностью, " +
+                "используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .plus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getLengthDimensions())));
+        logger.info("Начало теста на сложение вещественного числа с размерностью, " +
+                "используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(4.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .plus(new NumberWithDimension(2.0,"А",
+                                new Dimensions()
+                                        .addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
+        logger.info("Начало теста на сложение вещественного числа с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .plus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getWeightDimensions()))); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на сложение с вещественным числом с размерностью пройдены.");
+    }
+
+
+    @Test
+    void minus() {
+        logger.info("Начало теста на вычитание вещественного числа с размерностью, " +
+                "используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(6.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .minus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getLengthDimensions())));
+        logger.info("Начало теста на вычитание вещественного числа с размерностью, " +
+                "используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(5.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(15.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .minus(new NumberWithDimension(10.0,"А",
+                                new Dimensions()
+                                        .addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
+        logger.info("Начало теста на вычитание вещественного числа с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .minus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getWeightDimensions()))); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на вычитание с вещественным числом с размерностью пройдены.");
+    }
+
+    @Test
+    void multiply() {
+        logger.info("Начало теста на умножение на вещественное число, используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(26.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(1.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .multiply(26.0));
+        assertEquals(new NumberWithDimension(29.0,"м",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(1.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .multiply(29.0));
+        logger.info("Начало теста на умножение на вещественное число, используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(51.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .multiply(25.5));
+        logger.info("Тест на умножение на вещественное число пройдены.");
+    }
+
+    @Test
+    void divide() {
+        logger.info("Начало теста на деление на вещественное число, используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(5.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(25.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .divide(5.0));
+        assertEquals(new NumberWithDimension(5.0,"м",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(30.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .divide(6.0));
+        logger.info("Начало теста на деление на вещественное число, используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(12.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .divide(6.0));
+        logger.info("Тест на деление на вещественное число пройдены.");
+    }
+
+    @Test
+    void divideForDim() {
+        logger.info("Начало теста на деление на вещественное число с размерностью, " +
+                "используя уже приготовленные размерности.");
+        assertEquals(10.0,
+                new NumberWithDimension(25.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .divideForDim(new NumberWithDimension(2.5,"км",
+                                new Dimensions().getLengthDimensions())));
+        logger.info("Начало теста на деление на вещественное число с размерностью, " +
+                "используя размерности, написанные пользователем.");
+        assertEquals(5.5, new NumberWithDimension(11.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .divideForDim(new NumberWithDimension(2.0,"А",
+                                new Dimensions()
+                                        .addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
+        logger.info("Начало теста на деление на вещественное число с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .plus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getWeightDimensions()))); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на деление на вещественное число с размерностью пройдены.");
+    }
+
+    @Test
+    void translate() {
+        logger.info("Начало теста на перевод вещественного числа с размерностью, " +
+                "используя размерности, написанные пользователем.");
+        assertEquals(new NumberWithDimension(2000.0,"мА",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001)),
+                new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .translate("мА"));
+        logger.info("Начало теста на перевод вещественного числа с размерностью, " +
+                "используя уже приготовленные размерности.");
+        assertEquals(new NumberWithDimension(6000.0,"м",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(6.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .translate("м"));
+        logger.info("Начало теста на перевод вещественного числа с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .plus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getWeightDimensions()))); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на перевод чисел с размерностью пройдены.");
+    }
+
+
+    @Test
+    void compareTo() {
+        logger.info("Начало теста на сравнение между числами, используя уже приготовленные размерности.");
+        assertEquals(0,
+                new NumberWithDimension(25.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(0.025,"км",
+                                new Dimensions().getLengthDimensions())));
+        assertEquals(1,
+                new NumberWithDimension(25.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(0.024,"км",
+                                new Dimensions().getLengthDimensions())));
+        assertEquals(-1,
+                new NumberWithDimension(25.0,"м",
+                        new Dimensions().getLengthDimensions())
+                        .compareTo(new NumberWithDimension(0.026,"км",
+                                new Dimensions().getLengthDimensions())));
+        logger.info("Начало теста на сравнение между числами, используя размерности, написанные пользователем.");
+        assertEquals(1, new NumberWithDimension(2.0,"А",
+                        new Dimensions()
+                                .addDimension("кА",1000)
+                                .addDimension("А",1)
+                                .addDimension("мА",0.001))
+                        .compareTo(new NumberWithDimension(2.0,"мА",
+                                new Dimensions()
+                                        .addDimension("кА",1000)
+                                        .addDimension("А",1)
+                                        .addDimension("мА",0.001))));
+        logger.info("Начало теста на сравнение вещественных чисел с размерностью, чтобы мы ловили ошибку.");
+        try {assertEquals(new NumberWithDimension(4.0,"км",
+                        new Dimensions().getLengthDimensions()),
+                new NumberWithDimension(2.0,"км",
+                        new Dimensions().getLengthDimensions())
+                        .plus(new NumberWithDimension(2.0,"км",
+                                new Dimensions().getWeightDimensions()))); }
+        catch (IllegalArgumentException e) {
+            System.out.println("Ошибка поймана.");
+        }
+        logger.info("Тест на сравнение пройдены.");
+    }
+
+}
\ No newline at end of file

From 0c4a70105317a0b5611247d7d416082e2ce90446 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=92=D0=B8=D0=BA=D1=82=D0=BE=D1=80?= <sfera98@bk.ru>
Date: Sun, 11 Mar 2018 16:03:09 +0300
Subject: [PATCH 12/12] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D0=B8=D0=B5=20=D1=82=D0=B5=D1=81=D1=82=D0=BE?=
 =?UTF-8?q?=D0=B2.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../ru/spbstu/kspt/task1/NumberWithDimensionTest.java    | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java
index 4335b55..c5fc09c 100644
--- a/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java
+++ b/src/test/java/ru/spbstu/kspt/task1/NumberWithDimensionTest.java
@@ -25,7 +25,7 @@ void getDimension() {
     }
 
     @Test
-    void plus() throws IllegalArgumentException{
+    void plus() {
         logger.info("Начало теста на сложение с вещественным числом с размерностью, " +
                 "используя уже приготовленные размерности.");
         assertEquals(new NumberWithDimension(4.0,"км",
@@ -187,7 +187,7 @@ void divideForDim() {
                         new Dimensions().getLengthDimensions()),
                 new NumberWithDimension(2.0,"км",
                         new Dimensions().getLengthDimensions())
-                        .plus(new NumberWithDimension(2.0,"км",
+                        .divideForDim(new NumberWithDimension(2.0,"км",
                                 new Dimensions().getWeightDimensions()))); }
         catch (IllegalArgumentException e) {
             System.out.println("Ошибка поймана.");
@@ -222,8 +222,7 @@ void translate() {
                         new Dimensions().getLengthDimensions()),
                 new NumberWithDimension(2.0,"км",
                         new Dimensions().getLengthDimensions())
-                        .plus(new NumberWithDimension(2.0,"км",
-                                new Dimensions().getWeightDimensions()))); }
+                        .translate("glhf")); }
         catch (IllegalArgumentException e) {
             System.out.println("Ошибка поймана.");
         }
@@ -265,7 +264,7 @@ void compareTo() {
                         new Dimensions().getLengthDimensions()),
                 new NumberWithDimension(2.0,"км",
                         new Dimensions().getLengthDimensions())
-                        .plus(new NumberWithDimension(2.0,"км",
+                        .compareTo(new NumberWithDimension(2.0,"км",
                                 new Dimensions().getWeightDimensions()))); }
         catch (IllegalArgumentException e) {
             System.out.println("Ошибка поймана.");