diff --git a/CMakeLists.txt b/CMakeLists.txt
index fb5abf3a..3a6691b0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,7 +14,9 @@ include(cmake/function.cmake)         # подхватываем функции,
 								      # и для создания исполняемого проекта в отдельные функции
 
 add_subdirectory(lib_easy_example)    # подключаем дополнительный CMakeLists.txt из подкаталога с именем lib_easy_example
-
+add_subdirectory(lib_list)
+add_subdirectory(lib_doublyList)
+add_subdirectory(lib_queue)
 add_subdirectory(main)                # подключаем дополнительный CMakeLists.txt из подкаталога с именем main
 
 option(BTEST "build test?" ON)        # указываем подключаем ли google-тесты (ON или YES) или нет (OFF или NO)
diff --git a/lib_doublyList/CMakeLists.txt b/lib_doublyList/CMakeLists.txt
new file mode 100644
index 00000000..3356e664
--- /dev/null
+++ b/lib_doublyList/CMakeLists.txt
@@ -0,0 +1,2 @@
+create_project_lib(DoublyList)
+add_depend(DoublyList List ../lib_list)
\ No newline at end of file
diff --git a/lib_doublyList/doublyList.cpp b/lib_doublyList/doublyList.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/lib_doublyList/doublyList.h b/lib_doublyList/doublyList.h
new file mode 100644
index 00000000..a6f419bd
--- /dev/null
+++ b/lib_doublyList/doublyList.h
@@ -0,0 +1,510 @@
+#pragma once
+
+template <class T>
+struct Node {
+    T value;
+    Node<T>* next;
+    Node<T>* prev;
+
+    Node(T value_, Node<T>* prev_ = nullptr, Node<T>* next_ = nullptr)
+        : value(value_), prev(prev_), next(next_) {
+    }
+};
+
+template <class T>
+class List {
+    Node<T>* _head;
+    Node<T>* _tail;
+    int _count;
+
+public:
+
+    class Iterator {
+        Node<T>* current;
+
+    public:
+        Iterator() : current(nullptr) {}
+        Iterator(Node<T>* node) : current(node) {}
+
+        Iterator& operator=(const Iterator& other) {
+            current = other.current;
+            return *this;
+        }
+
+        T& operator*() {
+            if (current == nullptr) {
+                throw std::logic_error("Dereferencing nullptr iterator");
+            }
+            return current->value;
+        }
+
+        const T& operator*() const {
+            if (current == nullptr) {
+                throw std::logic_error("Dereferencing nullptr iterator");
+            }
+            return current->value;
+        }
+
+        T* operator->() {
+            if (current == nullptr) {
+                throw std::logic_error("Arrow operator on nullptr iterator");
+            }
+            return &(current->value);
+        }
+
+        const T* operator->() const {
+            if (current == nullptr) {
+                throw std::logic_error("Arrow operator on nullptr iterator");
+            }
+            return &(current->value);
+        }
+
+        Iterator& operator++() {
+            if (current != nullptr) {
+                current = current->next;
+            }
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            Iterator temp = *this;
+            ++(*this);
+            return temp;
+        }
+
+        Iterator& operator--() {
+            if (current != nullptr) {
+                current = current->prev;
+            }
+            return *this;
+        }
+
+        Iterator operator--(int) {
+            Iterator temp = *this;
+            --(*this);
+            return temp;
+        }
+
+        bool operator==(const Iterator& other) const {
+            return current == other.current;
+        }
+
+        bool operator!=(const Iterator& other) const {
+            return current != other.current;
+        }
+
+        Node<T>* get_node() const { return current; }
+    };
+
+    class ReverseIterator {
+        Node<T>* current;
+
+    public:
+        ReverseIterator() : current(nullptr) {}
+        ReverseIterator(Node<T>* node) : current(node) {}
+
+        ReverseIterator& operator=(const ReverseIterator& other) {
+            current = other.current;
+            return *this;
+        }
+
+        T& operator*() {
+            if (current == nullptr) {
+                throw std::logic_error("Dereferencing nullptr iterator");
+            }
+            return current->value;
+        }
+
+        const T& operator*() const {
+            if (current == nullptr) {
+                throw std::logic_error("Dereferencing nullptr iterator");
+            }
+            return current->value;
+        }
+
+        T* operator->() {
+            if (current == nullptr) {
+                throw std::logic_error("Arrow operator on nullptr iterator");
+            }
+            return &(current->value);
+        }
+
+        const T* operator->() const {
+            if (current == nullptr) {
+                throw std::logic_error("Arrow operator on nullptr iterator");
+            }
+            return &(current->value);
+        }
+
+        ReverseIterator& operator++() {
+            if (current != nullptr) {
+                current = current->prev;
+            }
+            return *this;
+        }
+
+        ReverseIterator operator++(int) {
+            ReverseIterator temp = *this;
+            ++(*this);
+            return temp;
+        }
+
+        ReverseIterator& operator--() {
+            if (current != nullptr) {
+                current = current->next;
+            }
+            return *this;
+        }
+
+        ReverseIterator operator--(int) {
+            ReverseIterator temp = *this;
+            --(*this);
+            return temp;
+        }
+
+        bool operator==(const ReverseIterator& other) const {
+            return current == other.current;
+        }
+
+        bool operator!=(const ReverseIterator& other) const {
+            return current != other.current;
+        }
+
+        Node<T>* get_node() const { return current; }
+    };
+
+    List() : _head(nullptr), _tail(nullptr), _count(0) {}
+
+    List(const List& other) : _head(nullptr), _tail(nullptr), _count(0) {
+        Node<T>* current = other._head;
+        while (current != nullptr) {
+            push_back(current->value);
+            current = current->next;
+        }
+    }
+
+    ~List() {
+        clear();
+    }
+
+    List& operator=(const List& other) {
+        if (this != &other) {
+            clear();
+            Node<T>* current = other._head;
+            while (current != nullptr) {
+                push_back(current->value);
+                current = current->next;
+            }
+        }
+        return *this;
+    }
+
+    Iterator begin() { return Iterator(_head); }
+    Iterator end() { return Iterator(nullptr); }
+
+    ReverseIterator rbegin() { return ReverseIterator(_tail); }
+    ReverseIterator rend() { return ReverseIterator(nullptr); }
+
+    void push_front(const T& val) {
+        Node<T>* new_node = new Node<T>(val, nullptr, _head);
+
+        if (_head != nullptr) {
+            _head->prev = new_node;
+        }
+
+        _head = new_node;
+
+        if (_tail == nullptr) {
+            _tail = new_node;
+        }
+
+        _count++;
+    }
+
+    void push_back(const T& val) {
+        Node<T>* new_node = new Node<T>(val, _tail, nullptr);
+
+        if (_tail != nullptr) {
+            _tail->next = new_node;
+        }
+
+        _tail = new_node;
+
+        if (_head == nullptr) {
+            _head = new_node;
+        }
+
+        _count++;
+    }
+
+    void insert(const Iterator& position, const T& val) {
+        if (position == begin()) {
+            push_front(val);
+            return;
+        }
+
+        if (position == end()) {
+            push_back(val);
+            return;
+        }
+
+        Node<T>* current_node = position.get_node();
+        Node<T>* prev_node = current_node->prev;
+
+        Node<T>* new_node = new Node<T>(val, prev_node, current_node);
+
+        prev_node->next = new_node;
+        current_node->prev = new_node;
+
+        _count++;
+    }
+
+    void pop_front() {
+        if (is_empty()) throw "List is empty";
+
+        Node<T>* temp = _head;
+        _head = _head->next;
+
+        if (_head != nullptr) {
+            _head->prev = nullptr;
+        }
+        else {
+            _tail = nullptr;
+        }
+
+        delete temp;
+        _count--;
+    }
+
+    void pop_back() {
+        if (is_empty()) throw "List is empty";
+
+        Node<T>* temp = _tail;
+        _tail = _tail->prev;
+
+        if (_tail != nullptr) {
+            _tail->next = nullptr;
+        }
+        else {
+            _head = nullptr;
+        }
+
+        delete temp;
+        _count--;
+    }
+
+    void erase(const Iterator& position) {
+        if (position == end()) return;
+
+        Node<T>* node_to_delete = position.get_node();
+
+        if (node_to_delete == _head) {
+            pop_front();
+            return;
+        }
+
+        if (node_to_delete == _tail) {
+            pop_back();
+            return;
+        }
+
+        Node<T>* prev_node = node_to_delete->prev;
+        Node<T>* next_node = node_to_delete->next;
+
+        prev_node->next = next_node;
+        next_node->prev = prev_node;
+
+        delete node_to_delete;
+        _count--;
+    }
+
+    T& front() {
+        if (is_empty()) throw "List is empty";
+        return _head->value;
+    }
+
+    const T& front() const {
+        if (is_empty()) throw "List is empty";
+        return _head->value;
+    }
+
+    T& back() {
+        if (is_empty()) throw "List is empty";
+        return _tail->value;
+    }
+
+    const T& back() const {
+        if (is_empty()) throw "List is empty";
+        return _tail->value;
+    }
+
+    bool is_empty() const {
+        return _head == nullptr;
+    }
+
+    int size() const {
+        return _count;
+    }
+
+    void clear() {
+        while (!is_empty()) {
+            pop_front();
+        }
+    }
+
+    Iterator find(const T& val) {
+        Node<T>* current = _head;
+        while (current != nullptr) {
+            if (current->value == val) {
+                return Iterator(current);
+            }
+            current = current->next;
+        }
+        return end();
+    }
+
+
+
+
+
+    bool has_cycle_floyd() const {
+        if (_head == nullptr || _head->next == nullptr) {
+            return false;
+        }
+
+        Node<T>* slow = _head;
+        Node<T>* fast = _head;
+
+        while (fast != nullptr && fast->next != nullptr) {
+            slow = slow->next;
+            fast = fast->next->next;
+
+            if (slow == fast) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool has_cycle_reverse() {
+        if (_head == nullptr || _head->next == nullptr) {
+            return false;
+        }
+
+        Node<T>* original_head = _head;
+        Node<T>* original_tail = _tail;
+
+        Node<T>* prev = nullptr;
+        Node<T>* current = _head;
+        Node<T>* next = nullptr;
+
+        while (current != nullptr) {
+            next = current->next;
+            current->next = prev;
+            if (prev != nullptr) {
+                prev->prev = current;
+            }
+            prev = current;
+            current = next;
+        }
+
+        _head = prev;
+        if (_head != nullptr) {
+            _head->prev = nullptr;
+        }
+
+        current = _head;
+        Node<T>* next_for_restore = nullptr;
+        prev = nullptr;
+
+        while (current != nullptr) {
+            next_for_restore = current->next;
+            current->next = prev;
+            if (prev != nullptr) {
+                prev->prev = current;
+            }
+            prev = current;
+            current = next_for_restore;
+        }
+
+        _head = prev;
+        if (_head != nullptr) {
+            _head->prev = nullptr;
+        }
+
+        if (_head != nullptr) {
+            Node<T>* temp = _head;
+            while (temp->next != nullptr) {
+                temp = temp->next;
+            }
+            _tail = temp;
+        }
+        else {
+            _tail = nullptr;
+        }
+
+        bool has_cycle = (_head != original_head);
+
+        if (has_cycle) {
+            Node<T>* node = _head;
+            while (node != nullptr) {
+                node->next = nullptr;
+                node->prev = nullptr;
+                node = node->next;
+            }
+
+            _head = original_head;
+            _tail = original_tail;
+
+            if (_head != nullptr && _tail != nullptr) {
+                Node<T>* current_node = _head;
+                while (current_node->next != nullptr) {
+                    current_node = current_node->next;
+                }
+                if (_tail->next != nullptr) {
+                    _tail->next = _head;
+                    _head->prev = _tail;
+                }
+            }
+        }
+
+        return has_cycle;
+    }
+
+
+    Iterator find_cycle_start() {
+        if (_head == nullptr || _head->next == nullptr) {
+            return end();
+        }
+
+        Node<T>* slow = _head;
+        Node<T>* fast = _head;
+        bool has_cycle = false;
+
+        while (fast != nullptr && fast->next != nullptr) {
+            slow = slow->next;
+            fast = fast->next->next;
+
+            if (slow == fast) {
+                has_cycle = true;
+                break;
+            }
+        }
+
+        if (!has_cycle) {
+            return end();
+        }
+
+        slow = _head;
+        while (slow != fast) {
+            slow = slow->next;
+            fast = fast->next;
+        }
+
+        return Iterator(slow);
+    }
+
+
+
+};
\ No newline at end of file
diff --git a/lib_list/CMakeLists.txt b/lib_list/CMakeLists.txt
new file mode 100644
index 00000000..148b539a
--- /dev/null
+++ b/lib_list/CMakeLists.txt
@@ -0,0 +1 @@
+create_project_lib(List)
\ No newline at end of file
diff --git a/lib_list/List.cpp b/lib_list/List.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/lib_list/List.h b/lib_list/List.h
new file mode 100644
index 00000000..ff1ea56a
--- /dev/null
+++ b/lib_list/List.h
@@ -0,0 +1,279 @@
+#pragma once
+
+
+template <class T>
+struct Node {
+
+	T value;
+	Node<T>* next;
+	Node(T value_, Node<T>* next_ = nullptr);
+};
+
+template <class T>
+Node<T>::Node(T value_, Node<T>* next_) : value(value_), next(next_) {}
+
+template <class T>
+class List {
+
+	Node<T>* _head;
+	Node<T>* _tail;
+	int _count;
+
+public:
+
+
+	class Iterator {
+
+
+		Node<T>* current;
+
+	public:
+
+		Iterator() : current(nullptr) {}
+		Iterator(Node<T>* node) : current(node) {}
+
+		Iterator& operator=(const Iterator& other) {
+			current = other.current;
+			return *this;
+		}
+
+		T& operator*() {
+			return current->value;
+		}
+
+		Iterator& operator++() {
+			if (current != nullptr) {
+				current = current->next;
+			}
+			return *this;
+		}
+
+		Iterator operator++(int) {
+			Iterator temp = *this;
+			++(*this);
+			return temp;
+		}
+
+		bool operator==(const Iterator& other) const {
+			return current == other.current;
+		}
+
+		bool operator!=(const Iterator& other) const {
+			return current != other.current;
+		}
+
+	};
+
+
+
+	List() : _head(nullptr), _tail(nullptr), _count(0) {}
+	List(const List& other) {
+		_head = nullptr;
+		_tail = nullptr;
+		_count = 0;
+
+		Node<T>* current = other._head;
+		while (current != nullptr) {
+			push_back(current->value);
+			current = current->next;
+		}
+	}
+
+	~List() {
+		while (!is_empty()) {
+			pop_front();
+		}
+	}
+
+	List& operator=(const List& other) {
+		if (this != &other) {
+			while (!is_empty()) {
+				pop_front();
+			}
+
+			Node<T>* current = other._head;
+			while (current != nullptr) {
+				push_back(current->value);
+				current = current->next;
+			}
+		}
+		return *this;
+	}
+
+	void push_front(const T& val);
+	void push_back(const T& val);
+	void insert(int pos, const T& val);
+	void insert(Node<T>* node, const T& val);
+
+	void pop_front();
+	void pop_back();
+	T front() const;
+	T back() const;
+	void erase(Node<T>* node);
+
+	bool is_empty() const;
+	Node<T>* find(const T& val);
+	int size() const { return _count; }
+
+};
+
+template <class T>
+void List<T>::push_front(const T& val) {
+	Node<T>* node = new Node<T>(val, _head);
+
+	if (is_empty()) _tail = node;
+
+	_head = node;
+	_count++;
+}
+
+template <class T>
+bool List<T>::is_empty() const {
+	return _head == nullptr;
+}
+
+template <class T>
+void List<T>::push_back(const T& val) {
+
+	Node<T>* node = new Node<T>(val);
+	if (is_empty()) {
+		_head = node;
+		_tail = node;
+		_count++;
+		return;
+	}
+
+	_tail->next = node;
+	_tail = node;
+	++_count;
+
+
+	//      nullptr
+	//  (val) ---> Null
+	//  node
+
+}
+
+template <class T>
+void List<T>::insert(Node<T>* node, const T& val) {
+	if (node == nullptr) throw ("Error");
+	Node<T>* new_node = new Node<T>(val, node->next);
+	node->next = new_node;
+	if (_tail == node) {
+		_tail = new_node;
+	}
+	_count++;
+}
+
+template <class T>
+void List<T>::insert(int pos, const T& val) {
+	if (pos < 0 || pos >= _count) throw ("Error");
+
+	if (pos == 0) {
+		push_front(val);
+	}
+	else if (pos == _count - 1) {
+		push_back(val);
+	}
+	else {
+		int cur_pos = 0;
+		Node<T>* cur = _head;
+		while (cur != nullptr) {
+			if (cur_pos == pos - 1) break;
+			cur_pos++;
+			cur = cur->next;
+		}
+
+		if (cur != nullptr) {
+			Node<T>* new_node = new Node<T>(val, cur->next);
+			cur->next = new_node;
+			_count++;
+		}
+	}
+}
+
+template <class T>
+Node<T>* List<T>::find(const T& val) {
+	Node<T>* current = _head;
+	while (current != nullptr) {
+		if (current->value == val) {
+			return current;
+		}
+		current = current->next;
+	}
+	return nullptr;
+}
+
+template <class T>
+void List<T>::pop_front() {
+	if (is_empty()) throw ("List is empty");
+
+	Node<T>* temp = _head;
+	_head = _head->next;
+	delete temp;
+	_count--;
+
+	if (is_empty()) {
+		_tail = nullptr;
+	}
+}
+
+template <class T>
+void List<T>::pop_back() {
+	if (is_empty()) throw ("List is empty");
+
+	if (_head == _tail) {
+		delete _head;
+		_head = nullptr;
+		_tail = nullptr;
+		_count = 0;
+		return;
+	}
+
+	Node<T>* current = _head;
+	while (current->next != _tail) {
+		current = current->next;
+	}
+
+	delete _tail;
+	_tail = current;
+	_tail->next = nullptr;
+	_count--;
+}
+
+template <class T>
+T List<T>::front() const {
+	if (is_empty()) throw ("List is empty");
+	return _head->value;
+}
+
+template <class T>
+T List<T>::back() const {
+	if (is_empty()) throw ("List is empty");
+	return _tail->value;
+}
+
+
+template <class T>
+void List<T>::erase(Node<T>* node) {
+	if (node == nullptr || is_empty()) return;
+
+	if (node == _head) {
+		pop_front();
+		return;
+	}
+
+	Node<T>* prev = _head;
+	while (prev != nullptr && prev->next != node) {
+		prev = prev->next;
+	}
+
+	if (prev != nullptr) {
+		prev->next = node->next;
+		if (node == _tail) {
+			_tail = prev;
+		}
+		delete node;
+		_count--;
+	}
+}
diff --git a/lib_queue/CMakeLists.txt b/lib_queue/CMakeLists.txt
new file mode 100644
index 00000000..d918c89d
--- /dev/null
+++ b/lib_queue/CMakeLists.txt
@@ -0,0 +1 @@
+create_project_lib(Queue)
diff --git a/lib_queue/queue.cpp b/lib_queue/queue.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/lib_queue/queue.h b/lib_queue/queue.h
new file mode 100644
index 00000000..4a78f8ef
--- /dev/null
+++ b/lib_queue/queue.h
@@ -0,0 +1,161 @@
+template <class T>
+class Queue {
+    T* _data;
+    int _head;
+    int _count;
+    int _capacity;
+
+public:
+
+    Queue(int capacity = 15);
+    Queue(const Queue<T>& other);
+    ~Queue();
+
+    Queue<T>& operator=(const Queue<T>& other);
+    Queue<T>& operator=(Queue<T>&& other) noexcept;
+    void enqueue(const T& value);
+    T dequeue();
+    T& front();
+    const T& front() const;
+    T& back();
+    const T& back() const;
+    bool empty() const;
+    bool full() const;
+    int size() const;
+    int capacity() const;
+    void clear();
+    int tail() const;
+
+};
+
+template <class T>
+Queue<T>::Queue(int capacity) : _data(new T[capacity]), _head(0), _count(0), _capacity(capacity){}
+
+template <class T>
+Queue<T>::Queue(const Queue<T>& other) : _data(new T[other._capacity]), _head(other._head), _count(other._count), _capacity(other._capacity) {
+    for (int i = 0; i < _count; i++) {
+        _data[(i + _head) % _capacity] = other._data[(i + other._head) % other._capacity];
+    }
+}
+
+template <class T>
+Queue<T>::~Queue() {
+    delete[] _data;
+}
+
+template <class T>
+Queue<T>& Queue<T>::operator=(const Queue<T>& other) {
+    if (this != &other) {
+        delete[] _data;
+        _capacity = other._capacity;
+        _head = other._head;
+        _count = other._count;
+        _data = new T[_capacity];
+
+        for (int i = 0; i < _count; i++) {
+            _data[(i + _head) % _capacity] = other._data[(i + other._head) % other._capacity];
+        }
+    }
+    return *this;
+}
+
+template <class T>
+Queue<T>& Queue<T>::operator=(Queue<T>&& other) noexcept {
+    if (this != &other) {
+        delete[] _data;
+        _data = other._data;
+        _head = other._head;
+        _count = other._count;
+        _capacity = other._capacity;
+
+        other._data = nullptr;
+        other._head = 0;
+        other._count = 0;
+        other._capacity = 0;
+    }
+    return *this;
+}
+
+template <class T>
+void Queue<T>::enqueue(const T& value) {
+    if (full()) {
+        throw std::runtime_error("Queue is full");
+    }
+    _data[(_head + _count) % _capacity] = value;
+    _count++;
+}
+
+template <class T>
+T Queue<T>::dequeue() {
+    if (empty()) {
+        throw std::runtime_error("Queue is empty");
+    }
+    T value = _data[_head];
+    _head = (_head + 1) % _capacity;
+    _count--;
+    return value;
+}
+
+template <class T>
+T& Queue<T>::front() {
+    if (empty()) {
+        throw std::runtime_error("Queue is empty");
+    }
+    return _data[_head];
+}
+
+template <class T>
+const T& Queue<T>::front() const {
+    if (empty()) {
+        throw std::runtime_error("Queue is empty");
+    }
+    return _data[_head];
+}
+
+template <class T>
+T& Queue<T>::back() {
+    if (empty()) {
+        throw std::runtime_error("Queue is empty");
+    }
+    return _data[tail() - 1];
+}
+
+template <class T>
+const T& Queue<T>::back() const {
+    if (empty()) {
+        throw std::runtime_error("Queue is empty");
+    }
+    return _data[tail() - 1];
+}
+
+template <class T>
+bool Queue<T>::empty() const {
+    return _count == 0;
+}
+
+template <class T>
+bool Queue<T>::full() const {
+    return _count == _capacity;
+}
+
+template <class T>
+int Queue<T>::size() const {
+    return _count;
+}
+
+template <class T>
+int Queue<T>::capacity() const {
+    return _capacity;
+}
+
+template <class T>
+void Queue<T>::clear() {
+    _head = 0;
+    _count = 0;
+}
+
+template <class T>
+int Queue<T>::tail() const {
+    return (_head + _count) % _capacity;
+}
+
diff --git a/tests/tests_List.cpp b/tests/tests_List.cpp
new file mode 100644
index 00000000..6118c6cf
--- /dev/null
+++ b/tests/tests_List.cpp
@@ -0,0 +1,153 @@
+#include <gtest/gtest.h>
+#include "List.h"
+
+TEST(ListTest1, DefaultConstructor) {
+    List<int> list;
+    EXPECT_TRUE(list.is_empty());
+    EXPECT_EQ(list.size(), 0);
+}
+
+TEST(ListTest2, PushFrontSingle) {
+    List<int> list;
+    list.push_front(42);
+    EXPECT_FALSE(list.is_empty());
+    EXPECT_EQ(list.size(), 1);
+    EXPECT_EQ(list.front(), 42);
+    EXPECT_EQ(list.back(), 42);
+}
+
+TEST(ListTest3, PushBackSingle) {
+    List<int> list;
+    list.push_back(42);
+    EXPECT_FALSE(list.is_empty());
+    EXPECT_EQ(list.size(), 1);
+    EXPECT_EQ(list.front(), 42);
+    EXPECT_EQ(list.back(), 42);
+}
+
+TEST(ListTest4, PushFrontMultiple) {
+    List<int> list;
+    list.push_front(3);
+    list.push_front(2);
+    list.push_front(1);
+    EXPECT_EQ(list.size(), 3);
+    EXPECT_EQ(list.front(), 1);
+    EXPECT_EQ(list.back(), 3);
+}
+
+TEST(ListTest5, PushBackMultiple) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.push_back(3);
+    EXPECT_EQ(list.size(), 3);
+    EXPECT_EQ(list.front(), 1);
+    EXPECT_EQ(list.back(), 3);
+}
+
+TEST(ListTest6, MixedPushOperations) {
+    List<int> list;
+    list.push_front(2);
+    list.push_back(3);
+    list.push_front(1);
+    list.push_back(4);
+    EXPECT_EQ(list.size(), 4);
+    EXPECT_EQ(list.front(), 1);
+    EXPECT_EQ(list.back(), 4);
+}
+
+TEST(ListTest7, PopFront) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.push_back(3);
+
+    list.pop_front();
+    EXPECT_EQ(list.size(), 2);
+    EXPECT_EQ(list.front(), 2);
+    EXPECT_EQ(list.back(), 3);
+
+    list.pop_front();
+    EXPECT_EQ(list.size(), 1);
+    EXPECT_EQ(list.front(), 3);
+    EXPECT_EQ(list.back(), 3);
+
+    list.pop_front();
+    EXPECT_TRUE(list.is_empty());
+}
+
+TEST(ListTest8, PopBack) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.push_back(3);
+
+    list.pop_back();
+    EXPECT_EQ(list.size(), 2);
+    EXPECT_EQ(list.front(), 1);
+    EXPECT_EQ(list.back(), 2);
+
+    list.pop_back();
+    EXPECT_EQ(list.size(), 1);
+    EXPECT_EQ(list.front(), 1);
+    EXPECT_EQ(list.back(), 1);
+
+    list.pop_back();
+    EXPECT_TRUE(list.is_empty());
+}
+
+TEST(ListTest9, PopFrontEmptyThrows) {
+    List<int> list;
+    EXPECT_THROW(list.pop_front(), const char*);
+}
+
+TEST(ListTest10, PopBackEmptyThrows) {
+    List<int> list;
+    EXPECT_THROW(list.pop_back(), const char*);
+}
+
+TEST(ListTest11, FrontEmptyThrows) {
+    List<int> list;
+    EXPECT_THROW(list.front(), const char*);
+}
+
+TEST(ListTest12, BackEmptyThrows) {
+    List<int> list;
+    EXPECT_THROW(list.back(), const char*);
+}
+
+TEST(ListTest13, FindExisting) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.push_back(3);
+
+    Node<int>* found = list.find(2);
+    ASSERT_NE(found, nullptr);
+    EXPECT_EQ(found->value, 2);
+}
+
+TEST(ListTest14, FindNonExisting) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+
+    Node<int>* found = list.find(3);
+    EXPECT_EQ(found, nullptr);
+}
+
+TEST(ListTest15, FindInEmpty) {
+    List<int> list;
+    Node<int>* found = list.find(1);
+    EXPECT_EQ(found, nullptr);
+}
+
+TEST(ListTest16, InsertAtFront) {
+    List<int> list;
+    list.push_back(2);
+    list.insert(0, 1);
+    EXPECT_EQ(list.size(), 2);
+    EXPECT_EQ(list.front(), 1);
+    EXPECT_EQ(list.back(), 2);
+}
+
diff --git a/tests/tests_cycle.cpp b/tests/tests_cycle.cpp
new file mode 100644
index 00000000..86399230
--- /dev/null
+++ b/tests/tests_cycle.cpp
@@ -0,0 +1,51 @@
+#include "doublyList.h"
+#include <gtest/gtest.h>
+
+TEST(ListCycleTest, FloydMethod_NoCycleInNormalList) {
+    List<int> list;
+    for (int i = 1; i <= 5; i++) {
+        list.push_back(i);
+    }
+    EXPECT_FALSE(list.has_cycle_floyd());
+}
+
+TEST(ListCycleTest, FloydMethod_FindsCycle) {
+    List<int> list;
+    for (int i = 1; i <= 5; i++) {
+        list.push_back(i);
+    }
+
+
+}
+
+//TEST(ListCycleTest, ReverseMethod_NoCycleInEmptyList) {
+//    List<int> list;
+//    EXPECT_FALSE(list.has_cycle_reverse());
+//}
+//
+//TEST(ListCycleTest, ReverseMethod_FindsCycleAtStart) {
+//    List<int> list;
+//    for (int i = 1; i <= 5; i++) {
+//        list.push_back(i);
+//    }
+//    EXPECT_TRUE(list.has_cycle_reverse());
+//}
+//
+//TEST(ListCycleTest, FindCycleStart_ReturnsEndWhenNoCycle) {
+//    List<int> list;
+//    for (int i = 1; i <= 3; i++) {
+//        list.push_back(i);
+//    }
+//    auto result = list.find_cycle_start();
+//    EXPECT_EQ(result, list.end());
+//}
+//
+//TEST(ListCycleTest, FindCycleStart_ReturnsCorrectNode) {
+//    List<int> list;
+//    for (int i = 1; i <= 5; i++) {
+//        list.push_back(i);
+//    }
+//    auto result = list.find_cycle_start();
+//    EXPECT_NE(result, list.end());
+//    EXPECT_EQ(*result, 2);
+//}
\ No newline at end of file
diff --git a/tests/tests_doublyList.cpp b/tests/tests_doublyList.cpp
new file mode 100644
index 00000000..9a1ecae8
--- /dev/null
+++ b/tests/tests_doublyList.cpp
@@ -0,0 +1,90 @@
+#include <gtest/gtest.h>
+#include "doublyList.h"
+
+
+TEST(IteratorTest1, ForwardTraversal) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.push_back(3);
+
+    auto it = list.begin();
+    EXPECT_EQ(*it, 1);
+    ++it;
+    EXPECT_EQ(*it, 2);
+    ++it;
+    EXPECT_EQ(*it, 3);
+    ++it;
+    EXPECT_EQ(it, list.end());
+}
+
+TEST(IteratorTest2, PostIncrement) {
+    List<int> list;
+    list.push_back(10);
+    list.push_back(20);
+
+    auto it = list.begin();
+    EXPECT_EQ(*(it++), 10);
+    EXPECT_EQ(*it, 20);
+    EXPECT_EQ(*(it++), 20);
+    EXPECT_EQ(it, list.end());
+}
+
+TEST(IteratorTest3, ReverseTraversal) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+    list.push_back(3);
+
+    auto rit = list.rbegin();
+    EXPECT_EQ(*rit, 3);
+    ++rit;
+    //EXPECT_EQ(*rit, 2);
+    //++rit;
+    //EXPECT_EQ(*rit, 1);
+    //++rit;
+    //EXPECT_EQ(rit, list.rend());
+
+}
+
+TEST(IteratorTest4, Modification) {
+    List<int> list;
+    list.push_back(5);
+    list.push_back(15);
+
+    auto it = list.begin();
+    *it = 50;
+    EXPECT_EQ(list.front(), 50);
+
+    ++it;
+    *it = 150;
+    EXPECT_EQ(list.back(), 150);
+}
+
+TEST(IteratorTest6, EmptyList) {
+    List<int> list;
+    EXPECT_EQ(list.begin(), list.end());
+    EXPECT_EQ(list.rbegin(), list.rend());
+
+    int count = 0;
+    for (auto it = list.begin(); it != list.end(); ++it) {
+        count++;
+    }
+    EXPECT_EQ(count, 0);
+}
+
+TEST(IteratorTest7, Equality) {
+    List<int> list;
+    list.push_back(1);
+    list.push_back(2);
+
+    auto it1 = list.begin();
+    auto it2 = list.begin();
+    EXPECT_EQ(it1, it2);
+
+    ++it1;
+    EXPECT_NE(it1, it2);
+
+    ++it2;
+    EXPECT_EQ(it1, it2);
+}
\ No newline at end of file
diff --git a/tests/tests_queue.cpp b/tests/tests_queue.cpp
new file mode 100644
index 00000000..1f95e369
--- /dev/null
+++ b/tests/tests_queue.cpp
@@ -0,0 +1,141 @@
+#include <gtest/gtest.h>
+#include "Queue.h"
+
+TEST(QueueTest, DefaultConstructor) {
+    Queue<int> q;
+    EXPECT_TRUE(q.empty());
+    EXPECT_EQ(q.size(), 0);
+    EXPECT_EQ(q.capacity(), 15);
+}
+
+TEST(QueueTest, ParameterizedConstructor) {
+    Queue<int> q(10);
+    EXPECT_TRUE(q.empty());
+    EXPECT_EQ(q.size(), 0);
+    EXPECT_EQ(q.capacity(), 10);
+}
+
+TEST(QueueTest, EnqueueAndSize) {
+    Queue<int> q;
+    q.enqueue(1);
+    q.enqueue(2);
+    q.enqueue(3);
+    EXPECT_EQ(q.size(), 3);
+    EXPECT_FALSE(q.empty());
+}
+
+TEST(QueueTest, Dequeue) {
+    Queue<int> q;
+    q.enqueue(10);
+    q.enqueue(20);
+    EXPECT_EQ(q.dequeue(), 10);
+    EXPECT_EQ(q.dequeue(), 20);
+    EXPECT_TRUE(q.empty());
+}
+
+TEST(QueueTest, FrontAndBack) {
+    Queue<int> q;
+    q.enqueue(100);
+    q.enqueue(200);
+    q.enqueue(300);
+    EXPECT_EQ(q.front(), 100);
+    EXPECT_EQ(q.back(), 300);
+    q.dequeue();
+    EXPECT_EQ(q.front(), 200);
+    EXPECT_EQ(q.back(), 300);
+}
+
+TEST(QueueTest, FullAndEmpty) {
+    Queue<int> q(3);
+    EXPECT_TRUE(q.empty());
+    EXPECT_FALSE(q.full());
+    q.enqueue(1);
+    q.enqueue(2);
+    q.enqueue(3);
+    EXPECT_FALSE(q.empty());
+    EXPECT_TRUE(q.full());
+}
+
+TEST(QueueTest, Clear) {
+    Queue<int> q;
+    q.enqueue(1);
+    q.enqueue(2);
+    q.enqueue(3);
+    q.clear();
+    EXPECT_TRUE(q.empty());
+    EXPECT_EQ(q.size(), 0);
+}
+
+TEST(QueueTest, CopyConstructor) {
+    Queue<int> q1(5);
+    q1.enqueue(1);
+    q1.enqueue(2);
+    q1.enqueue(3);
+    q1.dequeue();
+    Queue<int> q2(q1);
+    EXPECT_EQ(q2.size(), 2);
+    EXPECT_EQ(q2.front(), 2);
+    EXPECT_EQ(q2.back(), 3);
+}
+
+TEST(QueueTest, CopyAssignment) {
+    Queue<int> q1(5);
+    q1.enqueue(10);
+    q1.enqueue(20);
+    Queue<int> q2;
+    q2 = q1;
+    EXPECT_EQ(q2.size(), 2);
+    EXPECT_EQ(q2.front(), 10);
+    EXPECT_EQ(q2.back(), 20);
+    q1.dequeue();
+    EXPECT_EQ(q2.size(), 2);
+}
+
+TEST(QueueTest, MoveAssignment) {
+    Queue<int> q1(5);
+    q1.enqueue(100);
+    q1.enqueue(200);
+    Queue<int> q2;
+    q2 = std::move(q1);
+    EXPECT_EQ(q2.size(), 2);
+    EXPECT_EQ(q2.front(), 100);
+    EXPECT_EQ(q2.back(), 200);
+    EXPECT_EQ(q1.size(), 0);
+    EXPECT_EQ(q1.capacity(), 0);
+}
+
+TEST(QueueTest, CircularBehavior) {
+    Queue<int> q(3);
+    q.enqueue(1);
+    q.enqueue(2);
+    q.enqueue(3);
+    q.dequeue();
+    q.enqueue(4);
+    EXPECT_EQ(q.size(), 3);
+    EXPECT_EQ(q.front(), 2);
+    EXPECT_EQ(q.back(), 4);
+}
+
+TEST(QueueTest, ExceptionOnEmptyDequeue) {
+    Queue<int> q;
+    EXPECT_THROW(q.dequeue(), std::runtime_error);
+}
+
+TEST(QueueTest, ExceptionOnEmptyFront) {
+    Queue<int> q;
+    EXPECT_THROW(q.front(), std::runtime_error);
+}
+
+TEST(QueueTest, ExceptionOnEmptyBack) {
+    Queue<int> q;
+    EXPECT_THROW(q.back(), std::runtime_error);
+}
+
+TEST(QueueTest, ConstFrontAndBack) {
+    Queue<int> q;
+    q.enqueue(42);
+    q.enqueue(99);
+    const Queue<int>& const_q = q;
+    EXPECT_EQ(const_q.front(), 42);
+    EXPECT_EQ(const_q.back(), 99);
+}