diff --git a/module-1/homework/Allocator/CMakeLists.txt b/module-1/homework/Allocator/CMakeLists.txt
index 34c00966..182a2d5d 100644
--- a/module-1/homework/Allocator/CMakeLists.txt
+++ b/module-1/homework/Allocator/CMakeLists.txt
@@ -4,6 +4,8 @@ include(GoogleTest)
 
 project("runner")
 
+set(CMAKE_CXX_STANDARD 14)
+
 configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
 
 execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
diff --git a/module-1/homework/Allocator/src/allocator/allocator.h b/module-1/homework/Allocator/src/allocator/allocator.h
index 827256c5..13037d47 100644
--- a/module-1/homework/Allocator/src/allocator/allocator.h
+++ b/module-1/homework/Allocator/src/allocator/allocator.h
@@ -1,41 +1,119 @@
 #include <memory>
 #include <type_traits>
+#include <new>
 
 template<typename T>
 class CustomAllocator {
-    public:
-
-        using value_type = T;
-        // Your code goes here
-
-        CustomAllocator();
-        CustomAllocator(const CustomAllocator& other) noexcept;
-        ~CustomAllocator();
-
-        template<typename U>
-        CustomAllocator(const CustomAllocator<U>& other) noexcept;
-                
-        T* allocate(std::size_t n);
-        void deallocate(T* p, std::size_t n);
-        template<typename... Args>
-        void construct(pointer p, Args&&... args);
-        void destroy(pointer p);
-
-        template<typename K, typename U>
-        friend bool operator==(const CustomAllocator<K>& lhs, const CustomAllocator<U>& rhs) noexcept;
-        template<typename K, typename U>
-        friend bool operator!=(const CustomAllocator<K>& lhs, const CustomAllocator<U>& rhs) noexcept;
-        
-        private:
-        // Your code goes here
+public:
+
+    template<typename U>
+    struct rebind {
+        using other = CustomAllocator<U>;
+    };
+
+    using value_type = T;
+    using reference = T&;
+    using const_reference = const T&;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using size_type = std::size_t;
+    using pointer_difference = std::ptrdiff_t;
+    using propagate_on_container_copy_assignment = std::false_type;
+    using propagate_on_container_move_assignment = std::false_type;
+    using propogate_on_container_swap = std::false_type;
+    using is_always_equal = std::false_type;
+
+
+    CustomAllocator();
+    CustomAllocator(const CustomAllocator& other) noexcept;
+    ~CustomAllocator();
+
+    template<typename U>
+    explicit CustomAllocator(const CustomAllocator<U>& other) noexcept;
+
+    T* allocate(std::size_t n);
+    void deallocate(T* p, std::size_t n);
+    template<typename... Args>
+    void construct(pointer p, Args&&... args);
+    void destroy(pointer p);
+
+    template<typename K, typename U>
+    friend bool operator==(const CustomAllocator<K>& lhs, const CustomAllocator<U>& rhs) noexcept;
+    template<typename K, typename U>
+    friend bool operator!=(const CustomAllocator<K>& lhs, const CustomAllocator<U>& rhs) noexcept;
+
+private:
+    void* arena_;
+    int* arena_offset_;
+    int* curr_arena_ref_count_;
 };
 
 template<typename T, typename U>
 bool operator==(const CustomAllocator<T>& lhs, const CustomAllocator<U>& rhs) noexcept {
-    // Your code goes here
+    return lhs.arena_ == rhs.arena_;
 }
 
 template<typename T, typename U>
 bool operator!=(const CustomAllocator<T>& lhs, const CustomAllocator<U>& rhs) noexcept {
-    // Your code goes here
-}
\ No newline at end of file
+    return !(lhs == rhs);
+}
+
+template<typename T>
+CustomAllocator<T>::CustomAllocator() {
+    arena_ = ::operator new(40000 * sizeof(T));
+    arena_offset_ = new int(0);
+    curr_arena_ref_count_ = new int(1);
+}
+
+template<typename T>
+CustomAllocator<T>::CustomAllocator(const CustomAllocator& other) noexcept :
+    arena_(other.arena_),
+    curr_arena_ref_count_(other.curr_arena_ref_count_),
+    arena_offset_(other.arena_offset_)
+{
+    (*curr_arena_ref_count_)++;
+}
+
+template<typename T>
+template<typename U>
+CustomAllocator<T>::CustomAllocator(const CustomAllocator<U>& other) noexcept :
+    arena_(other.arena_),
+    curr_arena_ref_count_(other.curr_arena_ref_count_),
+    arena_offset_(other.arena_offset_)
+{
+    (*curr_arena_ref_count_)++;
+}
+
+template<typename T>
+CustomAllocator<T>::~CustomAllocator() {
+    (*curr_arena_ref_count_)--;
+    if (*curr_arena_ref_count_ == 0) {
+        ::operator delete(arena_);
+        delete curr_arena_ref_count_;
+        delete arena_offset_;
+    }
+}
+
+template<typename T>
+T* CustomAllocator<T>::allocate(std::size_t n) {
+    int offset = *arena_offset_;
+
+    *arena_offset_ += n;
+    return static_cast<pointer>(arena_) + offset;
+}
+
+template<typename T>
+void CustomAllocator<T>::deallocate(T* p, std::size_t n) {}
+
+template<typename T>
+template<typename... Args>
+void CustomAllocator<T>::construct(CustomAllocator::pointer p, Args&& ... args) {
+    ::new((void*)p) T(std::forward<Args>(args)...);
+}
+
+template<typename T>
+void CustomAllocator<T>::destroy(CustomAllocator::pointer p) {
+    p->~T();
+}
+
+
diff --git a/module-1/homework/Allocator/src/list/list.h b/module-1/homework/Allocator/src/list/list.h
index a0affdef..6c90b2a2 100644
--- a/module-1/homework/Allocator/src/list/list.h
+++ b/module-1/homework/Allocator/src/list/list.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <list>
 #include <memory>
 #include <type_traits>
 
