diff --git a/src/1111.txt b/src/1111.txt
new file mode 100644
index 0000000..1fb4559
--- /dev/null
+++ b/src/1111.txt
@@ -0,0 +1,15 @@
+public void readFile(String fileName) {
+                   BufferedInputStream inputFile;
+                   Pattern pattern = Pattern.compile(keyWords);
+                   try {
+                       inputFile = new BufferedInputStream(new FileInputStream(fileName));
+                       int bytesAvailable;
+                       StringBuffer stringFromInputFile = new StringBuffer();
+
+                       while ((bytesAvailable = inputFile.read()) != -1) {
+                           stringFromInputFile.append((char) bytesAvailable);
+                       }
+                   } catch (FileNotFoundException e) {
+            System.out.println("File " + fileName + " isn't found");
+        }
+    }
\ No newline at end of file
diff --git a/src/empty.txt b/src/empty.txt
new file mode 100644
index 0000000..e69de29
diff --git a/src/main/java/BinaryStream.java b/src/main/java/BinaryStream.java
index 87025b0..f10024d 100644
--- a/src/main/java/BinaryStream.java
+++ b/src/main/java/BinaryStream.java
@@ -3,16 +3,15 @@
 import java.io.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import main.java.Utils;
 
 public class BinaryStream {
 
-    public String keyWords = "abstract|boolean|break|byte|byvalue|case|cast|catch|char|class|const|continue|default|do|double|" +
-            "else|extends|false|final|finally|float|for|future|generic|goto|if|implements|import|inner|instanceof|" +
-            "int|interface|long|native|new|null|operator|outer|package|private|protected|public|rest|return|short|" +
-            "static|super|switch|syncronized|this|throw|throws|transient|true|try|var|void|volatile|while";
 
 
-    public StringBuffer readBinaryStream(String fileName) {
+    private BinaryStream() {}
+
+    public static StringBuffer readBinaryStream(String fileName) throws IOException{
         StringBuffer stringFromInputFile = new StringBuffer();
         try (BufferedInputStream inputFile =
                      new BufferedInputStream(new FileInputStream(fileName))) {
@@ -30,21 +29,7 @@ public StringBuffer readBinaryStream(String fileName) {
         return stringFromInputFile;
     }
 
-    public String analyzeString(StringBuffer resultString) {
-        Pattern pattern = Pattern.compile(keyWords);
-        String stringFromBuffer= "";
-        int count = 0;
-
-        Matcher m = pattern.matcher(resultString);
-        while (m.find()) {
-            stringFromBuffer += (m.group() + " ");
-            count++;
-        }
-
-        return stringFromBuffer + "\n Найдено ключевых слов: " + count;
-    }
-
-    public void writeBinaryStream(String resultString, String keyWordsFileName) {
+    public static void writeBinaryStream(String resultString, String keyWordsFileName) throws IOException{
         try (FileOutputStream keyWordsFile =
                      new FileOutputStream(keyWordsFileName)) {
             keyWordsFile.write(resultString.getBytes());
diff --git a/src/main/java/Main.java b/src/main/java/Main.java
index 8296120..ff7bb0e 100644
--- a/src/main/java/Main.java
+++ b/src/main/java/Main.java
@@ -1,20 +1,30 @@
 package main.java;
 
+import java.io.IOException;
+
 public class Main {
 
     public static void main(String[] args) {
-        BinaryStream byteStream = new BinaryStream();
-        StringBuffer resultString = byteStream.readBinaryStream("src/1111.txt");
-        String analyzedString = byteStream.analyzeString(resultString);
-        System.out.println(analyzedString);
-        String keyWordsFileName = "result.txt";
-        byteStream.writeBinaryStream(analyzedString,keyWordsFileName);
+        StringBuffer resultString = null;
+        try {
+            resultString = BinaryStream.readBinaryStream("src/1111.txt");
+
+            String analyzedString = Utils.analyzeString(resultString);
+            System.out.println(analyzedString);
+            String keyWordsFileName = "result.txt";
 
-        TextStream textStream = new TextStream();
-        StringBuilder resultTextString = textStream.readTextStream("src/1111.txt");
-        analyzedString = textStream.analyzeString(resultTextString);
-        System.out.println(analyzedString);
-        textStream.writeTextStream(analyzedString,"result1.txt");
+            BinaryStream.writeBinaryStream(analyzedString, keyWordsFileName);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
 
+        try {
+            StringBuffer resultTextString = TextStream.readTextStream("src/1111.txt");
+            String analyzedString = Utils.analyzeString(resultTextString);
+            System.out.println(analyzedString);
+            TextStream.writeTextStream(analyzedString, "result1.txt");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
     }
 }
diff --git a/src/main/java/TextStream.java b/src/main/java/TextStream.java
index 03d2c01..5268767 100644
--- a/src/main/java/TextStream.java
+++ b/src/main/java/TextStream.java
@@ -5,13 +5,11 @@
 import java.util.regex.Pattern;
 
 public class TextStream {
-    public String keyWords = "abstract|boolean|break|byte|byvalue|case|cast|catch|char|class|const|continue|default|do|double|" +
-            "else|extends|false|final|finally|float|for|future|generic|goto|if|implements|import|inner|instanceof|" +
-            "int|interface|long|native|new|null|operator|outer|package|private|protected|public|rest|return|short|" +
-            "static|super|switch|syncronized|this|throw|throws|transient|true|try|var|void|volatile|while";
 
-    public StringBuilder readTextStream(String fileName) {
-        StringBuilder stringFromInputFile = new StringBuilder();
+    private TextStream() {};
+
+    public static StringBuffer readTextStream(String fileName) throws IOException{
+        StringBuffer stringFromInputFile = new StringBuffer();
         try (BufferedReader inputFile =
                      new BufferedReader(new FileReader(fileName))) {
             String charsAvailable;
@@ -28,21 +26,7 @@ public StringBuilder readTextStream(String fileName) {
         return stringFromInputFile;
     }
 
-    public String analyzeString(StringBuilder resultString) {
-        Pattern pattern = Pattern.compile(keyWords);
-        String stringFromBuffer= "";
-        int count = 0;
-
-        Matcher m = pattern.matcher(resultString);
-        while (m.find()) {
-            stringFromBuffer += (m.group() + " ");
-            count++;
-        }
-
-        return stringFromBuffer + "\n Найдено ключевых слов: " + count;
-    }
-
-    public void writeTextStream(String resultString, String keyWordsFileName) {
+    public static void writeTextStream(String resultString, String keyWordsFileName) throws IOException{
         try (BufferedWriter keyWordsFile =
                      new BufferedWriter(new FileWriter(keyWordsFileName))) {
             keyWordsFile.write(resultString);
@@ -54,4 +38,4 @@ public void writeTextStream(String resultString, String keyWordsFileName) {
             e.printStackTrace();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/Utils.java b/src/main/java/Utils.java
new file mode 100644
index 0000000..f3e65e1
--- /dev/null
+++ b/src/main/java/Utils.java
@@ -0,0 +1,28 @@
+package main.java;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class Utils {
+    public static final String KEY_WORDS = "abstract|boolean|break|byte|byvalue|case|cast|catch|char|class|const|continue|default|do|double|" +
+            "else|extends|false|final|finally|float|for|future|generic|goto|if|implements|import|inner|instanceof|" +
+            "int|interface|long|native|new|null|operator|outer|package|private|protected|public|rest|return|short|" +
+            "static|super|switch|syncronized|this|throw|throws|transient|true|try|var|void|volatile|while";
+
+    public static String analyzeString(StringBuffer resultString) {
+        String[] arrayKeyWords = Utils.KEY_WORDS.split("\\|");
+        String stringFromBuffer= "";
+        int count = 0;
+        for(int i=0; i<arrayKeyWords.length; i++) {
+            String keyWord = "(^|[^a-zA-Z0-9])" + arrayKeyWords[i] + "([^a-zA-Z0-9]|$)";
+            Pattern pattern = Pattern.compile(keyWord);
+            Matcher m = pattern.matcher(resultString);
+            while (m.find()) {
+                stringFromBuffer += (m.group() + " ");
+                count++;
+            }
+        }
+        return stringFromBuffer + "\n Найдено ключевых слов: " + count;
+    }
+
+}
diff --git a/src/test/java/BinaryStreamTest.java b/src/test/java/BinaryStreamTest.java
index 6a1168e..dafb66d 100644
--- a/src/test/java/BinaryStreamTest.java
+++ b/src/test/java/BinaryStreamTest.java
@@ -1,45 +1,104 @@
 package test.java;
+import main.java.Utils;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
 import org.junit.Test;
 import main.java.BinaryStream;
 
 import java.io.FileNotFoundException;
+import java.io.IOException;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 public class BinaryStreamTest {
 
     @Test
-    public void readNonExistingFile() {
-        BinaryStream byteStream = new BinaryStream();
-        StringBuffer resultString = byteStream.readBinaryStream("src/1111000.txt");
-        assert(true);
+    public void readNonExistingFile(){
+        try {
+            StringBuffer resultString = BinaryStream.readBinaryStream("src/111100000.txt");
+            assertEquals(0, resultString.length());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void checkReadBinaryStreamFromExistingFile(){
+        try {
+            StringBuffer resultString = BinaryStream.readBinaryStream("src/testFile1.txt");
+            String expectedString = "public void readFile(String fileName) {BufferedInputStream inputFile;" +
+                    " Pattern pattern = Pattern.compile(keyWords); try";
+            assertTrue(expectedString.equals(resultString.toString()));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
     }
 
     @Test
     public void checkKeyWordsNumberInStream() {
-        BinaryStream byteStream = new BinaryStream();
-        StringBuffer resultString = byteStream.readBinaryStream("src/1111.txt");
-        String expectedResult = "public void try new new int byte new while byte char byte catch int \n" +
-                " Найдено ключевых слов: 14";
+        StringBuffer resultString = null;
+        try {
+            resultString = BinaryStream.readBinaryStream("src/1111.txt");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        String expectedResult = " catch  (char)  int   new  (new   new  public   try   void   while  \n" +
+                " Найдено ключевых слов: 10";
         assertEquals("Result string doesn't equal expected:", expectedResult,
-                byteStream.analyzeString (resultString));
+                Utils.analyzeString (resultString));
     }
 
     @Test
     public void checkKeyWordsInEmptyFile() {
-        BinaryStream byteStream = new BinaryStream();
-        StringBuffer resultString = byteStream.readBinaryStream("src/empty.txt");
+        StringBuffer resultString = null;
+        String expectedResult = "\n Найдено ключевых слов: 0";
+        try {
+            resultString = BinaryStream.readBinaryStream("src/empty.txt");
+            assertEquals("Result string doesn't equal expected:", expectedResult,
+                    Utils.analyzeString (resultString));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void checkWordsConsistingOfSeveralKeyWords() {
+        StringBuffer resultString = new StringBuffer();
+        resultString.append("publicintprivate");
+        String expectedResult = "\n Найдено ключевых слов: 0";
+            assertEquals("Result string doesn't equal expected:", expectedResult,
+                    Utils.analyzeString (resultString));
+    }
+
+    @Test
+    public void checkWordsConsistsOfNumberAndKeyWord() {
+        StringBuffer resultString = new StringBuffer();
+        resultString.append("12public");
+        String expectedResult = "\n Найдено ключевых слов: 0";
+        assertEquals("Result string doesn't equal expected:", expectedResult,
+                Utils.analyzeString (resultString));
+    }
+
+    @Test
+    public void checkWordsConsistsOfKeyWordAndNumber() {
+        StringBuffer resultString = new StringBuffer();
+        resultString.append("12public");
         String expectedResult = "\n Найдено ключевых слов: 0";
         assertEquals("Result string doesn't equal expected:", expectedResult,
-                byteStream.analyzeString (resultString));
+                Utils.analyzeString (resultString));
     }
 
     @Test
-    public void writeFileWithEmptyName() {
-        BinaryStream byteStream = new BinaryStream();
-        String resultString = "\n Найдено ключевых слов: 0";
-        byteStream.writeBinaryStream(resultString,"");
-        assert(true);
+    public void checkWriteBinaryStreamMethod() {
+        String inputString = "public void readFile(String fileName) {BufferedInputStream inputFile;" +
+                " Pattern pattern = Pattern.compile(keyWords); try";
+        try {
+            BinaryStream.writeBinaryStream(inputString,"testFile2.txt");
+            StringBuffer resultString = BinaryStream.readBinaryStream("testFile2.txt");
+            assertTrue(inputString.equals(resultString.toString()));
+        } catch (IOException e1) {
+            e1.printStackTrace();
+        }
     }
 
 }
diff --git a/src/test/java/TestStreamTest.java b/src/test/java/TestStreamTest.java
index d9ddc50..0d54422 100644
--- a/src/test/java/TestStreamTest.java
+++ b/src/test/java/TestStreamTest.java
@@ -1,43 +1,101 @@
 package test.java;
 
 import main.java.TextStream;
+import main.java.Utils;
 import org.junit.Test;
 
+import java.io.IOException;
+
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 public class TestStreamTest {
     @Test
     public void readNonExistingFile() {
-        TextStream textStream = new TextStream();
-        StringBuilder resultTextString = textStream.readTextStream("src/1111000.txt");
-        assert(true);
+        try {
+            StringBuffer resultTextString = TextStream.readTextStream("src/1111000.txt");
+            assertEquals(0, resultTextString.length());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void checkReadBinaryStreamFromExistingFile(){
+        try {
+            StringBuffer resultString = TextStream.readTextStream("src/testFile1.txt");
+            String expectedString = "public void readFile(String fileName) {BufferedInputStream inputFile;" +
+                    " Pattern pattern = Pattern.compile(keyWords); try";
+            assertTrue(expectedString.equals(resultString.toString()));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
     }
 
     @Test
     public void checkKeyWordsNumberInStream() {
-        TextStream textStream = new TextStream();
-        StringBuilder resultTextString = textStream.readTextStream("src/1111.txt");
-        String expectedResult = "public void try new new int byte new while byte char byte catch int \n" +
-                " Найдено ключевых слов: 14";
-        assertEquals("Result string doesn't equal expected:", expectedResult,
-                textStream.analyzeString(resultTextString));
+        try {
+            StringBuffer resultTextString = TextStream.readTextStream("src/1111.txt");
+            String expectedResult = " catch  (char)  int   new  (new   new  public   try   void   while  \n" +
+                    " Найдено ключевых слов: 10";
+            assertEquals("Result string doesn't equal expected:", expectedResult,
+                    Utils.analyzeString(resultTextString));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
     }
 
     @Test
     public void checkKeyWordsInEmptyFile() {
-        TextStream textStream = new TextStream();
-        StringBuilder resultString = textStream.readTextStream("src/empty.txt");
+        StringBuffer resultTextString = null;
+        String expectedResult = "\n Найдено ключевых слов: 0";
+        try {
+            resultTextString = TextStream.readTextStream("src/empty.txt");
+            assertEquals("Result string doesn't equal expected:", expectedResult,
+                    Utils.analyzeString (resultTextString));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void checkWordsConsistingOfSeveralKeyWords() {
+        StringBuffer resultString = new StringBuffer();
+        resultString.append("publicintprivate");
+        String expectedResult = "\n Найдено ключевых слов: 0";
+        assertEquals("Result string doesn't equal expected:", expectedResult,
+                Utils.analyzeString (resultString));
+    }
+
+    @Test
+    public void checkWordsConsistsOfNumberAndKeyWord() {
+        StringBuffer resultString = new StringBuffer();
+        resultString.append("12public");
+        String expectedResult = "\n Найдено ключевых слов: 0";
+        assertEquals("Result string doesn't equal expected:", expectedResult,
+                Utils.analyzeString (resultString));
+    }
+
+    @Test
+    public void checkWordsConsistsOfKeyWordAndNumber() {
+        StringBuffer resultString = new StringBuffer();
+        resultString.append("12public");
         String expectedResult = "\n Найдено ключевых слов: 0";
         assertEquals("Result string doesn't equal expected:", expectedResult,
-                textStream.analyzeString (resultString));
+                Utils.analyzeString (resultString));
     }
 
     @Test
-    public void writeFileWithEmptyName() {
-        TextStream textStream = new TextStream();
-        String resultString = "\n Найдено ключевых слов: 0";
-        textStream.writeTextStream(resultString,"");
-        assert(true);
+    public void checkWriteBinaryStreamMethod() {
+        String inputString = "public void readFile(String fileName) {BufferedInputStream inputFile;" +
+                " Pattern pattern = Pattern.compile(keyWords); try";
+        try {
+            TextStream.writeTextStream(inputString,"testFile2.txt");
+            StringBuffer resultString = TextStream.readTextStream("testFile2.txt");
+            assertTrue(inputString.equals(resultString.toString()));
+        } catch (IOException e1) {
+            e1.printStackTrace();
+        }
     }
 
 }
diff --git a/src/testFile1.txt b/src/testFile1.txt
new file mode 100644
index 0000000..6ecbf7d
--- /dev/null
+++ b/src/testFile1.txt
@@ -0,0 +1 @@
+public void readFile(String fileName) {BufferedInputStream inputFile; Pattern pattern = Pattern.compile(keyWords); try
\ No newline at end of file