diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..69c7852
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.6)
+
+project(Main_automata)
+
+set(CMAKE_CXX_STANDARD 17)
+
+include_directories(
+        FSM/include
+        FSM/include/math)
+
+add_executable(run
+        main.cpp
+        FSM/src/NFSM.cpp
+        FSM/src/DFSM.cpp
+        FSM/src/MDFSM.cpp
+        FSM/src/math_func/utility.cpp
+        FSM/src/RegularFSM.cpp
+        FSM/src/State.cpp
+        )
+
+add_subdirectory(tests)
diff --git a/FSM/include/DFSM.h b/FSM/include/DFSM.h
new file mode 100644
index 0000000..b195f0a
--- /dev/null
+++ b/FSM/include/DFSM.h
@@ -0,0 +1,36 @@
+#pragma once
+#include "NFSM.h"
+#include "globals.h"
+#include <bitset>
+#include <vector>
+#include <cmath>
+#include <queue>
+#include <unordered_set>
+#include "State.h"
+#include "utility.h"
+
+
+struct IndexState {
+  std::vector<int> tranzitions;
+  int WayByLetter(int letter);
+  void SetSize(int new_size);
+  void SetWayByLetter(int letter, int new_tranz_index);
+};
+
+
+class DFSM{
+ public:
+  DFSM(std::string file_name);
+  DFSM(NFSM nfsm);
+  DFSM() = default;
+  bool RecognizeWord(std::string);
+  int getSize();
+  std::vector<IndexState> getStates();
+  std::bitset<MaxStateNumber> getF();
+  void Complement();
+ protected:
+  std::vector<IndexState> states_;
+  int size_;
+  int S_size_;
+  std::bitset<MaxStateNumber> F_;
+};
diff --git a/FSM/include/MDFSM.h b/FSM/include/MDFSM.h
new file mode 100644
index 0000000..a008045
--- /dev/null
+++ b/FSM/include/MDFSM.h
@@ -0,0 +1,16 @@
+#pragma once
+#include "State.h"
+#include "globals.h"
+#include "DFSM.h"
+#include <map>
+#include <set>
+
+class MDFSM: public DFSM{
+ public:
+  MDFSM(std::string file_name) : DFSM(file_name){};
+  MDFSM(DFSM);
+ private:
+  void BuildStatesByClasses(std::vector<int> state_to_class,
+                            std::vector<IndexState> last_states,
+                            std::bitset<MaxStateNumber>);
+};
diff --git a/FSM/include/NFSM.h b/FSM/include/NFSM.h
new file mode 100644
index 0000000..83cafc0
--- /dev/null
+++ b/FSM/include/NFSM.h
@@ -0,0 +1,41 @@
+#pragma once
+#include <vector>
+#include <iostream>
+#include <string>
+#include <bitset>
+#include <fstream>
+#include "globals.h"
+#include "State.h"
+
+
+struct EpsInfoState {
+  std::vector<std::string> attempts;
+  bool Find(std::string);
+};
+
+
+
+class NFSM {
+ private:
+  std::vector<State> states_;
+  int q0_;
+  int size_;
+  std::bitset<MaxStateNumber> F_;
+  int edge_size_;
+  int S_size_ = SigmaSize;
+  bool IsEpsExist = true;
+  std::vector<EpsInfoState> SeenBefore;
+  bool RecognizeWordIfNoEps(std::string, int);
+  bool RecognizeWordIfExistEps(std::string, int);
+ public:
+  NFSM(const std::string& file);
+  NFSM();
+  void FilchEps();
+  void print_states();
+  void print_ndsm();
+  void print_in_input_format();
+  bool RecognizeWord(std::string);
+  int getSize();
+  std::vector<State> getStates();
+  std::bitset<MaxStateNumber> getF();
+};
diff --git a/FSM/include/RegularFSM.h b/FSM/include/RegularFSM.h
new file mode 100644
index 0000000..4ece1f2
--- /dev/null
+++ b/FSM/include/RegularFSM.h
@@ -0,0 +1,42 @@
+#include <string>
+#include <iostream>
+#include <DFSM.h>
+
+struct configuration {
+  int index; //куда пришел
+  std::string word; //по какому слову
+  configuration(int x):index(x), word("1"){};
+  configuration(int x, std::string s): index(x), word(s){};
+};
+
+struct way {
+  int index; //откуда иду
+  std::string word; //по какому слову
+  way(int x, std::string s): index(x), word(s){};
+  way(int x): index(x), word("1"){};
+};
+
+struct reg_state {
+  std::vector<configuration> inputs;
+  std::vector<way> outputs;
+  std::string mesh = "1";
+  reg_state() = default;
+};
+
+class Regular_automat {
+ private:
+  std::vector<bool> IsUsed_;
+  std::vector<reg_state> reg_states_;
+  int size_;
+  int S_size_;
+  void DeleteState(int index);
+  void Filch(int index);
+ public:
+  Regular_automat(DFSM aut);
+  void MakeRegular();
+  void print_for_latex();
+  std::string GetRegex();
+  void PrintRegex();
+  void PrintForLatex();
+
+};
diff --git a/FSM/include/State.h b/FSM/include/State.h
new file mode 100644
index 0000000..07ebc59
--- /dev/null
+++ b/FSM/include/State.h
@@ -0,0 +1,21 @@
+#pragma once
+#include<vector>
+#include<bitset>
+#include "globals.h"
+
+struct State {
+  std::vector<std::bitset<MaxStateNumber>> tranzitions;
+
+  std::bitset<MaxStateNumber> way_by_letter(int x);
+  std::bitset<MaxStateNumber> way_by_eps();
+  void Unite(int letter, std::bitset<MaxStateNumber>);
+  bool IsTranzIncludeState(int letter, int state_id);
+  std::bitset<MaxStateNumber> WayByLetter(int letter);
+  void SetWayByLetter(int letter, std::bitset<MaxStateNumber>);
+  void SetSize(int new_size);
+};
+
+struct DetState {
+  std::vector<std::bitset<MaxStateNumber>> tranzitions;
+  std::bitset<MaxStateNumber> mask;
+};
diff --git a/FSM/include/globals.h b/FSM/include/globals.h
new file mode 100644
index 0000000..db05335
--- /dev/null
+++ b/FSM/include/globals.h
@@ -0,0 +1,3 @@
+#pragma once
+const int MaxStateNumber = 64;
+const int SigmaSize = 2;
diff --git a/FSM/include/math/utility.h b/FSM/include/math/utility.h
new file mode 100644
index 0000000..a45e5e4
--- /dev/null
+++ b/FSM/include/math/utility.h
@@ -0,0 +1,3 @@
+#pragma once
+int charBiject(char c);
+char intBiject(int x);
\ No newline at end of file
diff --git a/FSM/include/tmp.txt b/FSM/include/tmp.txt
new file mode 100644
index 0000000..704b3d0
--- /dev/null
+++ b/FSM/include/tmp.txt
@@ -0,0 +1,88 @@
+#include "DFSM.h"
+
+int IndexState::way_by_letter(int letter) {
+  return tranzitions[letter];
+}
+
+DFSM::DFSM(NFSM fsm){
+  std::vector<State> old_states = fsm.getStates();
+  std::vector<DetState> new_states;
+  std::bitset<MaxStateNumber> old_F = fsm.getF();
+  std::cout << std::endl;
+  int old_size = fsm.getSize();
+
+  S_size_ = SigmaSize;
+  F_ = 0;
+
+  std::queue<std::bitset<MaxStateNumber>> WorkingStates;
+  std::unordered_set<std::bitset<MaxStateNumber>, std::hash<std::bitset<MaxStateNumber>>> UsedStates;
+  std::bitset<MaxStateNumber> zero;
+
+  zero.set(0);
+  UsedStates.insert(zero);
+  WorkingStates.push(zero);
+
+  DetState new_state;
+  new_state.tranzitions.resize(S_size_+1);
+
+  while (!WorkingStates.empty()) {
+    new_state.mask = WorkingStates.front();
+    WorkingStates.pop();
+    new_state.tranzitions.resize(S_size_ + 1);
+    for(int c = 1; c < S_size_+1; ++c) {
+      new_state.tranzitions[c] = 0;
+      for (int k = 0; k < old_size; ++k) {
+        if (new_state.mask.test(k)) {
+          new_state.tranzitions[c] |= old_states[k].way_by_letter(c);
+        }
+      }
+      if (UsedStates.find(new_state.tranzitions[c]) == UsedStates.end()) {
+        UsedStates.insert(new_state.tranzitions[c]);
+        WorkingStates.push(new_state.tranzitions[c]);
+      }
+    }
+    new_states.push_back(new_state);
+  }
+  states_.resize(new_states.size());
+  size_ = new_states.size();
+  for(int i = 0; i < size_; ++i) {
+    states_[i].resize(S_size_ + 1);
+    for(int c = 1; c < S_size_+1; ++c) {
+      for(int j = 0; j < size_; ++j) {
+        if (new_states[i].tranzitions[c] == new_states[j].mask) {
+          states_[i][c] = j;
+          break;
+        }
+        states_[i][c] = size_-1;
+      }
+    }
+    if ((new_states[i].mask & old_F) != 0) {
+      F_.set(i);
+    }
+  }
+}
+
+
+bool DFSM::RecognizeWord(std::string word) {
+  int pivot = 0;
+  for(int pos = 0; pos < word.size(); ++pos) {
+    pivot = states_[pivot][charBiject(word[pos])];
+  }
+  return F_.test(pivot);
+}
+
+int DFSM::getSize() {
+  return size_;
+}
+
+std::vector<std::vector<int>> DFSM::getStates() {
+  return states_;
+}
+
+std::bitset<MaxStateNumber> DFSM::getF() {
+  return F_;
+}
+
+void DFSM::Complement() {
+  F_ = ~F_;
+}
\ No newline at end of file
diff --git a/FSM/src/DFSM.cpp b/FSM/src/DFSM.cpp
new file mode 100644
index 0000000..7b33726
--- /dev/null
+++ b/FSM/src/DFSM.cpp
@@ -0,0 +1,120 @@
+#include "DFSM.h"
+#include <execution>
+int IndexState::WayByLetter(int letter) {
+  return tranzitions[letter];
+}
+void IndexState::SetSize(int new_size) {
+  tranzitions.resize(new_size);
+}
+void IndexState::SetWayByLetter(int letter, int new_tranz_index){
+  tranzitions[letter] = new_tranz_index;
+}
+
+DFSM::DFSM(std::string file_name) {
+  S_size_ = SigmaSize;
+  std::ifstream input(file_name);
+  input >> size_;
+  int term_flag = 0;
+  for(int i = 0; i < size_; ++i) {
+    input>>term_flag;
+    if (term_flag) {
+      F_.set(i);
+    }
+  }
+  int way_by_letter;
+  states_.resize(size_);
+  if (input.is_open()) {
+    for(int i = 0; i < size_; ++i) {
+      states_[i].SetSize(S_size_+1);
+      for (int c = 1; c < S_size_+1; ++c) {
+        input >> way_by_letter;
+        states_[i].SetWayByLetter(c, way_by_letter);
+      }
+    }
+  } else {
+    std::cout << "error input(no files)" << std::endl;
+    }
+}
+
+DFSM::DFSM(NFSM fsm){
+  std::vector<State> old_states = fsm.getStates();
+  std::vector<DetState> new_states;
+  std::bitset<MaxStateNumber> old_F = fsm.getF();
+  std::cout << std::endl;
+  int old_size = fsm.getSize();
+
+  S_size_ = SigmaSize;
+  F_ = 0;
+
+  std::queue<std::bitset<MaxStateNumber>> WorkingStates;
+  std::unordered_set<std::bitset<MaxStateNumber>, std::hash<std::bitset<MaxStateNumber>>> UsedStates;
+  std::bitset<MaxStateNumber> zero;
+
+  zero.set(0);
+  UsedStates.insert(zero);
+  WorkingStates.push(zero);
+
+  DetState new_state;
+  new_state.tranzitions.resize(S_size_+1);
+
+  while (!WorkingStates.empty()) {
+    new_state.mask = WorkingStates.front();
+    WorkingStates.pop();
+    new_state.tranzitions.resize(S_size_ + 1);
+    for(int c = 1; c < S_size_+1; ++c) {
+      new_state.tranzitions[c] = 0;
+      for (int k = 0; k < old_size; ++k) {
+        if (new_state.mask.test(k)) {
+          new_state.tranzitions[c] |= old_states[k].way_by_letter(c);
+        }
+      }
+      if (UsedStates.find(new_state.tranzitions[c]) == UsedStates.end()) {
+        UsedStates.insert(new_state.tranzitions[c]);
+        WorkingStates.push(new_state.tranzitions[c]);
+      }
+    }
+    new_states.push_back(new_state);
+  }
+  states_.resize(new_states.size());
+  size_ = new_states.size();
+  for(int i = 0; i < size_; ++i) {
+    states_[i].SetSize(S_size_ + 1);
+    for(int c = 1; c < S_size_+1; ++c) {
+      for(int j = 0; j < size_; ++j) {
+        if (new_states[i].tranzitions[c] == new_states[j].mask) {
+          states_[i].SetWayByLetter(c, j);
+          break;
+        }
+        states_[i].SetWayByLetter(c, size_ - 1);
+      }
+    }
+    if ((new_states[i].mask & old_F) != 0) {
+      F_.set(i);
+    }
+  }
+}
+
+
+bool DFSM::RecognizeWord(std::string word) {
+  int pivot = 0;
+  for(int pos = 0; pos < word.size(); ++pos) {
+    pivot = states_[pivot].WayByLetter(charBiject(word[pos]));
+  }
+  return F_.test(pivot);
+}
+
+int DFSM::getSize() {
+  return size_;
+}
+
+std::vector<IndexState> DFSM::getStates() {
+  return states_;
+}
+
+std::bitset<MaxStateNumber> DFSM::getF() {
+  return F_;
+}
+
+void DFSM::Complement() {
+  F_ = ~F_;
+}
\ No newline at end of file
diff --git a/FSM/src/MDFSM.cpp b/FSM/src/MDFSM.cpp
new file mode 100644
index 0000000..ca4a9dc
--- /dev/null
+++ b/FSM/src/MDFSM.cpp
@@ -0,0 +1,110 @@
+#include "MDFSM.h"
+
+
+MDFSM::MDFSM(DFSM dfsm) {
+  size_ = dfsm.getSize();
+  S_size_ = SigmaSize;
+  std::vector<IndexState> old_states = dfsm.getStates();
+  std::bitset<MaxStateNumber> old_F = dfsm.getF();
+
+  std::vector<int> state_to_class(size_);
+  std::vector<int> state_to_class_old(size_);
+  std::vector<int> new_link(size_);
+
+  int term_represent;
+  int nonterm_represent;
+
+  for(int i = 0; i < size_; ++i) {
+    if (old_F.test(i)) {
+      term_represent = i;
+      break;
+    }
+  }
+  for(int i = 0; i < size_; ++i) {
+    if (!old_F.test(i)) {
+      nonterm_represent = i;
+      break;
+    }
+  }
+
+  for(int i = 0; i < size_; ++i) {
+    if (old_F.test(i)) {
+      state_to_class[i] = term_represent;
+    } else {
+      state_to_class[i] = nonterm_represent;
+    }
+  }
+
+  std::map<std::pair<int, int>, int> new_classes_represent; //новые классы определяются в зависимости от пары начало->конец
+  int last_size = 2;
+  int new_size = 0;
+  while (new_size != last_size) {
+    last_size = new_size;
+    for(int c = 1; c < S_size_+1; ++c) {
+      state_to_class_old = state_to_class;
+      for (int i = 0; i < size_; ++i) {
+        new_link[i] = state_to_class_old[old_states[i].WayByLetter(c)];
+        if (new_classes_represent.find({state_to_class_old[i], new_link[i]}) == new_classes_represent.end()) {
+         //Если еще не задан репрезентативный для данного перехода
+         new_classes_represent[{state_to_class_old[i], new_link[i]}] = i;
+         state_to_class[i] = i;
+        } else {
+          state_to_class[i] = new_classes_represent[{state_to_class_old[i], new_link[i]}];
+        }
+      }
+      new_size = new_classes_represent.size();
+      new_classes_represent.clear();
+    }
+  }
+
+  BuildStatesByClasses(state_to_class, old_states, old_F);
+}
+
+void MDFSM::BuildStatesByClasses(std::vector<int> state_to_class,
+                                 std::vector<IndexState> last_states,
+                                 std::bitset<MaxStateNumber> old_F) {
+
+  std::set<int> dif_classes;
+  for(const int& repr: state_to_class) { // добавляем классы в множество
+    dif_classes.insert(repr);
+  }
+
+  //тут информация про связь старых и новых классов через индексы репрезентативных
+  std::map<int, int> new_index_to_old_repr_index;
+  std::map<int, int> old_repr_index_to_new_index;
+  std::set<int> used_classes_ind;
+  int last_class_index = 0;
+
+  //делаем все классы идущими по порядку
+  for(int& repr: state_to_class) { // переделываем классы для минимальных
+    if (used_classes_ind.find(repr) != used_classes_ind.end()) { //если для этого класса уже найден индекс нового
+      repr = old_repr_index_to_new_index[repr];
+    } else {
+      used_classes_ind.insert((repr));
+      old_repr_index_to_new_index[repr] = last_class_index;
+      new_index_to_old_repr_index[last_class_index] = repr;
+      repr = last_class_index;
+      last_class_index++;
+    }
+  }
+
+  size_ = last_class_index;
+  states_.resize(size_);
+
+  //наконец переназначаем классы и делаем из них автомат
+  for(int i = 0; i < size_; ++i) {
+    states_[i].SetSize(S_size_ + 1);
+    for(int c = 1; c < S_size_+1; ++c) {
+      int new_way = state_to_class[last_states[new_index_to_old_repr_index[i]].WayByLetter(c)];
+      states_[i].SetWayByLetter(c, new_way);
+    }
+  }
+
+  F_ = 0;
+  for(int i = 0; i < last_states.size(); ++i) {
+    if (old_F.test(i)) {
+      F_.set(state_to_class[i]);
+    }
+  }
+}
+
diff --git a/FSM/src/NFSM.cpp b/FSM/src/NFSM.cpp
new file mode 100644
index 0000000..ba1992c
--- /dev/null
+++ b/FSM/src/NFSM.cpp
@@ -0,0 +1,203 @@
+#include "NFSM.h"
+#include "utility.h"
+
+
+bool EpsInfoState::Find(std::string word) {
+  for(const auto& w: attempts) {
+    if (w == word) {
+      return true;
+    }
+  }
+  return false;
+}
+
+
+NFSM::NFSM() {
+  q0_ = 0;
+  size_ = 0;
+  F_ = 0;
+  edge_size_ = 0;
+  IsEpsExist = false;
+  S_size_ = SigmaSize;
+}
+
+NFSM::NFSM(const std::string& file) {
+  std::ifstream input(file);
+  int bit;
+  if (input.is_open()) {
+    input >> size_;
+    input >> edge_size_;
+    SeenBefore.resize(size_);
+    states_.resize(size_);
+    F_ = 0;
+    for(int i = 0; i < size_; ++i) {
+      input >> bit;
+      if (bit == 1) {
+        F_.set(i);
+      }
+      states_[i].SetSize((S_size_+1));
+      states_[i].tranzitions.resize(S_size_ + 1);
+    }
+    int index;
+    char tranzit_char;
+    int to_state_index;
+    for(int i = 0; i < edge_size_; ++i) {
+      input >> index;
+      input >> tranzit_char;
+      input >> to_state_index;
+      std::bitset<MaxStateNumber> to_state_index_mask;
+      to_state_index_mask.set(to_state_index);
+      states_[index].Unite(charBiject(tranzit_char), to_state_index_mask);
+    }
+  } else {
+    std::cout << "error input(no files)";
+  }
+  input.close();
+}
+void NFSM::FilchEps() {
+  std::bitset<MaxStateNumber> tmp_set;
+  for (int j = 0; j < size_; ++j) {//пройдем по всем состояниям
+    for (int k = 0; k < size_; ++k) { //проверяем можно ли прийти в эту вершину по eps
+      tmp_set = states_[j].way_by_eps();
+      if (states_[j].IsTranzIncludeState(0, k)) {
+        for(int c = 0; c <= S_size_; ++c) { //по буквам итерируемся
+          states_[j].Unite(c, states_[k].way_by_letter(c));
+        }
+      }
+      if (states_[j].way_by_eps() != tmp_set) {
+        k = -1; // to get 0 after for
+      }
+    }
+    if ((states_[j].way_by_eps() & F_) != 0) {
+      F_.set(j);
+    }
+  }
+  IsEpsExist = false;
+}
+bool NFSM::RecognizeWord(std::string word) {
+  if (IsEpsExist) {
+    bool ret = RecognizeWordIfExistEps(word, 0);
+    SeenBefore.clear();
+    return ret;
+  }
+  return RecognizeWordIfNoEps(word, 0);
+}
+
+bool NFSM::RecognizeWordIfExistEps(std::string word, int pivot) {
+  if (word == "") {
+    if (!SeenBefore[pivot].Find(word)) {
+    SeenBefore[pivot].attempts.push_back(word);
+      for(int i = 0; i < size_; ++i) {
+        if (states_[pivot].IsTranzIncludeState(0, i)) {
+          if (RecognizeWordIfExistEps(word, i)) {
+            return true;
+          }
+        }
+      }
+    }
+    return F_.test(pivot);
+  }
+
+  std::string new_word = word;
+  new_word.erase(0, 1);
+
+  for(int c = 1; c < S_size_ + 1; ++c) {
+    for(int i = 0; i < size_; ++i) {
+      if (states_[pivot].IsTranzIncludeState(charBiject(word[0]), i)) {
+        if (RecognizeWordIfExistEps(new_word, i)) {
+          return true;
+        }
+      }
+    }
+  }
+
+  if (!SeenBefore[pivot].Find(word)) {
+    SeenBefore[pivot].attempts.push_back(word);
+    for(int i = 0; i < size_; ++i) {
+      if (states_[pivot].IsTranzIncludeState(0, i)) {
+        if (RecognizeWordIfExistEps(word, i)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+bool NFSM::RecognizeWordIfNoEps(std::string word, int pivot = 0) {
+  if (word.empty()) {
+    return F_.test(pivot);
+  }
+  int reading_sumbol = word[0];
+  word.erase(0, 1);
+  for(int c = 1; c < S_size_+1; ++c) {
+    for(int j = 0; j < size_; ++j) {
+      if (states_[pivot].IsTranzIncludeState(charBiject(reading_sumbol), j)) {
+        if (RecognizeWordIfNoEps(word, j)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+int NFSM::getSize() { return size_; }
+
+void NFSM::print_states() {
+  for(int i = 0; i < size_; ++i) {
+    std::cout << "1: " << states_[i].tranzitions[0] << std::endl;
+    std::cout << "a: " << states_[i].tranzitions[1] << std::endl;
+    std::cout << "b: " << states_[i].tranzitions[2] << std::endl;
+    std::cout << std::endl;
+    std::cout << std::endl;
+    std::cout << std::endl;
+  }
+  std::cout << F_;
+}
+
+void NFSM::print_ndsm() {
+  for(int i = 0; i < size_; ++i) {
+    for(int c = 1; c < S_size_+1; ++c) {
+      for(int j = 0; j < size_; ++j) {
+        if(states_[i].WayByLetter(c).test(j)) {
+          std::cout << "(" << i << ", "<< intBiject(c) <<") -> " << j << std::endl;
+        }
+      }
+    }
+  }
+  for(int c = 0; c < size_; ++c) {
+    if (F_.test(c)) {
+      std::cout << c << " ";
+    }
+  }
+}
+
+void NFSM::print_in_input_format() {
+  std::cout << size_ << std::endl;
+  for(int c = 0; c < size_; ++c) {
+    if (F_.test(c)) {
+      std::cout << 1 << " ";
+    } else {
+      std::cout << 0 << " ";
+    }
+  }
+  std::cout << std::endl;
+  for(int i = 0; i < size_; ++i) {
+    for(int c = 1; c < S_size_+1; ++c) {
+      for(int j = 0; j < size_; ++j) {
+        if(states_[i].WayByLetter(c).test(j)) {
+          std::cout << i << " "<< intBiject(c) << " "<< j << std::endl;
+        }
+      }
+    }
+  }
+}
+
+std::vector<State> NFSM::getStates() {
+    return states_;
+}
+
+std::bitset<MaxStateNumber> NFSM::getF() {
+  return F_;
+}
diff --git a/FSM/src/RegularFSM.cpp b/FSM/src/RegularFSM.cpp
new file mode 100644
index 0000000..da83d28
--- /dev/null
+++ b/FSM/src/RegularFSM.cpp
@@ -0,0 +1,124 @@
+#include"RegularFSM.h"
+
+Regular_automat::Regular_automat(DFSM aut) {
+  std::vector<IndexState> old_states = aut.getStates();
+  std::bitset<MaxStateNumber> old_F = aut.getF();
+  size_ = aut.getSize();
+  reg_states_.resize(size_+1);
+  S_size_ = SigmaSize;
+  std::string tranz_word;
+  int tranz_state_index;
+  for(int i = 0; i < size_; ++i) {
+    for(int c = 1; c < S_size_ + 1; ++c) {
+      tranz_word = intBiject(c);
+      tranz_state_index = old_states[i].WayByLetter(c);
+      if (tranz_state_index == i) {
+        reg_states_[i].mesh = tranz_word;
+        continue;
+      }
+      reg_states_[i].outputs.push_back(way(tranz_state_index, tranz_word));
+      reg_states_[tranz_state_index].inputs.push_back(configuration(i, tranz_word));
+    }
+    if (old_F.test(i)) {
+      reg_states_[i].outputs.push_back(way(aut.getSize(), "1"));
+      reg_states_[size_].inputs.push_back(configuration(i, "1"));
+    }
+  }
+  size_++;
+  MakeRegular();
+}
+
+void Regular_automat::MakeRegular() {
+  for(int i = 1; i < size_-1; ++i) {
+    Filch(i);
+  }
+}
+
+void Regular_automat::Filch(int index) {
+  reg_state pivot = reg_states_[index];
+  std::string new_word;
+  for(configuration& conf_in : pivot.inputs) {
+    for (way& way_out : pivot.outputs) {
+      if (pivot.mesh == "1") {
+        new_word = /*"("*/ conf_in.word + way_out.word/* + ")"*/;
+      } else {
+        new_word = /*"("*/ conf_in.word + "(" + pivot.mesh + ")*" + way_out.word/* + ")"*/;
+      }
+      if (way_out.index == conf_in.index) {
+        reg_states_[way_out.index].mesh = "(" + reg_states_[way_out.index].mesh + "+" + new_word + ")";
+        continue;
+      }
+      bool filching_flag = false;
+      for (way& way_of_in : reg_states_[conf_in.index].outputs) { // проверяем на то если уже есть такой путь из предшествующего
+        if (way_of_in.index == way_out.index) {
+          way_of_in = {way_out.index, "(" + way_of_in.word + "+" + new_word + ")"};
+          filching_flag = true;
+          continue;
+        }
+      }
+      for(configuration& conf_of_out : reg_states_[way_out.index].inputs) {  //
+        if (conf_of_out.index == conf_in.index) {
+          conf_of_out = {conf_in.index, "(" + conf_of_out.word + "+" + new_word + ")"};
+          continue;
+        }
+      }
+      if (!filching_flag) {
+        reg_states_[conf_in.index].outputs.push_back({way_out.index, new_word});
+        reg_states_[way_out.index].inputs.push_back({conf_in.index, new_word});
+      }
+    }
+  }
+  DeleteState(index);
+}
+
+void Regular_automat::DeleteState(int index) {
+  IsUsed_.resize(size_);
+  bool break_flag = false;
+  for(configuration& conf : reg_states_[index].inputs) {
+    if (break_flag) {
+      break;
+    }
+    for(int i = 0; i < reg_states_[conf.index].outputs.size(); ++i) {
+      if (reg_states_[conf.index].outputs[i].index == index) {
+        reg_states_[conf.index].outputs.erase(reg_states_[conf.index].outputs.begin() + i);
+        break_flag = false;
+        break;
+      }
+    }
+  }
+  break_flag = false;
+  for(way& way_in : reg_states_[index].outputs) {
+    if (break_flag) {
+      break;
+    }
+    for(int i = 0; i < reg_states_[way_in.index].inputs.size(); ++i) {
+      if (reg_states_[way_in.index].inputs[i].index == index) {
+        reg_states_[way_in.index].inputs.erase(reg_states_[way_in.index].inputs.begin() + i);
+        break_flag = false;
+        break;
+      }
+    }
+  }
+  IsUsed_[index] = true;
+  reg_states_[index].outputs.clear();
+  reg_states_[index].inputs.clear();
+}
+
+
+std::string Regular_automat::GetRegex() {
+  return "(" + reg_states_[0].mesh + ")*" + "(" + reg_states_[0].outputs[0].word + ")";
+}
+
+void Regular_automat::PrintRegex() {
+  std::cout << GetRegex();
+}
+
+void Regular_automat::PrintForLatex() {
+    std::string reg = GetRegex();
+    for (char& c : reg) {
+      if (c == '*') {
+        std::cout << "^";
+      }
+      std::cout << c;
+    }
+  }
\ No newline at end of file
diff --git a/FSM/src/State.cpp b/FSM/src/State.cpp
new file mode 100644
index 0000000..27cf11b
--- /dev/null
+++ b/FSM/src/State.cpp
@@ -0,0 +1,29 @@
+#include "State.h"
+
+std::bitset<MaxStateNumber> State::way_by_letter(int n) {
+  return tranzitions[n];
+}
+
+std::bitset<MaxStateNumber> State::way_by_eps() {
+  return tranzitions[0];
+}
+
+void State::Unite(int letter, std::bitset<MaxStateNumber> states_mask) {
+  tranzitions[letter] |= states_mask;
+}
+
+bool State::IsTranzIncludeState(int letter, int state_id) {
+  return tranzitions[letter].test(state_id);
+}
+
+std::bitset<MaxStateNumber> State::WayByLetter(int letter) {
+  return tranzitions[letter];
+}
+
+void State::SetWayByLetter(int letter, std::bitset<MaxStateNumber> new_way) {
+  tranzitions[letter] = new_way;
+}
+
+void State::SetSize(int new_size) {
+  tranzitions.resize(new_size);
+}
\ No newline at end of file
diff --git a/FSM/src/math_func/utility.cpp b/FSM/src/math_func/utility.cpp
new file mode 100644
index 0000000..e36cbae
--- /dev/null
+++ b/FSM/src/math_func/utility.cpp
@@ -0,0 +1,15 @@
+#include "utility.h"
+
+int charBiject(char c) {
+  if (c == '1') {
+    return 0;
+  }
+  return c - 'a' + 1;
+}
+
+char intBiject(int x) {
+  if (x == 0) {
+    return '1';
+  }
+  return x + 'a' - 1;
+}
diff --git a/README.md b/README.md
index 6394bd8..0875b7d 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,102 @@
 # FiniteStateMachine
+
+## Для сборки проекта достаточно в корне:
+mkdir build  
+cd build  
+cmake ..  
+make  
+Для запуска тестов можно перейти в src/bin и исполнить бинарник  
+Бинарник для запуска основной программы лежать будет в build  
+
+Если вы хотите запустить через Clion, можно открыть как проект и запустить либо run для программы либо BasicFsmTests - это запустит все тесты  
+
+## Как задавать автомат:
+- 0-е состояние всегда начальное.  
+- ## Формат входных данных в файл для NFSM:
+#вершин #ребер  
+маска терминальных вершин (например 1 0 0 0 1 0 0) - означает, что терминальные: 0, 4)
+Переходы в формате:  
+src letter path - тут из src ведет стрелка в path по букве letter
+При этом letter = 1 - означает, что переходы по eps.
+### Пример:
+4 4  
+0 0 0 1  
+0 1 1  
+1 1 2  
+2 a 3  
+3 a 3  
+Задает автомат:  
+![](tests/img/NFSM1.jpg)
+
+- ## Формат входных данных в файл для DFSM: 
+#вершин(n)  
+маска терминальных вершин  
+x0 y0  
+x1 y1  
+.....  
+xn yn  
+где xi, yi - вершины куда есть переход из i по a, b соответственно  
+
+### Пример:
+5  
+0 1 1 1 0  
+1 4  
+2 4  
+3 4  
+3 4  
+4 4  
+Задает автомат:
+![](tests/img/DFSM1.jpg)
+
+- ##### MDFSM задается аналогично DFSM, но тогда нужно гарантировать то что для данного языка он введен верно
+3  
+0 1 0  
+1 2  
+1 2  
+2 2  
+Задает автомат:  
+![](tests/img/MDFSM1.jpg)
+
+
+# Краткое описание необходимых методов:
+### NFSM:
+- NFSM(filename) - делает из данного файла NFSM
+- FilchEps() - стягивает eps-переходы
+- bool RecognizeWord(word) - возвращает результат принадлежания word языку этого автомата
+### DFSM:
+- DFSM(NFSM) - конструктор из NFSM
+- DFSM(filename) - конструктор из файла, при этом будьте внимательны входной автомат должен быть ПДКА
+- bool RecognizeWord(word) - ...
+### MDFSM
+- MDFSM(DFSM) - делает из DFSM минимизируя его
+- RecoginzeWord(word) - ...
+- Complement() - преобразуется в дополнение
+### RegularFSM
+Этот класс отвечает за построение регулярки - на самом деле это не автомат)))
+- Regular_automat(DFSM) - конструктор из DFSM
+- MakeRegular() - преобразует себя в подобающий для дальнейшего вид - рекомендуется исполнятт всякий раз после создания
+- PrintRegex() - выводит регулярку в командную строку
+- PrintForLatex() - выводит ту же регулярку чтоб закинуть ее в Latex
+
+При этом в дирректории tests/SM_examples вы можете посмотреть некоторые автоматыи как их вводить, в частности:
+## Для NFSM:
+|Q| |delta|
+Маски для состояний(1 - завершающее, 0 - нет)  
+переходы (q1, v) -> q2 в формате q1_v_q2  
+## Для MDFSM
+- |Q|  
+Маски для состояний(1 - завершающее, 0 - нет)  
+i_j   
+где i, j - это переходы из данной вешины(по номеру запроса) в буквы a и b  
+
+
+При этом можно обобщить на больший алфавит но те же входные данные мои не пойдут но можно прееделать очевидным образом и изменить глобальную константу
+
+### Регулярка для моих тестовых автоматов:
+1. a+
+2. (a+b)
+3. (1 + (a+b)*b)b(a+b)*
+4. (ab+ba)*(1 + a + ba)
+5. (aa)*b + ((a+b)^2)*  
+
+Они все из наших дз к слову
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..a620cda
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,16 @@
+#include "DFSM.h"
+#include "NFSM.h"
+#include "RegularFSM.h"
+#include "MDFSM.h"
+
+int main() {
+  NFSM nfsm("../tests/SM_examples/NFSM_examples/nfsm1.txt"); // файл c примером автомата из ридинга (a+)
+  DFSM dfsm("../tests/SM_examples/DFSM_examples/dfsm1.txt");
+  std::cout << nfsm.RecognizeWord("aaa");
+  std::cout << nfsm.RecognizeWord("bbb");
+  std::cout << nfsm.RecognizeWord("") << std::endl;
+  std::cout << dfsm.RecognizeWord("aaa");
+  std::cout << dfsm.RecognizeWord("bbb");
+  std::cout << dfsm.RecognizeWord("");
+  return 0;
+}
\ No newline at end of file
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
new file mode 100644
index 0000000..6a5e4f0
--- /dev/null
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,68 @@
+cmake_minimum_required(VERSION 3.6)
+project(gtest)
+
+enable_testing()
+
+include_directories(
+        ${gtest_SOURCE_DIR}/include
+        ${gtest_SOURCE_DIR}
+        basic_tests/my_tests
+        ../FSM/include
+        ../FSM/include/math
+        )
+
+add_subdirectory(
+        lib/googletest
+        )
+
+set(TEST_SOURCE
+        basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm1_test.cpp
+        basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm2_test.cpp
+        basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm3_test.cpp
+        basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm4_test.cpp
+        basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm5_test.cpp
+
+        basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm1_test.cpp
+        basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm2_test.cpp
+        basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm3_test.cpp
+        basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm4_test.cpp
+        basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm5_test.cpp
+
+        basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm1_convert_test.cpp
+        basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm2_convert_test.cpp
+        basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm3_convert_test.cpp
+        basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm4_convert_test.cpp
+        basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm5_convert_test.cpp
+
+        basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm1_convert_test.cpp
+        basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm2_convert_test.cpp
+        basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm3_convert_test.cpp
+        basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm4_convert_test.cpp
+        basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm5_convert_test.cpp
+
+        basic_tests/word_rec_tests/DFSM_tests/DFSM_test1.cpp
+        basic_tests/word_rec_tests/DFSM_tests/DFSM_test2.cpp
+        basic_tests/word_rec_tests/DFSM_tests/DFSM_test3.cpp
+        basic_tests/word_rec_tests/DFSM_tests/DFSM_test4.cpp
+        basic_tests/word_rec_tests/DFSM_tests/DFSM_test5.cpp
+
+        basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test1.cpp
+        basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test2.cpp
+        basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test3.cpp
+        basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test4.cpp
+        basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test5.cpp
+        )
+
+add_executable(BasicFsmTests
+        ../FSM/src/NFSM.cpp
+        ../FSM/src/DFSM.cpp
+        ../FSM/src/MDFSM.cpp
+        ../FSM/src/RegularFSM.cpp
+        ../FSM/src/State.cpp
+        ../FSM/src/math_func/utility.cpp
+        ${TEST_SOURCE}
+        )
+
+set(EXECUTABLE_OUTPUT_PATH  ${PROJECT_SOURCE_DIR}/bin)
+
+target_link_libraries(BasicFsmTests gtest gtest_main)
\ No newline at end of file
diff --git a/tests/SM_examples/DFSM_examples/dfsm1.txt b/tests/SM_examples/DFSM_examples/dfsm1.txt
new file mode 100644
index 0000000..7e1ba25
--- /dev/null
+++ b/tests/SM_examples/DFSM_examples/dfsm1.txt
@@ -0,0 +1,7 @@
+5
+0 1 1 1 0
+1 4
+2 4
+3 4
+3 4
+4 4
diff --git a/tests/SM_examples/DFSM_examples/dfsm2.txt b/tests/SM_examples/DFSM_examples/dfsm2.txt
new file mode 100644
index 0000000..9c96fe8
--- /dev/null
+++ b/tests/SM_examples/DFSM_examples/dfsm2.txt
@@ -0,0 +1,7 @@
+6
+0 1 1 0 0 0
+1 2
+3 4
+4 3
+4 4
+5 5
\ No newline at end of file
diff --git a/tests/SM_examples/DFSM_examples/dfsm3.txt b/tests/SM_examples/DFSM_examples/dfsm3.txt
new file mode 100644
index 0000000..6190eb0
--- /dev/null
+++ b/tests/SM_examples/DFSM_examples/dfsm3.txt
@@ -0,0 +1,12 @@
+10
+0 1 1 1 0 0 1 1 1 1
+4 1
+2 3
+2 2
+2 2
+4 5
+4 6
+7 9
+7 8
+7 9
+7 9
\ No newline at end of file
diff --git a/tests/SM_examples/DFSM_examples/dfsm4.txt b/tests/SM_examples/DFSM_examples/dfsm4.txt
new file mode 100644
index 0000000..ff4c143
--- /dev/null
+++ b/tests/SM_examples/DFSM_examples/dfsm4.txt
@@ -0,0 +1,7 @@
+5
+1 1 0 1 0
+1 2
+4 0
+3 4
+1 2
+4 4
\ No newline at end of file
diff --git a/tests/SM_examples/DFSM_examples/dfsm5.txt b/tests/SM_examples/DFSM_examples/dfsm5.txt
new file mode 100644
index 0000000..b502dba
--- /dev/null
+++ b/tests/SM_examples/DFSM_examples/dfsm5.txt
@@ -0,0 +1,9 @@
+7
+1 0 1 1 1 1 0
+1 3
+2 5
+1 3
+5 4
+6 3
+6 6
+5 5
\ No newline at end of file
diff --git a/tests/SM_examples/MDFSM_examples/mdfsm1.txt b/tests/SM_examples/MDFSM_examples/mdfsm1.txt
new file mode 100644
index 0000000..c000f6d
--- /dev/null
+++ b/tests/SM_examples/MDFSM_examples/mdfsm1.txt
@@ -0,0 +1,5 @@
+3
+0 1 0
+1 2
+1 2
+2 2
\ No newline at end of file
diff --git a/tests/SM_examples/MDFSM_examples/mdfsm2.txt b/tests/SM_examples/MDFSM_examples/mdfsm2.txt
new file mode 100644
index 0000000..21928a1
--- /dev/null
+++ b/tests/SM_examples/MDFSM_examples/mdfsm2.txt
@@ -0,0 +1,5 @@
+3
+0 1 0
+1 1
+2 2
+2 2
\ No newline at end of file
diff --git a/tests/SM_examples/MDFSM_examples/mdfsm3.txt b/tests/SM_examples/MDFSM_examples/mdfsm3.txt
new file mode 100644
index 0000000..f9eb0c5
--- /dev/null
+++ b/tests/SM_examples/MDFSM_examples/mdfsm3.txt
@@ -0,0 +1,5 @@
+3
+0 0 1
+1 2
+1 0
+2 2
\ No newline at end of file
diff --git a/tests/SM_examples/MDFSM_examples/mdfsm4.txt b/tests/SM_examples/MDFSM_examples/mdfsm4.txt
new file mode 100644
index 0000000..56290f5
--- /dev/null
+++ b/tests/SM_examples/MDFSM_examples/mdfsm4.txt
@@ -0,0 +1,6 @@
+4
+1 1 0 0
+1 2
+3 0
+0 3
+3 3
\ No newline at end of file
diff --git a/tests/SM_examples/MDFSM_examples/mdfsm5.txt b/tests/SM_examples/MDFSM_examples/mdfsm5.txt
new file mode 100644
index 0000000..dcc7689
--- /dev/null
+++ b/tests/SM_examples/MDFSM_examples/mdfsm5.txt
@@ -0,0 +1,8 @@
+6
+1 0 1 1 1 0
+1 2
+0 3
+3 4
+5 5
+5 2
+3 3
\ No newline at end of file
diff --git a/tests/SM_examples/NFSM_examples/nfsm1.txt b/tests/SM_examples/NFSM_examples/nfsm1.txt
new file mode 100644
index 0000000..f224985
--- /dev/null
+++ b/tests/SM_examples/NFSM_examples/nfsm1.txt
@@ -0,0 +1,6 @@
+4 4
+0 0 0 1
+0 1 1
+1 1 2
+2 a 3
+3 a 3
diff --git a/tests/SM_examples/NFSM_examples/nfsm2.txt b/tests/SM_examples/NFSM_examples/nfsm2.txt
new file mode 100644
index 0000000..621d498
--- /dev/null
+++ b/tests/SM_examples/NFSM_examples/nfsm2.txt
@@ -0,0 +1,8 @@
+6 6
+0 0 0 0 0 1
+0 1 1
+0 1 3
+1 a 2
+3 b 4
+2 1 5
+4 1 5
\ No newline at end of file
diff --git a/tests/SM_examples/NFSM_examples/nfsm3.txt b/tests/SM_examples/NFSM_examples/nfsm3.txt
new file mode 100644
index 0000000..b78be65
--- /dev/null
+++ b/tests/SM_examples/NFSM_examples/nfsm3.txt
@@ -0,0 +1,15 @@
+7 13
+0 0 0 0 0 0 1
+0 1 1
+0 1 3
+3 1 4
+4 1 3
+3 a 4
+3 b 4
+4 b 2
+1 1 2
+2 b 5
+5 a 6
+5 b 6
+5 1 6
+6 1 5
diff --git a/tests/SM_examples/NFSM_examples/nfsm4.txt b/tests/SM_examples/NFSM_examples/nfsm4.txt
new file mode 100644
index 0000000..8110abd
--- /dev/null
+++ b/tests/SM_examples/NFSM_examples/nfsm4.txt
@@ -0,0 +1,14 @@
+11 12
+1 0 0 0 0 0 0 1 0 1 1
+0 1 1
+1 a 2
+2 b 3
+3 1 0
+0 1 4
+4 b 5
+5 a 6
+6 1 0
+0 1 7
+7 b 8
+8 a 9
+7 a 10
diff --git a/tests/SM_examples/NFSM_examples/nfsm5.txt b/tests/SM_examples/NFSM_examples/nfsm5.txt
new file mode 100644
index 0000000..9cc0572
--- /dev/null
+++ b/tests/SM_examples/NFSM_examples/nfsm5.txt
@@ -0,0 +1,14 @@
+7 12
+0 0 0 1 0 0 1
+0 1 1
+1 1 3
+3 b 3
+1 a 2
+2 a 1
+0 1 4
+4 1 6
+6 1 4
+4 a 5
+4 b 5
+5 a 6
+5 b 6
\ No newline at end of file
diff --git a/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm1_convert_test.cpp b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm1_convert_test.cpp
new file mode 100644
index 0000000..72c8d0d
--- /dev/null
+++ b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm1_convert_test.cpp
@@ -0,0 +1,48 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+class TestMDFSM1_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    DFSM dfsm("../SM_examples/DFSM_examples/dfsm1.txt");
+    mdfsm_ = new MDFSM(dfsm);
+  }
+  void TearDown() {
+    delete mdfsm_;
+  }
+  DFSM* mdfsm_;
+};
+TEST_F(TestMDFSM1_convert, test_size1) {
+  std::cout << mdfsm_->getSize();
+ASSERT_EQ(mdfsm_->getSize(), size1);
+}
+TEST_F(TestMDFSM1_convert, test1) {
+ASSERT_EQ(mdfsm_->RecognizeWord(Test1_1.word) , Test1_1.answer);
+}
+TEST_F(TestMDFSM1_convert, test2) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_2.word) , Test1_2.answer);
+}
+TEST_F(TestMDFSM1_convert, test3) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_3.word) , Test1_3.answer);
+}
+TEST_F(TestMDFSM1_convert, test4) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_4.word) , Test1_4.answer);
+}
+TEST_F(TestMDFSM1_convert, test5) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_5.word) , Test1_5.answer);
+}
+TEST_F(TestMDFSM1_convert, test6) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_6.word) , Test1_6.answer);
+}
+TEST_F(TestMDFSM1_convert, test7) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_7.word) , Test1_7.answer);
+}
+TEST_F(TestMDFSM1_convert, test8) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_8.word) , Test1_8.answer);
+}
+TEST_F(TestMDFSM1_convert, test9) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_9.word) , Test1_9.answer);
+}
+TEST_F(TestMDFSM1_convert, test10) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_10.word) , Test1_10.answer);
+}
diff --git a/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm2_convert_test.cpp b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm2_convert_test.cpp
new file mode 100644
index 0000000..ae6ec31
--- /dev/null
+++ b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm2_convert_test.cpp
@@ -0,0 +1,49 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+class TestMDFSM2_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    DFSM dfsm("../SM_examples/DFSM_examples/dfsm2.txt");
+    mdfsm_ = new MDFSM(dfsm);
+  }
+  void TearDown() {
+    delete mdfsm_;
+  }
+
+  DFSM* mdfsm_;
+};
+TEST_F(TestMDFSM2_convert, test_size2) {
+  ASSERT_EQ(mdfsm_->getSize(), size2);
+}
+TEST_F(TestMDFSM2_convert, test1) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_1.word) , Test2_1.answer);
+}
+TEST_F(TestMDFSM2_convert, test2) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_2.word) , Test2_2.answer);
+}
+TEST_F(TestMDFSM2_convert, test3) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_3.word) , Test2_3.answer);
+}
+TEST_F(TestMDFSM2_convert, test4) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_4.word) , Test2_4.answer);
+}
+TEST_F(TestMDFSM2_convert, test5) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_5.word) , Test2_5.answer);
+}
+TEST_F(TestMDFSM2_convert, test6) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_6.word) , Test2_6.answer);
+}
+TEST_F(TestMDFSM2_convert, test7) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_7.word) , Test2_7.answer);
+}
+TEST_F(TestMDFSM2_convert, test8) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_8.word) , Test2_8.answer);
+}
+TEST_F(TestMDFSM2_convert, test9) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_9.word) , Test2_9.answer);
+}
+TEST_F(TestMDFSM2_convert, test10) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test2_10.word) , Test2_10.answer);
+}
+
diff --git a/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm3_convert_test.cpp b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm3_convert_test.cpp
new file mode 100644
index 0000000..ff5cac6
--- /dev/null
+++ b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm3_convert_test.cpp
@@ -0,0 +1,48 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+class TestMDFSM3_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    DFSM dfsm("../SM_examples/DFSM_examples/dfsm3.txt");
+    mdfsm_ = new MDFSM(dfsm);
+  }
+  void TearDown() {
+    delete mdfsm_;
+  }
+
+  DFSM* mdfsm_;
+};
+TEST_F(TestMDFSM3_convert, test_size3) {
+  ASSERT_EQ(mdfsm_->getSize(), size3);
+}
+TEST_F(TestMDFSM3_convert, test1) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_1.word) , Test3_1.answer);
+}
+TEST_F(TestMDFSM3_convert, test2) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_2.word) , Test3_2.answer);
+}
+TEST_F(TestMDFSM3_convert, test3) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_3.word) , Test3_3.answer);
+}
+TEST_F(TestMDFSM3_convert, test4) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_4.word) , Test3_4.answer);
+}
+TEST_F(TestMDFSM3_convert, test5) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_5.word) , Test3_5.answer);
+}
+TEST_F(TestMDFSM3_convert, test6) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_6.word) , Test3_6.answer);
+}
+TEST_F(TestMDFSM3_convert, test7) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_7.word) , Test3_7.answer);
+}
+TEST_F(TestMDFSM3_convert, test8) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_8.word) , Test3_8.answer);
+}
+TEST_F(TestMDFSM3_convert, test9) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_9.word) , Test3_9.answer);
+}
+TEST_F(TestMDFSM3_convert, test10) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test3_10.word) , Test3_10.answer);
+}
diff --git a/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm4_convert_test.cpp b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm4_convert_test.cpp
new file mode 100644
index 0000000..bdb624c
--- /dev/null
+++ b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm4_convert_test.cpp
@@ -0,0 +1,48 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+class TestMDFSM4_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    DFSM dfsm("../SM_examples/DFSM_examples/dfsm4.txt");
+    mdfsm_ = new MDFSM(dfsm);
+  }
+  void TearDown() {
+    delete mdfsm_;
+  }
+
+  DFSM* mdfsm_;
+};
+TEST_F(TestMDFSM4_convert, test_size4) {
+  ASSERT_EQ(mdfsm_->getSize(), size4);
+}
+TEST_F(TestMDFSM4_convert, test1) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_1.word) , Test4_1.answer);
+}
+TEST_F(TestMDFSM4_convert, test2) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_2.word) , Test4_2.answer);
+}
+TEST_F(TestMDFSM4_convert, test3) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_3.word) , Test4_3.answer);
+}
+TEST_F(TestMDFSM4_convert, test4) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_4.word) , Test4_4.answer);
+}
+TEST_F(TestMDFSM4_convert, test5) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_5.word) , Test4_5.answer);
+}
+TEST_F(TestMDFSM4_convert, test6) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_6.word) , Test4_6.answer);
+}
+TEST_F(TestMDFSM4_convert, test7) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_7.word) , Test4_7.answer);
+}
+TEST_F(TestMDFSM4_convert, test8) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_8.word) , Test4_8.answer);
+}
+TEST_F(TestMDFSM4_convert, test9) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_9.word) , Test4_9.answer);
+}
+TEST_F(TestMDFSM4_convert, test10) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_10.word) , Test4_10.answer);
+}
diff --git a/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm5_convert_test.cpp b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm5_convert_test.cpp
new file mode 100644
index 0000000..65d7610
--- /dev/null
+++ b/tests/basic_tests/converts_test/DFSM_to_MDFSM_convert_tests/mdfsm5_convert_test.cpp
@@ -0,0 +1,48 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+class TestMDFSM5_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    DFSM dfsm("../SM_examples/DFSM_examples/dfsm5.txt");
+    mdfsm_ = new MDFSM(dfsm);
+  }
+  void TearDown() {
+    delete mdfsm_;
+  }
+
+  DFSM* mdfsm_;
+};
+TEST_F(TestMDFSM5_convert, test_size5) {
+  ASSERT_EQ(mdfsm_->getSize(), size5);
+}
+TEST_F(TestMDFSM5_convert, test1) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_1.word) , Test5_1.answer);
+}
+TEST_F(TestMDFSM5_convert, test2) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_2.word) , Test5_2.answer);
+}
+TEST_F(TestMDFSM5_convert, test3) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_3.word) , Test5_3.answer);
+}
+TEST_F(TestMDFSM5_convert, test4) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_4.word) , Test5_4.answer);
+}
+TEST_F(TestMDFSM5_convert, test5) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_5.word) , Test5_5.answer);
+}
+TEST_F(TestMDFSM5_convert, test6) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_6.word) , Test5_6.answer);
+}
+TEST_F(TestMDFSM5_convert, test7) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_7.word) , Test5_7.answer);
+}
+TEST_F(TestMDFSM5_convert, test8) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_8.word) , Test5_8.answer);
+}
+TEST_F(TestMDFSM5_convert, test9) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_9.word) , Test5_9.answer);
+}
+TEST_F(TestMDFSM5_convert, test10) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test5_10.word) , Test5_10.answer);
+}
diff --git a/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm1_convert_test.cpp b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm1_convert_test.cpp
new file mode 100644
index 0000000..060eb27
--- /dev/null
+++ b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm1_convert_test.cpp
@@ -0,0 +1,83 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+class TestDFSM1_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    NFSM nfsm("../SM_examples/NFSM_examples/nfsm1.txt");
+    nfsm.FilchEps();
+    dfsm_ = new DFSM(nfsm);
+    compl_dfsm = new DFSM(nfsm);
+    compl_dfsm->Complement();
+  }
+  void TearDown() {
+    delete dfsm_;
+    delete compl_dfsm;
+  }
+  DFSM* compl_dfsm;
+  DFSM* dfsm_;
+};
+
+TEST_F(TestDFSM1_convert, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_1.word) , Test1_1.answer);
+}
+TEST_F(TestDFSM1_convert, test1_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_1.word) , !Test1_1.answer);
+}
+
+TEST_F(TestDFSM1_convert, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_2.word) , Test1_2.answer);
+}
+
+TEST_F(TestDFSM1_convert, test2_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_2.word) , !Test1_2.answer);
+}
+
+TEST_F(TestDFSM1_convert, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_3.word) , Test1_3.answer);
+}
+TEST_F(TestDFSM1_convert, test3_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_3.word) , !Test1_3.answer);
+}
+TEST_F(TestDFSM1_convert, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_4.word) , Test1_4.answer);
+}
+TEST_F(TestDFSM1_convert, test4_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_4.word) , !Test1_4.answer);
+}
+TEST_F(TestDFSM1_convert, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_5.word) , Test1_5.answer);
+}
+TEST_F(TestDFSM1_convert, test5_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_5.word) , !Test1_5.answer);
+}
+TEST_F(TestDFSM1_convert, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_6.word) , Test1_6.answer);
+}
+TEST_F(TestDFSM1_convert, test6_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_6.word) , !Test1_6.answer);
+}
+TEST_F(TestDFSM1_convert, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_7.word) , Test1_7.answer);
+}
+TEST_F(TestDFSM1_convert, test7_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_7.word) , !Test1_7.answer);
+}
+TEST_F(TestDFSM1_convert, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_8.word) , Test1_8.answer);
+}
+TEST_F(TestDFSM1_convert, test8_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_8.word) , !Test1_8.answer);
+}
+TEST_F(TestDFSM1_convert, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_9.word) , Test1_9.answer);
+}
+TEST_F(TestDFSM1_convert, test9_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_9.word) , !Test1_9.answer);
+}
+TEST_F(TestDFSM1_convert, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_10.word) , Test1_10.answer);
+}
+TEST_F(TestDFSM1_convert, test10_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test1_10.word) , !Test1_10.answer);
+}
\ No newline at end of file
diff --git a/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm2_convert_test.cpp b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm2_convert_test.cpp
new file mode 100644
index 0000000..108908c
--- /dev/null
+++ b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm2_convert_test.cpp
@@ -0,0 +1,84 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+class TestDFSM2_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    NFSM nfsm("../SM_examples/NFSM_examples/nfsm2.txt");
+    nfsm.FilchEps();
+    dfsm_ = new DFSM(nfsm);
+    compl_dfsm = new DFSM(nfsm);
+    compl_dfsm->Complement();
+  }
+  void TearDown() {
+    delete dfsm_;
+    delete compl_dfsm;
+  }
+  DFSM* compl_dfsm;
+  DFSM* dfsm_;
+};
+
+
+TEST_F(TestDFSM2_convert, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_1.word) , Test2_1.answer);
+}
+TEST_F(TestDFSM2_convert, test1_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_1.word) , !Test2_1.answer);
+}
+
+TEST_F(TestDFSM2_convert, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_2.word) , Test2_2.answer);
+}
+
+TEST_F(TestDFSM2_convert, test2_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_2.word) , !Test2_2.answer);
+}
+
+TEST_F(TestDFSM2_convert, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_3.word) , Test2_3.answer);
+}
+TEST_F(TestDFSM2_convert, test3_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_3.word) , !Test2_3.answer);
+}
+TEST_F(TestDFSM2_convert, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_4.word) , Test2_4.answer);
+}
+TEST_F(TestDFSM2_convert, test4_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_4.word) , !Test2_4.answer);
+}
+TEST_F(TestDFSM2_convert, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_5.word) , Test2_5.answer);
+}
+TEST_F(TestDFSM2_convert, test5_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_5.word) , !Test2_5.answer);
+}
+TEST_F(TestDFSM2_convert, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_6.word) , Test2_6.answer);
+}
+TEST_F(TestDFSM2_convert, test6_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_6.word) , !Test2_6.answer);
+}
+TEST_F(TestDFSM2_convert, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_7.word) , Test2_7.answer);
+}
+TEST_F(TestDFSM2_convert, test7_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_7.word) , !Test2_7.answer);
+}
+TEST_F(TestDFSM2_convert, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_8.word) , Test2_8.answer);
+}
+TEST_F(TestDFSM2_convert, test8_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_8.word) , !Test2_8.answer);
+}
+TEST_F(TestDFSM2_convert, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_9.word) , Test2_9.answer);
+}
+TEST_F(TestDFSM2_convert, test9_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_9.word) , !Test2_9.answer);
+}
+TEST_F(TestDFSM2_convert, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_10.word) , Test2_10.answer);
+}
+TEST_F(TestDFSM2_convert, test10_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test2_10.word) , !Test2_10.answer);
+}
\ No newline at end of file
diff --git a/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm3_convert_test.cpp b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm3_convert_test.cpp
new file mode 100644
index 0000000..75ddcf7
--- /dev/null
+++ b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm3_convert_test.cpp
@@ -0,0 +1,84 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+class TestDFSM3_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    NFSM nfsm("../SM_examples/NFSM_examples/nfsm3.txt");
+    nfsm.FilchEps();
+    dfsm_ = new DFSM(nfsm);
+    compl_dfsm = new DFSM(nfsm);
+    compl_dfsm->Complement();
+  }
+  void TearDown() {
+    delete dfsm_;
+    delete compl_dfsm;
+  }
+  DFSM* compl_dfsm;
+  DFSM* dfsm_;
+};
+
+
+TEST_F(TestDFSM3_convert, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_1.word) , Test3_1.answer);
+}
+TEST_F(TestDFSM3_convert, test1_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_1.word) , !Test3_1.answer);
+}
+
+TEST_F(TestDFSM3_convert, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_2.word) , Test3_2.answer);
+}
+
+TEST_F(TestDFSM3_convert, test2_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_2.word) , !Test3_2.answer);
+}
+
+TEST_F(TestDFSM3_convert, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_3.word) , Test3_3.answer);
+}
+TEST_F(TestDFSM3_convert, test3_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_3.word) , !Test3_3.answer);
+}
+TEST_F(TestDFSM3_convert, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_4.word) , Test3_4.answer);
+}
+TEST_F(TestDFSM3_convert, test4_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_4.word) , !Test3_4.answer);
+}
+TEST_F(TestDFSM3_convert, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_5.word) , Test3_5.answer);
+}
+TEST_F(TestDFSM3_convert, test5_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_5.word) , !Test3_5.answer);
+}
+TEST_F(TestDFSM3_convert, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_6.word) , Test3_6.answer);
+}
+TEST_F(TestDFSM3_convert, test6_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_6.word) , !Test3_6.answer);
+}
+TEST_F(TestDFSM3_convert, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_7.word) , Test3_7.answer);
+}
+TEST_F(TestDFSM3_convert, test7_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_7.word) , !Test3_7.answer);
+}
+TEST_F(TestDFSM3_convert, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_8.word) , Test3_8.answer);
+}
+TEST_F(TestDFSM3_convert, test8_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_8.word) , !Test3_8.answer);
+}
+TEST_F(TestDFSM3_convert, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_9.word) , Test3_9.answer);
+}
+TEST_F(TestDFSM3_convert, test9_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_9.word) , !Test3_9.answer);
+}
+TEST_F(TestDFSM3_convert, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_10.word) , Test3_10.answer);
+}
+TEST_F(TestDFSM3_convert, test10_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test3_10.word) , !Test3_10.answer);
+}
diff --git a/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm4_convert_test.cpp b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm4_convert_test.cpp
new file mode 100644
index 0000000..f8e96d8
--- /dev/null
+++ b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm4_convert_test.cpp
@@ -0,0 +1,84 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+class TestDFSM4_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    NFSM nfsm("../SM_examples/NFSM_examples/nfsm4.txt");
+    nfsm.FilchEps();
+    dfsm_ = new DFSM(nfsm);
+    compl_dfsm = new DFSM(nfsm);
+    compl_dfsm->Complement();
+  }
+  void TearDown() {
+    delete dfsm_;
+    delete compl_dfsm;
+  }
+  DFSM* compl_dfsm;
+  DFSM* dfsm_;
+};
+
+
+TEST_F(TestDFSM4_convert, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_1.word) , Test4_1.answer);
+}
+TEST_F(TestDFSM4_convert, test1_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_1.word) , !Test4_1.answer);
+}
+
+TEST_F(TestDFSM4_convert, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_2.word) , Test4_2.answer);
+}
+
+TEST_F(TestDFSM4_convert, test2_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_2.word) , !Test4_2.answer);
+}
+
+TEST_F(TestDFSM4_convert, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_3.word) , Test4_3.answer);
+}
+TEST_F(TestDFSM4_convert, Test4_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_3.word) , !Test4_3.answer);
+}
+TEST_F(TestDFSM4_convert, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_4.word) , Test4_4.answer);
+}
+TEST_F(TestDFSM4_convert, test4_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_4.word) , !Test4_4.answer);
+}
+TEST_F(TestDFSM4_convert, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_5.word) , Test4_5.answer);
+}
+TEST_F(TestDFSM4_convert, test5_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_5.word) , !Test4_5.answer);
+}
+TEST_F(TestDFSM4_convert, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_6.word) , Test4_6.answer);
+}
+TEST_F(TestDFSM4_convert, test6_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_6.word) , !Test4_6.answer);
+}
+TEST_F(TestDFSM4_convert, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_7.word) , Test4_7.answer);
+}
+TEST_F(TestDFSM4_convert, test7_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_7.word) , !Test4_7.answer);
+}
+TEST_F(TestDFSM4_convert, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_8.word) , Test4_8.answer);
+}
+TEST_F(TestDFSM4_convert, test8_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_8.word) , !Test4_8.answer);
+}
+TEST_F(TestDFSM4_convert, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_9.word) , Test4_9.answer);
+}
+TEST_F(TestDFSM4_convert, test9_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_9.word) , !Test4_9.answer);
+}
+TEST_F(TestDFSM4_convert, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_10.word) , Test4_10.answer);
+}
+TEST_F(TestDFSM4_convert, test10_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test4_10.word) , !Test4_10.answer);
+}
\ No newline at end of file
diff --git a/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm5_convert_test.cpp b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm5_convert_test.cpp
new file mode 100644
index 0000000..6f77c0a
--- /dev/null
+++ b/tests/basic_tests/converts_test/NFSM_to_DFSM_convert_tests/dfsm5_convert_test.cpp
@@ -0,0 +1,84 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+class TestDFSM5_convert : public ::testing::Test {
+ protected:
+  void SetUp() {
+    NFSM nfsm("../SM_examples/NFSM_examples/nfsm5.txt");
+    nfsm.FilchEps();
+    dfsm_ = new DFSM(nfsm);
+    compl_dfsm = new DFSM(nfsm);
+    compl_dfsm->Complement();
+  }
+  void TearDown() {
+    delete dfsm_;
+    delete compl_dfsm;
+  }
+  DFSM* compl_dfsm;
+  DFSM* dfsm_;
+};
+
+
+TEST_F(TestDFSM5_convert, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_1.word) , Test5_1.answer);
+}
+TEST_F(TestDFSM5_convert, test1_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_1.word) , !Test5_1.answer);
+}
+
+TEST_F(TestDFSM5_convert, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_2.word) , Test5_2.answer);
+}
+
+TEST_F(TestDFSM5_convert, test2_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_2.word) , !Test5_2.answer);
+}
+
+TEST_F(TestDFSM5_convert, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_3.word) , Test5_3.answer);
+}
+TEST_F(TestDFSM5_convert, Test5_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_3.word) , !Test5_3.answer);
+}
+TEST_F(TestDFSM5_convert, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_4.word) , Test5_4.answer);
+}
+TEST_F(TestDFSM5_convert, test4_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_4.word) , !Test5_4.answer);
+}
+TEST_F(TestDFSM5_convert, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_5.word) , Test5_5.answer);
+}
+TEST_F(TestDFSM5_convert, test5_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_5.word) , !Test5_5.answer);
+}
+TEST_F(TestDFSM5_convert, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_6.word) , Test5_6.answer);
+}
+TEST_F(TestDFSM5_convert, test6_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_6.word) , !Test5_6.answer);
+}
+TEST_F(TestDFSM5_convert, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_7.word) , Test5_7.answer);
+}
+TEST_F(TestDFSM5_convert, test7_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_7.word) , !Test5_7.answer);
+}
+TEST_F(TestDFSM5_convert, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_8.word) , Test5_8.answer);
+}
+TEST_F(TestDFSM5_convert, test8_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_8.word) , !Test5_8.answer);
+}
+TEST_F(TestDFSM5_convert, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_9.word) , Test5_9.answer);
+}
+TEST_F(TestDFSM5_convert, test9_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_9.word) , !Test5_9.answer);
+}
+TEST_F(TestDFSM5_convert, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_10.word) , Test5_10.answer);
+}
+TEST_F(TestDFSM5_convert, test10_compl) {
+  ASSERT_EQ(compl_dfsm->RecognizeWord(Test5_10.word) , !Test5_10.answer);
+}
\ No newline at end of file
diff --git a/tests/basic_tests/my_tests/test_words.h b/tests/basic_tests/my_tests/test_words.h
new file mode 100644
index 0000000..22c9813
--- /dev/null
+++ b/tests/basic_tests/my_tests/test_words.h
@@ -0,0 +1,68 @@
+#pragma once
+#include <string>
+
+struct Test_pair {
+  std::string word;
+  bool answer;
+  Test_pair(std::string word, bool answer) : word{word}, answer{answer}{};
+};
+
+const Test_pair Test1_1 = {"a", true};
+const Test_pair Test1_2 = {"b", false};
+const Test_pair Test1_3 = {"bb", false};
+const Test_pair Test1_4 = {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true};
+const Test_pair Test1_5 = {"bbbaaabbba", false};
+const Test_pair Test1_6 = {"", false};
+const Test_pair Test1_7 = {"aaab", false};
+const Test_pair Test1_8 = {"ab", false};
+const Test_pair Test1_9 = {"bbbbbb", false};
+const Test_pair Test1_10 = {"aaaaaa", true};
+const int size1 = 3;
+
+const Test_pair Test2_1 = {"a", true};
+const Test_pair Test2_2 = {"b", true};
+const Test_pair Test2_3 = {"ab", false};
+const Test_pair Test2_4 = {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaa", false};
+const Test_pair Test2_5 = {"ba", false};
+const Test_pair Test2_6 = {"", false};
+const Test_pair Test2_7 = {"bb", false};
+const Test_pair Test2_8 = {"bbbba", false};
+const Test_pair Test2_9 = {"aaaab", false};
+const Test_pair Test2_10 = {"aa", false};
+const int size2 = 3;
+
+const Test_pair Test3_1 = {"b", true};
+const Test_pair Test3_2 = {"bb", true};
+const Test_pair Test3_3 = {"abababababbaaaaaaaaaaa", true};
+const Test_pair Test3_4 = {"", false};
+const Test_pair Test3_5 = {"aaba", false};
+const Test_pair Test3_6 = {"aaaaaa", false};
+const Test_pair Test3_7 = {"bbbbbb", true};
+const Test_pair Test3_8 = {"baaaaa", true};
+const Test_pair Test3_9 = {"aaaaaaab", false};
+const Test_pair Test3_10 = {"baaababbababaababab", true};
+const int size3 = 3;
+
+const Test_pair Test4_1 = {"aba", true};
+const Test_pair Test4_2 = {"abba", true};
+const Test_pair Test4_3 = {"abababbababa", true};
+const Test_pair Test4_4 = {"", true};
+const Test_pair Test4_5 = {"a", true};
+const Test_pair Test4_6 = {"ba", true};
+const Test_pair Test4_7 = {"bbbbbbb", false};
+const Test_pair Test4_8 = {"aa", false};
+const Test_pair Test4_9 = {"bb", false};
+const Test_pair Test4_10 = {"bababaa", true};
+const int size4 = 4;
+
+const Test_pair Test5_1 = {"b", true};
+const Test_pair Test5_2 = {"", true};
+const Test_pair Test5_3 = {"aaaaaab", true};
+const Test_pair Test5_4 = {"ababbaba", true};
+const Test_pair Test5_5 = {"ab", true};
+const Test_pair Test5_6 = {"bab", false};
+const Test_pair Test5_7 = {"baa", false};
+const Test_pair Test5_8 = {"bba", false};
+const Test_pair Test5_9 = {"baaba", false};
+const Test_pair Test5_10 = {"babab", false};
+const int size5 = 6;
diff --git a/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test1.cpp b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test1.cpp
new file mode 100644
index 0000000..1009367
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test1.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+
+class TestDFSM1 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    dfsm_ = new DFSM("../SM_examples/DFSM_examples/dfsm1.txt");
+  }
+  void TearDown() {
+    delete dfsm_;
+  }
+  DFSM* dfsm_;
+};
+TEST_F(TestDFSM1, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_1.word) , Test1_1.answer);
+}
+TEST_F(TestDFSM1, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_2.word) , Test1_2.answer);
+}
+TEST_F(TestDFSM1, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_3.word) , Test1_3.answer);
+}
+TEST_F(TestDFSM1, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_4.word) , Test1_4.answer);
+}
+TEST_F(TestDFSM1, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_5.word) , Test1_5.answer);
+}
+TEST_F(TestDFSM1, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_6.word) , Test1_6.answer);
+}
+TEST_F(TestDFSM1, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_7.word) , Test1_7.answer);
+}
+TEST_F(TestDFSM1, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_8.word) , Test1_8.answer);
+}
+TEST_F(TestDFSM1, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_9.word) , Test1_9.answer);
+}
+TEST_F(TestDFSM1, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test1_10.word) , Test1_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test2.cpp b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test2.cpp
new file mode 100644
index 0000000..c264c83
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test2.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+
+class TestDFSM2 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    dfsm_ = new DFSM("../SM_examples/DFSM_examples/dfsm2.txt");
+  }
+  void TearDown() {
+    delete dfsm_;
+  }
+  DFSM* dfsm_;
+};
+TEST_F(TestDFSM2, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_1.word) , Test2_1.answer);
+}
+TEST_F(TestDFSM2, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_2.word) , Test2_2.answer);
+}
+TEST_F(TestDFSM2, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_3.word) , Test2_3.answer);
+}
+TEST_F(TestDFSM2, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_4.word) , Test2_4.answer);
+}
+TEST_F(TestDFSM2, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_5.word) , Test2_5.answer);
+}
+TEST_F(TestDFSM2, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_6.word) , Test2_6.answer);
+}
+TEST_F(TestDFSM2, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_7.word) , Test2_7.answer);
+}
+TEST_F(TestDFSM2, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_8.word) , Test2_8.answer);
+}
+TEST_F(TestDFSM2, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_9.word) , Test2_9.answer);
+}
+TEST_F(TestDFSM2, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_10.word) , Test2_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test3.cpp b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test3.cpp
new file mode 100644
index 0000000..e70a0f6
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test3.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+
+class TestDFSM3 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    dfsm_ = new DFSM("../SM_examples/DFSM_examples/dfsm3.txt");
+  }
+  void TearDown() {
+    delete dfsm_;
+  }
+  DFSM* dfsm_;
+};
+TEST_F(TestDFSM3, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_1.word) , Test3_1.answer);
+}
+TEST_F(TestDFSM3, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_2.word) , Test3_2.answer);
+}
+TEST_F(TestDFSM3, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_3.word) , Test3_3.answer);
+}
+TEST_F(TestDFSM3, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_4.word) , Test3_4.answer);
+}
+TEST_F(TestDFSM3, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_5.word) , Test3_5.answer);
+}
+TEST_F(TestDFSM3, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_6.word) , Test3_6.answer);
+}
+TEST_F(TestDFSM3, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_7.word) , Test3_7.answer);
+}
+TEST_F(TestDFSM3, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_8.word) , Test3_8.answer);
+}
+TEST_F(TestDFSM3, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_9.word) , Test3_9.answer);
+}
+TEST_F(TestDFSM3, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test3_10.word) , Test3_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test4.cpp b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test4.cpp
new file mode 100644
index 0000000..3aa50f7
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test4.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+
+class TestDFSM4 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    dfsm_ = new DFSM("../SM_examples/DFSM_examples/dfsm4.txt");
+  }
+  void TearDown() {
+    delete dfsm_;
+  }
+  DFSM* dfsm_;
+};
+TEST_F(TestDFSM4, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_1.word) , Test4_1.answer);
+}
+TEST_F(TestDFSM4, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_2.word) , Test4_2.answer);
+}
+TEST_F(TestDFSM4, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_3.word) , Test4_3.answer);
+}
+TEST_F(TestDFSM4, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_4.word) , Test4_4.answer);
+}
+TEST_F(TestDFSM4, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_5.word) , Test4_5.answer);
+}
+TEST_F(TestDFSM4, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_6.word) , Test4_6.answer);
+}
+TEST_F(TestDFSM4, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_7.word) , Test4_7.answer);
+}
+TEST_F(TestDFSM4, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_8.word) , Test4_8.answer);
+}
+TEST_F(TestDFSM4, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_9.word) , Test4_9.answer);
+}
+TEST_F(TestDFSM4, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test4_10.word) , Test4_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test5.cpp b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test5.cpp
new file mode 100644
index 0000000..b46dc63
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/DFSM_tests/DFSM_test5.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "DFSM.h"
+#include "test_words.h"
+
+class TestDFSM5 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    dfsm_ = new DFSM("../SM_examples/DFSM_examples/dfsm5.txt");
+  }
+  void TearDown() {
+    delete dfsm_;
+  }
+  DFSM* dfsm_;
+};
+TEST_F(TestDFSM5, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_1.word) , Test5_1.answer);
+}
+TEST_F(TestDFSM5, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_2.word) , Test5_2.answer);
+}
+TEST_F(TestDFSM5, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_3.word) , Test5_3.answer);
+}
+TEST_F(TestDFSM5, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_4.word) , Test5_4.answer);
+}
+TEST_F(TestDFSM5, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_5.word) , Test5_5.answer);
+}
+TEST_F(TestDFSM5, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_6.word) , Test5_6.answer);
+}
+TEST_F(TestDFSM5, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_7.word) , Test5_7.answer);
+}
+TEST_F(TestDFSM5, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_8.word) , Test5_8.answer);
+}
+TEST_F(TestDFSM5, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_9.word) , Test5_9.answer);
+}
+TEST_F(TestDFSM5, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test5_10.word) , Test5_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test1.cpp b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test1.cpp
new file mode 100644
index 0000000..b25fd78
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test1.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+
+class TestMDFSM1 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    mdfsm_ = new MDFSM("../SM_examples/MDFSM_examples/mdfsm1.txt");
+  }
+  void TearDown() {
+    delete mdfsm_;
+  }
+  MDFSM* mdfsm_;
+};
+TEST_F(TestMDFSM1, test1) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_1.word) , Test1_1.answer);
+}
+TEST_F(TestMDFSM1, test2) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_2.word) , Test1_2.answer);
+}
+TEST_F(TestMDFSM1, test3) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_3.word) , Test1_3.answer);
+}
+TEST_F(TestMDFSM1, test4) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_4.word) , Test1_4.answer);
+}
+TEST_F(TestMDFSM1, test5) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_5.word) , Test1_5.answer);
+}
+TEST_F(TestMDFSM1, test6) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_6.word) , Test1_6.answer);
+}
+TEST_F(TestMDFSM1, test7) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_7.word) , Test1_7.answer);
+}
+TEST_F(TestMDFSM1, test8) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_8.word) , Test1_8.answer);
+}
+TEST_F(TestMDFSM1, test9) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_9.word) , Test1_9.answer);
+}
+TEST_F(TestMDFSM1, test10) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test1_10.word) , Test1_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test2.cpp b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test2.cpp
new file mode 100644
index 0000000..069823a
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test2.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+
+class TestMDFSM2 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    dfsm_ = new DFSM("../SM_examples/MDFSM_examples/mdfsm2.txt");
+  }
+  void TearDown() {
+    delete dfsm_;
+  }
+  DFSM* dfsm_;
+};
+TEST_F(TestMDFSM2, test1) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_1.word) , Test2_1.answer);
+}
+TEST_F(TestMDFSM2, test2) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_2.word) , Test2_2.answer);
+}
+TEST_F(TestMDFSM2, test3) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_3.word) , Test2_3.answer);
+}
+TEST_F(TestMDFSM2, test4) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_4.word) , Test2_4.answer);
+}
+TEST_F(TestMDFSM2, test5) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_5.word) , Test2_5.answer);
+}
+TEST_F(TestMDFSM2, test6) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_6.word) , Test2_6.answer);
+}
+TEST_F(TestMDFSM2, test7) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_7.word) , Test2_7.answer);
+}
+TEST_F(TestMDFSM2, test8) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_8.word) , Test2_8.answer);
+}
+TEST_F(TestMDFSM2, test9) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_9.word) , Test2_9.answer);
+}
+TEST_F(TestMDFSM2, test10) {
+  ASSERT_EQ(dfsm_->RecognizeWord(Test2_10.word) , Test2_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test3.cpp b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test3.cpp
new file mode 100644
index 0000000..cfabd16
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test3.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+
+class TestMDFSM3 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    MDFSM_ = new MDFSM("../SM_examples/MDFSM_examples/mdfsm3.txt");
+  }
+  void TearDown() {
+    delete MDFSM_;
+  }
+  MDFSM* MDFSM_;
+};
+TEST_F(TestMDFSM3, test1) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_1.word) , Test3_1.answer);
+}
+TEST_F(TestMDFSM3, test2) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_2.word) , Test3_2.answer);
+}
+TEST_F(TestMDFSM3, test3) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_3.word) , Test3_3.answer);
+}
+TEST_F(TestMDFSM3, test4) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_4.word) , Test3_4.answer);
+}
+TEST_F(TestMDFSM3, test5) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_5.word) , Test3_5.answer);
+}
+TEST_F(TestMDFSM3, test6) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_6.word) , Test3_6.answer);
+}
+TEST_F(TestMDFSM3, test7) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_7.word) , Test3_7.answer);
+}
+TEST_F(TestMDFSM3, test8) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_8.word) , Test3_8.answer);
+}
+TEST_F(TestMDFSM3, test9) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_9.word) , Test3_9.answer);
+}
+TEST_F(TestMDFSM3, test10) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test3_10.word) , Test3_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test4.cpp b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test4.cpp
new file mode 100644
index 0000000..58536d0
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test4.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+
+class TestMDFSM4 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    mdfsm_ = new MDFSM("../SM_examples/MDFSM_examples/mdfsm4.txt");
+  }
+  void TearDown() {
+    delete mdfsm_;
+  }
+  MDFSM* mdfsm_;
+};
+TEST_F(TestMDFSM4, test1) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_1.word) , Test4_1.answer);
+}
+TEST_F(TestMDFSM4, test2) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_2.word) , Test4_2.answer);
+}
+TEST_F(TestMDFSM4, test3) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_3.word) , Test4_3.answer);
+}
+TEST_F(TestMDFSM4, test4) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_4.word) , Test4_4.answer);
+}
+TEST_F(TestMDFSM4, test5) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_5.word) , Test4_5.answer);
+}
+TEST_F(TestMDFSM4, test6) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_6.word) , Test4_6.answer);
+}
+TEST_F(TestMDFSM4, test7) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_7.word) , Test4_7.answer);
+}
+TEST_F(TestMDFSM4, test8) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_8.word) , Test4_8.answer);
+}
+TEST_F(TestMDFSM4, test9) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_9.word) , Test4_9.answer);
+}
+TEST_F(TestMDFSM4, test10) {
+  ASSERT_EQ(mdfsm_->RecognizeWord(Test4_10.word) , Test4_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test5.cpp b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test5.cpp
new file mode 100644
index 0000000..a04c535
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/MDFSM_tests/MDFSM_test5.cpp
@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "MDFSM.h"
+#include "test_words.h"
+
+class TestMDFSM5 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    MDFSM_ = new MDFSM("../SM_examples/MDFSM_examples/mdfsm5.txt");
+  }
+  void TearDown() {
+    delete MDFSM_;
+  }
+  MDFSM* MDFSM_;
+};
+TEST_F(TestMDFSM5, test1) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_1.word) , Test5_1.answer);
+}
+TEST_F(TestMDFSM5, test2) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_2.word) , Test5_2.answer);
+}
+TEST_F(TestMDFSM5, test3) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_3.word) , Test5_3.answer);
+}
+TEST_F(TestMDFSM5, test4) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_4.word) , Test5_4.answer);
+}
+TEST_F(TestMDFSM5, test5) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_5.word) , Test5_5.answer);
+}
+TEST_F(TestMDFSM5, test6) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_6.word) , Test5_6.answer);
+}
+TEST_F(TestMDFSM5, test7) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_7.word) , Test5_7.answer);
+}
+TEST_F(TestMDFSM5, test8) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_8.word) , Test5_8.answer);
+}
+TEST_F(TestMDFSM5, test9) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_9.word) , Test5_9.answer);
+}
+TEST_F(TestMDFSM5, test10) {
+  ASSERT_EQ(MDFSM_->RecognizeWord(Test5_10.word) , Test5_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm1_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm1_test.cpp
new file mode 100644
index 0000000..a086f4b
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm1_test.cpp
@@ -0,0 +1,48 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+#include <iostream>
+
+class TestNoEpsNFSM1 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm1.txt");
+    nfsm_->FilchEps();
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+
+
+  NFSM* nfsm_;
+};
+TEST_F(TestNoEpsNFSM1, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_1.word) , Test1_1.answer);
+}
+TEST_F(TestNoEpsNFSM1, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_2.word) , Test1_2.answer);
+}
+TEST_F(TestNoEpsNFSM1, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_3.word) , Test1_3.answer);
+}
+TEST_F(TestNoEpsNFSM1, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_4.word) , Test1_4.answer);
+}
+TEST_F(TestNoEpsNFSM1, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_5.word) , Test1_5.answer);
+}
+TEST_F(TestNoEpsNFSM1, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_6.word) , Test1_6.answer);
+}
+TEST_F(TestNoEpsNFSM1, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_7.word) , Test1_7.answer);
+}
+TEST_F(TestNoEpsNFSM1, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_8.word) , Test1_8.answer);
+}
+TEST_F(TestNoEpsNFSM1, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_9.word) , Test1_9.answer);
+}
+TEST_F(TestNoEpsNFSM1, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_10.word) , Test1_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm2_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm2_test.cpp
new file mode 100644
index 0000000..ff3b1c4
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm2_test.cpp
@@ -0,0 +1,47 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+
+class TestNoEpsNFSM2 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm2.txt");
+    nfsm_->FilchEps();
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+
+
+  NFSM* nfsm_;
+};
+TEST_F(TestNoEpsNFSM2, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_1.word) , Test2_1.answer);
+}
+TEST_F(TestNoEpsNFSM2, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_2.word) , Test2_2.answer);
+}
+TEST_F(TestNoEpsNFSM2, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_3.word) , Test2_3.answer);
+}
+TEST_F(TestNoEpsNFSM2, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_4.word) , Test2_4.answer);
+}
+TEST_F(TestNoEpsNFSM2, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_5.word) , Test2_5.answer);
+}
+TEST_F(TestNoEpsNFSM2, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_6.word) , Test2_6.answer);
+}
+TEST_F(TestNoEpsNFSM2, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_7.word) , Test2_7.answer);
+}
+TEST_F(TestNoEpsNFSM2, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_8.word) , Test2_8.answer);
+}
+TEST_F(TestNoEpsNFSM2, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_9.word) , Test2_9.answer);
+}
+TEST_F(TestNoEpsNFSM2, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_10.word) , Test2_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm3_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm3_test.cpp
new file mode 100644
index 0000000..285f44c
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm3_test.cpp
@@ -0,0 +1,47 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+
+class TestNoEpsNFSM3 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm3.txt");
+    nfsm_->FilchEps();
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+
+
+  NFSM* nfsm_;
+};
+TEST_F(TestNoEpsNFSM3, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_1.word) , Test3_1.answer);
+}
+TEST_F(TestNoEpsNFSM3, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_2.word) , Test3_2.answer);
+}
+TEST_F(TestNoEpsNFSM3, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_3.word) , Test3_3.answer);
+}
+TEST_F(TestNoEpsNFSM3, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_4.word) , Test3_4.answer);
+}
+TEST_F(TestNoEpsNFSM3, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_5.word) , Test3_5.answer);
+}
+TEST_F(TestNoEpsNFSM3, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_6.word) , Test3_6.answer);
+}
+TEST_F(TestNoEpsNFSM3, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_7.word) , Test3_7.answer);
+}
+TEST_F(TestNoEpsNFSM3, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_8.word) , Test3_8.answer);
+}
+TEST_F(TestNoEpsNFSM3, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_9.word) , Test3_9.answer);
+}
+TEST_F(TestNoEpsNFSM3, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_10.word) , Test3_10.answer);
+}
\ No newline at end of file
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm4_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm4_test.cpp
new file mode 100644
index 0000000..f988785
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm4_test.cpp
@@ -0,0 +1,47 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+
+class TestNoEpsNFSM4 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm4.txt");
+    nfsm_->FilchEps();
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+
+
+  NFSM* nfsm_;
+};
+TEST_F(TestNoEpsNFSM4, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_1.word) , Test4_1.answer);
+}
+TEST_F(TestNoEpsNFSM4, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_2.word) , Test4_2.answer);
+}
+TEST_F(TestNoEpsNFSM4, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_3.word) , Test4_3.answer);
+}
+TEST_F(TestNoEpsNFSM4, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_4.word) , Test4_4.answer);
+}
+TEST_F(TestNoEpsNFSM4, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_5.word) , Test4_5.answer);
+}
+TEST_F(TestNoEpsNFSM4, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_6.word) , Test4_6.answer);
+}
+TEST_F(TestNoEpsNFSM4, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_7.word) , Test4_7.answer);
+}
+TEST_F(TestNoEpsNFSM4, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_8.word) , Test4_8.answer);
+}
+TEST_F(TestNoEpsNFSM4, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_9.word) , Test4_9.answer);
+}
+TEST_F(TestNoEpsNFSM4, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_10.word) , Test4_10.answer);
+}
\ No newline at end of file
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm5_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm5_test.cpp
new file mode 100644
index 0000000..6b73e6d
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/AnyNFSM_tests/nfsm5_test.cpp
@@ -0,0 +1,46 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+
+class TestNoEpsNFSM5 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm5.txt");
+    nfsm_->FilchEps();
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+  NFSM* nfsm_;
+};
+
+TEST_F(TestNoEpsNFSM5, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_1.word) , Test5_1.answer);
+}
+TEST_F(TestNoEpsNFSM5, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_2.word) , Test5_2.answer);
+}
+TEST_F(TestNoEpsNFSM5, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_3.word) , Test5_3.answer);
+}
+TEST_F(TestNoEpsNFSM5, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_4.word) , Test5_4.answer);
+}
+TEST_F(TestNoEpsNFSM5, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_5.word) , Test5_5.answer);
+}
+TEST_F(TestNoEpsNFSM5, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_6.word) , Test5_6.answer);
+}
+TEST_F(TestNoEpsNFSM5, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_7.word) , Test5_7.answer);
+}
+TEST_F(TestNoEpsNFSM5, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_8.word) , Test5_8.answer);
+}
+TEST_F(TestNoEpsNFSM5, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_9.word) , Test5_9.answer);
+}
+TEST_F(TestNoEpsNFSM5, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_10.word) , Test5_10.answer);
+}
\ No newline at end of file
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm1_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm1_test.cpp
new file mode 100644
index 0000000..14e4531
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm1_test.cpp
@@ -0,0 +1,47 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+#include <iostream>
+
+class TestEpsExistNFSM1 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm1.txt");
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+
+
+  NFSM* nfsm_;
+};
+TEST_F(TestEpsExistNFSM1, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_1.word) , Test1_1.answer);
+}
+TEST_F(TestEpsExistNFSM1, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_2.word) , Test1_2.answer);
+}
+TEST_F(TestEpsExistNFSM1, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_3.word) , Test1_3.answer);
+}
+TEST_F(TestEpsExistNFSM1, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_4.word) , Test1_4.answer);
+}
+TEST_F(TestEpsExistNFSM1, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_5.word) , Test1_5.answer);
+}
+TEST_F(TestEpsExistNFSM1, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_6.word) , Test1_6.answer);
+}
+TEST_F(TestEpsExistNFSM1, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_7.word) , Test1_7.answer);
+}
+TEST_F(TestEpsExistNFSM1, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_8.word) , Test1_8.answer);
+}
+TEST_F(TestEpsExistNFSM1, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_9.word) , Test1_9.answer);
+}
+TEST_F(TestEpsExistNFSM1, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test1_10.word) , Test1_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm2_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm2_test.cpp
new file mode 100644
index 0000000..f7714d3
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm2_test.cpp
@@ -0,0 +1,46 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+
+class TestEpsExistNFSM2 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm2.txt");
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+
+
+  NFSM* nfsm_;
+};
+TEST_F(TestEpsExistNFSM2, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_1.word) , Test2_1.answer);
+}
+TEST_F(TestEpsExistNFSM2, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_2.word) , Test2_2.answer);
+}
+TEST_F(TestEpsExistNFSM2, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_3.word) , Test2_3.answer);
+}
+TEST_F(TestEpsExistNFSM2, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_4.word) , Test2_4.answer);
+}
+TEST_F(TestEpsExistNFSM2, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_5.word) , Test2_5.answer);
+}
+TEST_F(TestEpsExistNFSM2, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_6.word) , Test2_6.answer);
+}
+TEST_F(TestEpsExistNFSM2, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_7.word) , Test2_7.answer);
+}
+TEST_F(TestEpsExistNFSM2, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_8.word) , Test2_8.answer);
+}
+TEST_F(TestEpsExistNFSM2, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_9.word) , Test2_9.answer);
+}
+TEST_F(TestEpsExistNFSM2, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test2_10.word) , Test2_10.answer);
+}
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm3_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm3_test.cpp
new file mode 100644
index 0000000..f0e0d52
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm3_test.cpp
@@ -0,0 +1,46 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+
+class TestEpsExistNFSM3 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm3.txt");
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+
+
+  NFSM* nfsm_;
+};
+TEST_F(TestEpsExistNFSM3, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_1.word) , Test3_1.answer);
+}
+TEST_F(TestEpsExistNFSM3, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_2.word) , Test3_2.answer);
+}
+TEST_F(TestEpsExistNFSM3, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_3.word) , Test3_3.answer);
+}
+TEST_F(TestEpsExistNFSM3, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_4.word) , Test3_4.answer);
+}
+TEST_F(TestEpsExistNFSM3, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_5.word) , Test3_5.answer);
+}
+TEST_F(TestEpsExistNFSM3, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_6.word) , Test3_6.answer);
+}
+TEST_F(TestEpsExistNFSM3, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_7.word) , Test3_7.answer);
+}
+TEST_F(TestEpsExistNFSM3, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_8.word) , Test3_8.answer);
+}
+TEST_F(TestEpsExistNFSM3, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_9.word) , Test3_9.answer);
+}
+TEST_F(TestEpsExistNFSM3, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test3_10.word) , Test3_10.answer);
+}
\ No newline at end of file
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm4_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm4_test.cpp
new file mode 100644
index 0000000..30153b6
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm4_test.cpp
@@ -0,0 +1,46 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+
+class TestEpsExistNFSM4 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm4.txt");
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+
+
+  NFSM* nfsm_;
+};
+TEST_F(TestEpsExistNFSM4, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_1.word) , Test4_1.answer);
+}
+TEST_F(TestEpsExistNFSM4, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_2.word) , Test4_2.answer);
+}
+TEST_F(TestEpsExistNFSM4, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_3.word) , Test4_3.answer);
+}
+TEST_F(TestEpsExistNFSM4, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_4.word) , Test4_4.answer);
+}
+TEST_F(TestEpsExistNFSM4, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_5.word) , Test4_5.answer);
+}
+TEST_F(TestEpsExistNFSM4, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_6.word) , Test4_6.answer);
+}
+TEST_F(TestEpsExistNFSM4, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_7.word) , Test4_7.answer);
+}
+TEST_F(TestEpsExistNFSM4, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_8.word) , Test4_8.answer);
+}
+TEST_F(TestEpsExistNFSM4, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_9.word) , Test4_9.answer);
+}
+TEST_F(TestEpsExistNFSM4, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test4_10.word) , Test4_10.answer);
+}
\ No newline at end of file
diff --git a/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm5_test.cpp b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm5_test.cpp
new file mode 100644
index 0000000..3c722cd
--- /dev/null
+++ b/tests/basic_tests/word_rec_tests/NFSM_tests/NoEpsNFSM_test/NoEpsnfsm5_test.cpp
@@ -0,0 +1,45 @@
+#include "gtest/gtest.h"
+#include "NFSM.h"
+#include "test_words.h"
+
+class TestEpsExistNFSM5 : public ::testing::Test {
+ protected:
+  void SetUp() {
+    nfsm_ = new NFSM("../SM_examples/NFSM_examples/nfsm5.txt");
+  }
+  void TearDown() {
+    delete nfsm_;
+  }
+  NFSM* nfsm_;
+};
+
+TEST_F(TestEpsExistNFSM5, test1) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_1.word) , Test5_1.answer);
+}
+TEST_F(TestEpsExistNFSM5, test2) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_2.word) , Test5_2.answer);
+}
+TEST_F(TestEpsExistNFSM5, test3) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_3.word) , Test5_3.answer);
+}
+TEST_F(TestEpsExistNFSM5, test4) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_4.word) , Test5_4.answer);
+}
+TEST_F(TestEpsExistNFSM5, test5) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_5.word) , Test5_5.answer);
+}
+TEST_F(TestEpsExistNFSM5, test6) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_6.word) , Test5_6.answer);
+}
+TEST_F(TestEpsExistNFSM5, test7) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_7.word) , Test5_7.answer);
+}
+TEST_F(TestEpsExistNFSM5, test8) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_8.word) , Test5_8.answer);
+}
+TEST_F(TestEpsExistNFSM5, test9) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_9.word) , Test5_9.answer);
+}
+TEST_F(TestEpsExistNFSM5, test10) {
+  ASSERT_EQ(nfsm_->RecognizeWord(Test5_10.word) , Test5_10.answer);
+}
\ No newline at end of file
diff --git a/tests/img/DFSM1.jpg b/tests/img/DFSM1.jpg
new file mode 100644
index 0000000..6824b97
Binary files /dev/null and b/tests/img/DFSM1.jpg differ
diff --git a/tests/img/MDFSM1.jpg b/tests/img/MDFSM1.jpg
new file mode 100644
index 0000000..10b3ac7
Binary files /dev/null and b/tests/img/MDFSM1.jpg differ
diff --git a/tests/img/NFSM1.jpg b/tests/img/NFSM1.jpg
new file mode 100644
index 0000000..9df937a
Binary files /dev/null and b/tests/img/NFSM1.jpg differ
diff --git a/tests/lib/googletest b/tests/lib/googletest
new file mode 160000
index 0000000..9fbb657
--- /dev/null
+++ b/tests/lib/googletest
@@ -0,0 +1 @@
+Subproject commit 9fbb6575035e3ac97ad9547d042c026a1296c705