@@ -8,21 +7,31 @@ namespace task {
 
 template<typename T, typename Allocator=std::allocator<T>>
 class list {
-
 public:
-    
+    class iterator;
+public:
+
     using value_type = T;
+    using allocator_type = Allocator;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using pointer = typename std::allocator_traits<Allocator>::pointer;
+    using const_pointer = typename std::allocator_traits<Allocator>::const_pointer;
+    using iterator = iterator;
+    using const_iterator = const iterator;
+
     // Your code goes here
 
     // Special member functions
     list();
 
-    list(const list& other) {
-        // Your code goes here
-    }
+    list(const list& other);
+
     list(const list& other, const Allocator& alloc);
-    
-    list(list&& other) :  lst(std::move(other.lst));
+
+    list(list&& other) noexcept;
     list(list&& other, const Allocator& alloc);
 
     ~list();
@@ -38,16 +47,16 @@ class list {
     const_reference back() const;
 
     // Iterators
-    iterator begin() noexcept;
-    const_iterator begin() const noexcept;
+    iterator begin() noexcept { return iterator(NIL->getNext()); }
+    const_iterator begin() const noexcept { return iterator(NIL->getNext()); }
 
-    iterator end() noexcept;
-    const_iterator end() const noexcept;
+    iterator end() noexcept { return iterator(NIL); }
+    const_iterator end() const noexcept { return iterator(NIL); }
 
     // Capacity
-    bool empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
+    bool empty() const noexcept { return size_ == 0; }
+    size_type size() const noexcept { return size_; }
+//    size_type max_size() const noexcept;
 
     // Modifiers
     void clear();
@@ -71,10 +80,510 @@ class list {
     void unique();
     void sort();
 
-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const noexcept {
+        return allocator_type(alloc_);
+    }
 
 private:
-    // Your code goes here
+    class Node {
+    public:
+
+        Node(): value(), next(nullptr), prev(nullptr) {}
+
+        explicit Node(value_type value, Node* next = nullptr, Node* prev = nullptr) {
+            this->value = value;
+            this->next = next;
+            this->prev = prev;
+        }
+
+        value_type getValue() const { return value; }
+
+        reference getValueRef() { return value; }
+
+        const_reference getValueRef() const { return value;}
+
+        const Node* getPrev() const { return prev; }
+
+        Node* getPrev() { return prev; }
+
+        const Node* getNext() const { return next; }
+
+        Node* getNext() { return next; }
+
+        void setNext(Node* newNext) { this->next = newNext; }
+
+        void setPrev(Node* newPrev) { this->prev = newPrev; }
+
+        ~Node() {
+            this->next = nullptr;
+            this->prev = nullptr;
+        }
+
+    private:
+        value_type value;
+        Node* prev;
+        Node* next;
+    };
+public:
+    class iterator {
+        friend class std::iterator_traits<iterator>;
+    public:
+        typedef T value_type;
+        typedef iterator self_type;
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef T* pointer;
+        typedef T& reference;
+        typedef std::ptrdiff_t difference_type;
+
+        explicit iterator(Node* ptr): ptr(ptr) {}
+
+        iterator& operator++() {
+            ptr = ptr->getNext();
+            return *this;
+        }
+
+        iterator operator++(int) {
+            iterator copy(*this);
+            ++(*this);
+            return copy;
+        }
+
+        iterator& operator--() {
+            ptr = ptr->getPrev();
+            return *this;
+        }
+
+        iterator operator--(int) {
+            iterator copy(*this);
+            --(*this);
+            return copy;
+        }
+
+        bool operator==(const iterator& rhs) { return ptr == rhs.ptr; }
+        bool operator!=(const iterator& rhs) { return ptr != rhs.ptr; }
+
+        reference operator*() { return ptr->getValueRef(); }
+        T* operator->() { return &ptr->getValueRef(); }
+    private:
+        Node* ptr = nullptr;
+    };
+
+private:
+    typedef typename std::allocator_traits<Allocator>::template rebind_alloc<Node> node_allocator;
+    typedef typename std::allocator_traits<node_allocator> node_alloc_traits;
+
+
+    node_allocator alloc_;
+
+    Node* NIL;
+
+    size_t size_ = 0;
+
+    static list merge(const list& left, const list& right);//begin2 == end1
+    static std::pair<list*, list*> bisect(const list& source);
+    static list sorted(const list& source);
+
+    void copyValues(iterator beg, iterator end);
 };
 
-}
\ No newline at end of file
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator>::list(): NIL(alloc_.allocate(1)) {
+    size_ = 0;
+    alloc_.construct(NIL);
+    NIL->setNext(NIL);
+    NIL->setPrev(NIL);
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator>::list(const task::list<T, Allocator>& other):
+        alloc_(node_alloc_traits::select_on_container_copy_construction(other.alloc_)),
+        NIL(alloc_.allocate(1))
+{
+    size_ = 0;
+    alloc_.construct(NIL);
+    NIL->setNext(NIL);
+    NIL->setPrev(NIL);
+
+    this->copyValues(other.begin(), other.end());
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator>::list(const task::list<T, Allocator>& other, const Allocator& alloc): alloc_(alloc), NIL(alloc.allocate(1)) {
+    alloc.construct(NIL);
+    NIL->setPrev(NIL);
+    NIL->setNext(NIL);
+    size_ = 0;
+
+    this->copyValues(other.begin(), other.end());
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator>::~list() {
+    if (NIL == nullptr) {
+        return;
+    }
+    Node* curr = NIL->getNext();
+    while (curr && curr->getNext() != NIL) {
+        Node* to_delete = curr;
+        curr = curr->getNext();
+        alloc_.destroy(to_delete);
+        alloc_.deallocate(to_delete, 1);
+    }
+    alloc_.destroy(NIL);
+    alloc_.deallocate(NIL, 1);
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator>& task::list<T, Allocator>::operator=(const task::list<T, Allocator>& other) {
+    if (this != &other) {
+        if (node_alloc_traits::propagate_on_container_copy_assignment::value) {
+            if (alloc_ != other.alloc_) {
+                clear();
+            }
+            alloc_ = other.alloc_;
+
+        }
+        clear();
+        Node* other_head = other.NIL->getNext();
+        for (int i = 0; i < other.size(); ++i) {
+            this->push_back(other_head->getValue());
+            other_head = other_head->getNext();
+        }
+        size_ = other.size();
+    }
+    return *this;
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::copyValues(iterator beg, iterator end) {
+    for (auto it = beg; it != end; it++) {
+        push_back(*it);
+    }
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::clear() {
+    while (size()) {
+        pop_back();
+    }
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::push_back(const T& value) {
+    Node* curr_last = NIL->getPrev();
+    Node* begin = NIL;
+    Node* new_node = static_cast<Node*>(alloc_.allocate(1));
+    alloc_.construct(new_node, value);
+
+    new_node->setNext(begin);
+    new_node->setPrev(curr_last);
+    begin->setPrev(new_node);
+    curr_last->setNext(new_node);
+    ++size_;
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::pop_back() {
+    Node* last = NIL->getPrev();
+    if (last == NIL) {
+        throw std::runtime_error("Pop back in empty list");
+    }
+
+    Node* prevLast = last->getPrev();
+    prevLast->setNext(NIL);
+    NIL->setPrev(prevLast);
+    alloc_.destroy(last);
+    alloc_.deallocate(last, 1);
+    --size_;
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::push_front(const T& value) {
+    Node* new_node = static_cast<Node*>(alloc_.allocate(1));
+    alloc_.construct(new_node, value);
+    Node* curr_front = NIL->getNext();
+    NIL->setNext(new_node);
+    new_node->setPrev(NIL);
+
+    new_node->setNext(curr_front);
+    curr_front->setPrev(new_node);
+    size_++;
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::pop_front() {
+    if (NIL->getNext() == NIL) {
+        throw std::runtime_error("Pop front in empty list");
+    }
+    Node* curr_front = NIL->getNext();
+    Node* second = curr_front->getNext();
+    NIL->setNext(second);
+    second->setPrev(NIL);
+    alloc_.destroy(curr_front);
+    alloc_.deallocate(curr_front, 1);
+    size_--;
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::resize(size_t count) {
+    while (size_ > count) {
+        pop_back();
+    }
+    while (size_ < count) {
+        push_back({});
+    }
+    size_ = count;
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::remove(const T& value) {
+    Node* curr = NIL->getNext();
+    std::vector<Node*> to_delete;
+    while (curr != NIL) {
+        if (curr->getValueRef() == value) {
+            to_delete.push_back(curr);
+            Node* prev = curr->getPrev();
+            prev->setNext(curr->getNext());
+            curr->getNext()->setPrev(prev);
+            curr = curr->getNext();
+            size_--;
+        } else {
+            curr = curr->getNext();
+        }
+    }
+    for (auto& el : to_delete) {
+        alloc_.destroy(el);
+        alloc_.deallocate(el, 1);
+    }
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::unique() {
+    Node* curr = NIL->getNext()->getNext();
+
+    while (curr->getPrev() != NIL) {
+        Node* prev = curr->getPrev();
+        if (prev != NIL && prev->getValueRef() == curr->getValueRef()) {
+            Node* next = curr->getNext();
+            prev->setNext(next);
+            next->setPrev(prev);
+            size_--;
+            Node* to_delete = curr;
+            curr = curr->getNext();
+
+            alloc_.destroy(to_delete);
+            alloc_.deallocate(to_delete, 1);
+        } else {
+            curr = curr->getNext();
+        }
+    }
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::push_back(T&& value) {
+    Node* curr_last = NIL->getPrev();
+    Node* begin = NIL;
+    Node* new_node = static_cast<Node*>(alloc_.allocate(1));
+    alloc_.construct(new_node, std::forward<T>(value));
+
+    new_node->setNext(begin);
+    new_node->setPrev(curr_last);
+    begin->setPrev(new_node);
+    curr_last->setNext(new_node);
+    ++size_;
+}
+
+template<typename T, typename Allocator>
+template<typename... Args>
+void task::list<T, Allocator>::emplace_back(Args&& ... args) {
+    Node* new_node = static_cast<Node*>(alloc_.allocate(1));
+    alloc_.construct(new_node, std::forward<Args>(args)...);
+    Node* curr_front = NIL->getNext();
+    NIL->setNext(new_node);
+    new_node->setPrev(NIL);
+
+    new_node->setNext(curr_front);
+    curr_front->setPrev(new_node);
+    size_++;
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::push_front(T&& value) {
+    Node* new_node = static_cast<Node*>(alloc_.allocate(1));
+    alloc_.construct(new_node, std::forward<T>(value));
+    Node* curr_front = NIL->getNext();
+    NIL->setNext(new_node);
+    new_node->setPrev(NIL);
+
+    new_node->setNext(curr_front);
+    curr_front->setPrev(new_node);
+    size_++;
+}
+
+template<typename T, typename Allocator>
+template<typename... Args>
+void task::list<T, Allocator>::emplace_front(Args&& ... args) {
+    Node* new_node = static_cast<Node*>(alloc_.allocate(1));
+    alloc_.construct(new_node, std::forward<Args>(args)...);
+    Node* curr_front = NIL->getNext();
+    NIL->setNext(new_node);
+    new_node->setPrev(NIL);
+
+    new_node->setNext(curr_front);
+    curr_front->setPrev(new_node);
+    size_++;
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator> task::list<T, Allocator>::merge(const task::list<T, Allocator>& left, const task::list<T, Allocator>& right) {
+    task::list<T, Allocator> result;
+
+    const Node* curr_left = left.NIL->getNext();
+    const Node* curr_right = right.NIL->getNext();
+
+    while (curr_left != left.NIL && curr_right != right.NIL) {
+        if (curr_left->getValueRef() < curr_right->getValueRef()) {
+            result.push_back(std::move(curr_left->getValueRef()));
+            curr_left = curr_left->getNext();
+        } else {
+            result.push_back(std::move(curr_right->getValueRef()));
+            curr_right = curr_right->getNext();
+        }
+    }
+
+    while (curr_left != left.NIL) {
+        result.push_back(std::move(curr_left->getValueRef()));
+        curr_left = curr_left->getNext();
+    }
+
+    while (curr_right != right.NIL) {
+        result.push_back(std::move(curr_right->getValueRef()));
+        curr_right = curr_right->getNext();
+    }
+
+    return result;
+}
+
+template<typename T, typename Allocator>
+std::pair<task::list<T, Allocator>*, task::list<T, Allocator>*> task::list<T, Allocator>::bisect(const task::list<T, Allocator>& source) {
+    int size = source.size();
+    auto* left = new task::list<T, Allocator>();
+    auto* right = new task::list<T, Allocator>();
+
+    Node* curr = source.NIL->getNext();
+
+    for (int i = 0; i < size / 2; ++i, curr = curr->getNext()) {
+        left->push_back(std::move(curr->getValueRef()));
+    }
+
+    for (int i = size / 2; i < size; ++i, curr = curr->getNext()) {
+        right->push_back(std::move(curr->getValueRef()));
+    }
+
+    return {left, right};
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator> task::list<T, Allocator>::sorted(const task::list<T, Allocator>& source) {
+    if (source.size() > 1) {
+        auto res = task::list<T, Allocator>::bisect(source);
+        return task::list<T, Allocator>::merge(task::list<T, Allocator>::sorted(*res.first), task::list<T, Allocator>::sorted(*res.second));
+    }
+    return source;
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator>::list(task::list<T, Allocator>&& other, const Allocator& alloc) :
+    alloc_(alloc),
+    NIL(other.NIL)
+{
+    other.NIL = nullptr;
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator>::list(task::list<T, Allocator>&& other) noexcept :
+    alloc_(std::move(other.alloc_)),
+    NIL(other.NIL)
+{
+    other.NIL = nullptr;
+}
+
+template<typename T, typename Allocator>
+task::list<T, Allocator>& task::list<T, Allocator>::operator=(task::list<T, Allocator>&& other) noexcept {
+    clear();
+    if (node_alloc_traits::propagate_on_container_move_assignment::value) {
+        alloc_ = std::move(other.alloc_);
+        NIL = other.NIL;
+        other.NIL = nullptr;
+    } else if (node_alloc_traits::is_always_equal::value || alloc_ == other.alloc_) {
+        NIL = other.NIL;
+        other.NIL = nullptr;
+    } else  {
+        for (auto it = other.begin(); it != other.end(); ++it) {
+            push_back(std::move(*it));
+        }
+    }
+
+    return *this;
+}
+
+template<typename T, typename Allocator>
+typename task::list<T, Allocator>::reference task::list<T, Allocator>::front() {
+    if (!size()) {
+        throw std::runtime_error("get front in empty list");
+    }
+
+    return NIL->getNext()->getValueRef();
+}
+
+template<typename T, typename Allocator>
+typename task::list<T, Allocator>::const_reference task::list<T, Allocator>::front() const {
+    if (!size()) {
+        throw std::runtime_error("get front in empty list");
+    }
+
+    return NIL->getNext()->getValueRef();
+}
+
+template<typename T, typename Allocator>
+typename task::list<T, Allocator>::reference task::list<T, Allocator>::back() {
+    if (!size()) {
+        throw std::runtime_error("get back in empty list");
+    }
+
+    return NIL->getPrev()->getValueRef();
+}
+
+template<typename T, typename Allocator>
+typename task::list<T, Allocator>::const_reference task::list<T, Allocator>::back() const {
+    if (!size()) {
+        throw std::runtime_error("get back in empty list");
+    }
+
+    return NIL->getPrev()->getValueRef();
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::sort() {
+    *this = sorted(*this);
+}
+
+template<typename T, typename Allocator>
+void task::list<T, Allocator>::swap(task::list<T, Allocator>& other) noexcept {
+    if (!node_alloc_traits::propagate_on_container_swap::value && alloc_ != other.alloc_) {
+        throw std::runtime_error("Swap with different allocators");
+    }
+    if (node_alloc_traits::propagate_on_container_swap::value) {
+        std::swap(alloc_, other.alloc_);
+    }
+    std::swap(NIL, other.NIL);
+}
+
+
+
+
+
+
+
diff --git a/module-1/homework/Allocator/tests.cpp b/module-1/homework/Allocator/tests.cpp
index 4d88d43a..ba43eae3 100644
--- a/module-1/homework/Allocator/tests.cpp
+++ b/module-1/homework/Allocator/tests.cpp
@@ -1,5 +1,6 @@
 #include <algorithm>
 #include <list>
+#include <memory>
 #include <string>
 #include <random>
 
@@ -7,6 +8,7 @@
 #include "src/list/list.h"
 
 #include "gtest/gtest.h"
+//#define CustomAllocator std::allocator
 
 TEST(CopyAssignment, Test) {
     task::list<std::string, CustomAllocator<std::string>> actual;
@@ -30,7 +32,7 @@ TEST(MoveAssignment, Test1) {
     l2 = std::move(l1);
     l3.push_back("hello");
     l4 = std::move(l3);
-    
+
     ASSERT_TRUE(std::equal(l1.begin(), l1.end(), l3.begin(), l3.end()));
     ASSERT_TRUE(std::equal(l2.begin(), l2.end(), l4.begin(), l4.end()));
 }
@@ -38,7 +40,7 @@ TEST(MoveAssignment, Test1) {
 TEST(Front, Test1) {
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     actual.push_back("hello");
     expected.push_back("hello");
 
@@ -56,7 +58,7 @@ TEST(Front, Test1) {
 TEST(Clear, Test1) {
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     for (std::size_t i = 0; i < 10; i++) {
         actual.push_back("hello");
         expected.push_back("hello");
@@ -69,16 +71,15 @@ TEST(Clear, Test1) {
 
 TEST(Swap, Test1) {
     task::list<std::string, CustomAllocator<std::string>> actual;
+    task::list<std::string, CustomAllocator<std::string>> actual2(actual);
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+    std::list<std::string, CustomAllocator<std::string>> expected2(expected);
+
     for (std::size_t i = 0; i < 10; i++) {
         actual.push_back("hello");
         expected.push_back("hello");
     }
 
-    task::list<std::string, CustomAllocator<std::string>> actual2;
-    std::list<std::string, CustomAllocator<std::string>> expected2;
-    
     for (std::size_t i = 0; i < 10; i++) {
         actual2.push_back("world");
         expected2.push_back("world");
@@ -94,18 +95,19 @@ TEST(PushBack, Test) {
     std::vector<std::string> expected_v(10, "hello");
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     for (std::size_t i = 0; i < 10; i++) {
         actual.push_back(std::move(actual_v[i]));
         expected.push_back(std::move(expected_v[i]));
     }
+
     ASSERT_TRUE(std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()));
 }
 
 TEST(EmplaceBack, Test1) {
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     for (std::size_t i = 0; i < 10; i++) {
         actual.emplace_back("hello");
         expected.emplace_back("hello");
@@ -116,7 +118,7 @@ TEST(EmplaceBack, Test1) {
 TEST(PopBack, Test1) {
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     for (std::size_t i = 0; i < 10; i++) {
         actual.emplace_back("hello");
         expected.emplace_back("hello");
@@ -134,7 +136,7 @@ TEST(PushFront, Test1) {
     std::vector<std::string> expected_v(10, "hello");
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     for (std::size_t i = 0; i < 10; i++) {
         actual.push_front(actual_v[i]);
         expected.push_front(expected_v[i]);
@@ -147,18 +149,18 @@ TEST(PushFront, Test2) {
     std::vector<std::string> expected_v(10, "hello");
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     for (std::size_t i = 0; i < 10; i++) {
         actual.push_front(std::move(actual_v[i]));
         expected.push_front(std::move(expected_v[i]));
     }
     ASSERT_TRUE(std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()));
-}   
+}
 
 TEST(EmplaceFront, Test1) {
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     for (std::size_t i = 0; i < 10; i++) {
         actual.emplace_front("hello");
         expected.emplace_front("hello");
@@ -169,7 +171,7 @@ TEST(EmplaceFront, Test1) {
 TEST(PopFront, Test1) {
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     for (std::size_t i = 0; i < 10; i++) {
         actual.emplace_back("hello");
         expected.emplace_back("hello");
@@ -209,6 +211,11 @@ TEST(Unique, Test1) {
     std::list<std::string, CustomAllocator<std::string>> expected;
     expected.push_back("hello");
     expected.push_back("world");
+
+    for (auto it = actual.begin(); it != actual.end(); ++it) {
+        std::cout << *it << ' ';
+    }
+
     ASSERT_TRUE(std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()));
 }
 
@@ -232,7 +239,7 @@ TEST(Sort, Test1) {
 TEST(Mixed, Test1) {
     task::list<std::string, CustomAllocator<std::string>> actual;
     std::list<std::string, CustomAllocator<std::string>> expected;
-    
+
     for (std::size_t i = 0; i < 5; i++) {
         actual.push_back("hello");
         expected.push_back("hello");