better test organisation

Makefile

@@ -49,8 +49,9 @@ INCLUDES      = -I$(D_HEADERS) \
 				-I$(D_TEMPLATES)
 
 D_SRCS        = ./tests
-SRCS          = main.cpp
 #SRCS          = main42.cpp
+SRCS          = main.cpp \
+				tests_vectors.cpp
 
 D_HEADERS     = ./headers
 HEADERS       = colors.h \
@@ -72,9 +73,9 @@ endif
 
 
 # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
-#             .   target: prerequisites   .   $@ : target             #
-#    RULES    .           recipe          .   $< : 1st prerequisite   #
-#             .           recipe          .   $^ : all prerequisites  #
+#             .  target: prerequisites    .   $@ : target             #
+#    RULES    .          recipe           .   $< : 1st prerequisite   #
+#             .          @recipe (silent) .   $^ : all prerequisites  #
 # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
 
 all: $(NAME)
@@ -84,8 +85,8 @@ stl: re
 ft: re
 
 $(D_OBJS)/%.o: %.$(EXT) | $(D_OBJS)
-	@echo $(CYAN)"compilation (objects.o) :"$(RESET)
-	$(CC) $(CFLAGS) -c $< -o $@
+	@echo $(CYAN)"compilation " $@ $(RESET)
+	@$(CC) $(CFLAGS) -c $< -o $@
 
 $(D_OBJS):
 	mkdir $@

headers/tests.hpp

@@ -1,16 +1,29 @@
-#ifndef TESTS_H
-# define TESTS_H
+#ifndef TESTS_HPP
+# define TESTS_HPP
 
+#include <iostream>
 #include "colors.h"
 #include <vector>
 #include <string>
 
+
+//                                *************************
+// toogle between test ft and stl
+#include <vector>
+#ifdef STL
+	namespace ft = std;
+#else
+	#include "vector.hpp"
+#endif
+
+
+//                              ***************************
+// adding each test to the list
 # define TEST(s) \
 	{\
 		test_title = #s;\
 		struct tester : public test_base {\
 			void func()
-
 # define TESTEND \
 		};\
 		test = new(tester);\
@@ -18,15 +31,58 @@
 		test_list.push_back(test);\
 	}
 
+
+//                          *******************************
+// vector of functions test
+struct test_base { std::string title; virtual void func(){} };
+extern std::vector<test_base *>	test_list;
+extern test_base				*test;
+extern std::string				test_title;
+
+
+//                    *************************************
+// defines for titles
 # define TITLE(s) std::cout << "\n" B_PURPLE #s RESET "\n\n";
 
-struct test_base {
-		std::string title;
-		virtual void func() {}
-};
 
-std::vector<test_base *> test_list;
-test_base *test;
-std::string test_title;
+//                  ***************************************
+// struct for tests
+struct mystruct {
+public:
+	mystruct(int data = 1) {_val = new int[1]; _val[0] = data;}
+	~mystruct() {delete[] _val;}
+	int *	get_data() const {return _val;}
+private:
+	int *	_val;
+};
+extern std::ostream &	operator<<(std::ostream & o, mystruct const & rhs);
+
+
+//            *********************************************
+// prototypes
+void	tests_vector_constructor();
+void	tests_vector_operator_assignation();
+void	tests_vector_begin();
+void	tests_vector_end();
+//void	tests_vector_rbegin();
+//void	tests_vector_rend();
+void	tests_vector_size();
+void	tests_vector_max_size();
+void	tests_vector_resize();
+void	tests_vector_capacity();
+void	tests_vector_empty();
+void	tests_vector_reserve();
+void	tests_vector_operator_access();
+void	tests_vector_at();
+void	tests_vector_front();
+void	tests_vector_back();
+void	tests_vector_assign();
+void	tests_vector_push_back();
+void	tests_vector_pop_back();
+void	tests_vector_insert();
+void	tests_vector_erase();
+void	tests_vector_swap();
+void	tests_vector_clear();
+void	tests_vector_get_allocator();
 
 #endif

tests/tests_vectors.cpp

@@ -0,0 +1,970 @@
+#ifndef TESTS_VECTORS_CPP
+#define TESTS_VECTORS_CPP
+
+#include <iostream>
+#include <string>
+//#include "colors.h"
+#include "tests.hpp"
+#include <iomanip> // std::setw()
+
+
+void	tests_vector_constructor()
+{
+	TEST(vector::vector (constructor))
+    {
+		// title
+		TITLE(cplusplus.com reference)
+
+		// constructors used in the same order as described above:
+		ft::vector<int> first;                                // empty vector of ints
+		ft::vector<int> second (4,100);                       // four ints with value 100
+		ft::vector<int> third (second.begin(),second.end());  // iterating through second
+		ft::vector<int> fourth (third);                       // a copy of third
+
+		// the iterator constructor can also be used to construct from arrays:
+		int myints[] = {16,2,77,29};
+		ft::vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );
+
+		std::cout << "The contents of fifth are:";
+		for (ft::vector<int>::iterator it = fifth.begin(); it != fifth.end(); ++it)
+			std::cout << ' ' << *it;
+		std::cout << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_operator_assignation()
+{
+	TEST(vector::=operator)
+	{
+		// title
+		TITLE(cplusplus.com reference)
+
+		ft::vector<int> foo (3,0);
+		ft::vector<int> bar (5,0);
+
+		bar = foo;
+		foo = ft::vector<int>();
+
+		std::cout << "Size of foo: " << int(foo.size()) << '\n';
+		std::cout << "Size of bar: " << int(bar.size()) << '\n';
+
+
+		// title
+		TITLE(more informations)
+
+		int	size;
+
+		size = foo.size();
+		std::cout << "foo:\n";
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i <<"]" << foo[i];
+		std::cout << "\ncapacity: " << foo.capacity() << "\n";
+
+		size = bar.size();
+		std::cout << "bar:\n";
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i <<"]" << bar[i];
+		std::cout << "\ncapacity: " << bar.capacity() << "\n";
+
+	}
+	TESTEND
+}
+
+void	tests_vector_begin() {
+	TEST(vector::begin)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+		for (int i=1; i<=5; i++) myvector.push_back(i);
+
+		std::cout << "myvector contains:";
+		for (ft::vector<int>::iterator it = myvector.begin() ; it != myvector.end(); ++it)
+			std::cout << ' ' << *it;
+		std::cout << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_end()
+{
+	TEST(vector::end)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+		for (int i=1; i<=5; i++) myvector.push_back(i);
+
+		std::cout << "myvector contains:";
+		for (ft::vector<int>::iterator it = myvector.begin() ; it != myvector.end(); ++it)
+			std::cout << ' ' << *it;
+		std::cout << '\n';
+	}
+	TESTEND
+}
+
+/*
+void	tests_vector_rbegin()
+{
+	TEST(vector::rbegin)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector (5);  // 5 default-constructed ints
+
+		int i=0;
+
+		ft::vector<int>::reverse_iterator rit = myvector.rbegin();
+		for (; rit!= myvector.rend(); ++rit)
+			*rit = ++i;
+
+		std::cout << "myvector contains:";
+		for (ft::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
+			std::cout << ' ' << *it;
+		std::cout << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_rend()
+{
+	TEST(vector::rend)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector (5);  // 5 default-constructed ints
+
+		ft::vector<int>::reverse_iterator rit = myvector.rbegin();
+
+		int i=0;
+		for (rit = myvector.rbegin(); rit!= myvector.rend(); ++rit)
+			*rit = ++i;
+
+		std::cout << "myvector contains:";
+		for (ft::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
+			std::cout << ' ' << *it;
+		std::cout << '\n';
+	}
+	TESTEND
+}
+*/
+
+
+void	tests_vector_size()
+{
+	TEST(vector::size)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myints;
+		std::cout << "0. size: " << myints.size() << '\n';
+
+		for (int i=0; i<10; i++) myints.push_back(i);
+		std::cout << "1. size: " << myints.size() << '\n';
+
+		myints.insert (myints.end(),10,100);
+		std::cout << "2. size: " << myints.size() << '\n';
+
+		myints.pop_back();
+		std::cout << "3. size: " << myints.size() << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_max_size()
+{
+	TEST(vector::max_size)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+
+		// set some content in the vector:
+		for (int i=0; i<100; i++) myvector.push_back(i);
+
+		std::cout << "size: " << myvector.size() << "\n";
+		std::cout << "capacity: " << myvector.capacity() << "\n";
+		std::cout << "max_size: " << myvector.max_size() << "\n";
+	}
+	TESTEND
+}
+
+void	tests_vector_resize()
+{
+	TEST(vector::resize)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+
+		// set some initial content:
+		for (int i = 1; i < 10; i++) myvector.push_back(i);
+
+		myvector.resize(5);
+		myvector.resize(8,100);
+		myvector.resize(12);
+
+		std::cout << "myvector contains:";
+		for (unsigned int i = 0; i < myvector.size(); i++)
+			std::cout << ' ' << myvector[i];
+		std::cout << '\n';
+
+
+		// title
+		TITLE(test size and capacity 1 :)
+
+		ft::vector<int>	vector2;
+
+		std::cout << "size: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";
+
+		std::cout << "assign(10, 1)\n";
+		vector2.assign(10, 1);
+		for (unsigned int i = 0; i < vector2.size(); i++)
+			std::cout << "[" << i << "]" << vector2[i] << " ";
+		std::cout << "\n";
+
+		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";
+
+		std::cout << "resize(15)\n";
+		vector2.resize(15);
+		for (unsigned int i = 0; i < vector2.size(); i++)
+			std::cout << "[" << i << "]" << vector2[i] << " ";
+		std::cout << "\n";
+
+		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";
+
+		std::cout << "resize(10)\n";
+		vector2.resize(10);
+		for (unsigned int i = 0; i < vector2.size(); i++)
+			std::cout << "[" << i << "]" << vector2[i] << " ";
+		std::cout << "\n";
+
+		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";
+
+		std::cout << "resize(19)\n";
+		vector2.resize(19);
+		for (unsigned int i = 0; i < vector2.size(); i++)
+			std::cout << "[" << i << "]" << vector2[i] << " ";
+		std::cout << "\n";
+
+		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";
+
+		std::cout << "resize(20)\n";
+		vector2.resize(20);
+		for (unsigned int i = 0; i < vector2.size(); i++)
+			std::cout << "[" << i << "]" << vector2[i] << " ";
+		std::cout << "\n";
+
+		std::cout << "\nsize: " << vector2.size() << " - capacity: " << vector2.capacity() << "\n\n";
+
+		std::cout << "resize(21)\n";
+		vector2.resize(21);
+		for (unsigned int i = 0; i < vector2.size(); i++)
+			std::cout << "[" << i << "]" << vector2[i] << " ";
+		std::cout << "\n";
+
+
+		// title
+		TITLE(test size and capacity 2 :)
+
+		ft::vector<int>	vector3;
+
+		std::cout << "size: " << vector3.size() << " - capacity: " << vector3.capacity() << "\n\n";
+
+		std::cout << "assign(10, 1)\n";
+		vector3.assign(10, 1);
+		for (unsigned int i = 0; i < vector3.size(); i++)
+			std::cout << "[" << i << "]" << vector3[i] << " ";
+		std::cout << "\n";
+
+		std::cout << "\nsize: " << vector3.size() << " - capacity: " << vector3.capacity() << "\n\n";
+
+		std::cout << "resize(21)\n";
+		vector3.resize(21);
+		for (unsigned int i = 0; i < vector3.size(); i++)
+			std::cout << "[" << i << "]" << vector3[i] << " ";
+		std::cout << "\n";
+
+		std::cout << "\nsize: " << vector3.size() << " - capacity: " << vector3.capacity() << "\n\n";
+	}
+	TESTEND
+}
+
+void	tests_vector_capacity()
+{
+	TEST(vector::capacity)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+
+		// set some content in the vector:
+		for (int i=0; i<100; i++) myvector.push_back(i);
+
+		std::cout << "size: " << (int) myvector.size() << '\n';
+		std::cout << "capacity: " << (int) myvector.capacity() << '\n';
+		std::cout << "max_size: " << (int) myvector.max_size() << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_empty()
+{
+	TEST(vector::empty)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int>	myvector;
+		int				sum (0);
+
+		for (int i=1;i<=10;i++) myvector.push_back(i);
+
+		while (!myvector.empty())
+		{
+			sum += myvector.back();
+			myvector.pop_back();
+		}
+
+		std::cout << "total: " << sum << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_reserve()
+{
+	TEST(vector::reserve)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int>::size_type	sz;
+		ft::vector<int>				foo;
+
+		sz = foo.capacity();
+		std::cout << "making foo grow:\n";
+		for (int i=0; i<100; ++i) {
+			foo.push_back(i);
+			if (sz!=foo.capacity()) {
+				sz = foo.capacity();
+				std::cout << "capacity changed: " << sz << '\n';
+			}
+		}
+
+		ft::vector<int> bar;
+
+		sz = bar.capacity();
+		bar.reserve(100);   // this is the only difference with foo above
+		std::cout << "making bar grow:\n";
+		for (int i=0; i<100; ++i) {
+			bar.push_back(i);
+			if (sz!=bar.capacity()) {
+				sz = bar.capacity();
+				std::cout << "capacity changed: " << sz << '\n';
+			}
+		}
+	}
+	TESTEND
+}
+
+void	tests_vector_operator_access()
+{
+	TEST(vector::operator[])
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int>				myvector (10);   // 10 zero-initialized elements
+		ft::vector<int>::size_type	sz = myvector.size();
+
+		// assign some values:
+		for (unsigned i=0; i<sz; i++) myvector[i]=i;
+
+		// reverse vector using operator[]:
+		for (unsigned i=0; i<sz/2; i++)
+		{
+			int temp;
+			temp = myvector[sz-1-i];
+			myvector[sz-1-i]=myvector[i];
+			myvector[i]=temp;
+		}
+
+		std::cout << "myvector contains:";
+		for (unsigned i=0; i<sz; i++)
+			std::cout << ' ' << myvector[i];
+		std::cout << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_at()
+{
+	TEST(vector::at)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector (10);   // 10 zero-initialized ints
+
+		// assign some values:
+		for (unsigned i=0; i<myvector.size(); i++)
+			myvector.at(i)=i;
+
+		std::cout << "myvector contains:";
+		for (unsigned i=0; i<myvector.size(); i++)
+			std::cout << ' ' << myvector.at(i);
+		std::cout << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_front()
+{
+	TEST(vector::front)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+
+		myvector.push_back(78);
+		myvector.push_back(16);
+
+		// now front equals 78, and back 16
+
+		myvector.front() -= myvector.back();
+
+		std::cout << "myvector.front() is now " << myvector.front() << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_back()
+{
+	TEST(vector::back)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+
+		myvector.push_back(78);
+		myvector.push_back(16);
+
+		// now front equals 78, and back 16
+
+		myvector.front() -= myvector.back();
+		std::cout << "myvector.front() is now " << myvector.front() << '\n';
+
+
+		// title
+		TITLE(test with negatives :)
+
+		myvector.push_back(236);
+		myvector.push_back(8973);
+
+		myvector.front() -= myvector.back();
+		std::cout << "myvector.front() is now " << myvector.front() << '\n';
+
+
+		// title
+		TITLE(test with char :)
+
+		ft::vector<char> letters;
+		letters.push_back('o');
+		letters.push_back('m');
+		letters.push_back('g');
+		letters.push_back('w');
+		letters.push_back('t');
+		letters.push_back('f');
+
+		if (!letters.empty()) {
+			std::cout << "The first character is '" << letters.front() << "'.\n";
+		}
+	}
+	TESTEND
+}
+
+void	tests_vector_assign()
+{
+	TEST(vector::assign)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> first;
+		ft::vector<int> second;
+		ft::vector<int> third;
+
+		first.assign (7,100);             // 7 ints with a value of 100
+
+		ft::vector<int>::iterator it;
+		it=first.begin()+1;
+
+		second.assign (it,first.end()-1); // the 5 central values of first
+
+		int myints[] = {1776,7,4};
+		third.assign (myints,myints+3);   // assigning from array.
+
+		std::cout << "Size of first: " << int (first.size()) << '\n';
+		std::cout << "Size of second: " << int (second.size()) << '\n';
+		std::cout << "Size of third: " << int (third.size()) << '\n';
+
+		// title
+		TITLE(capacity tests of assignation :)
+
+		ft::vector<int> myvector;
+		int	size;
+
+		std::cout << "capacity before assignation : " << myvector.capacity() << "\n";
+
+		std::cout << "\nassign 1\n";
+		myvector.assign(1, 12);
+		size = myvector.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << myvector[i] << " - ";
+		std::cout << "\nsize : " << size << " , capacity : "  << myvector.capacity() << "\n";
+
+		std::cout << "\nassign 3\n";
+		myvector.assign(3, 12);
+		size = myvector.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << myvector[i] << " - ";
+		std::cout << "\nsize : " << size << " , capacity : "  << myvector.capacity() << "\n";
+
+		std::cout << "\nassign 7268\n";
+		myvector.assign(7268, 12);
+		size = myvector.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << myvector[i] << " - ";
+		std::cout << "\nsize : " << size << " , capacity : "  << myvector.capacity() << "\n";
+
+
+		// title
+		TITLE(tests of iterators :)
+
+		ft::vector<int> int_vector_1;
+		ft::vector<int> int_vector_2;
+		ft::vector<int> int_vector_3;
+		ft::vector<int> it_vector;
+		int	ssize;
+
+		std::cout << "\nassign 1\n";
+		int_vector_1.assign(1, 12);
+		it_vector.assign(int_vector_1.begin(), int_vector_1.end());
+		ssize = it_vector.size();
+		for (int i = 0; i < ssize; i++)
+			std::cout << "[" << i << "] " << it_vector[i] << " - ";
+		std::cout << "\nsize : " << ssize << " , capacity : "  << it_vector.capacity() << "\n";
+
+		std::cout << "\nassign 0\n";
+		int_vector_2.assign(1, 6);
+		it_vector.assign(int_vector_2.begin(), int_vector_2.end() - 1);
+		ssize = it_vector.size();
+		for (int i = 0; i < ssize; i++)
+			std::cout << "[" << i << "] " << it_vector[i] << " - ";
+		std::cout << "\nsize : " << ssize << " , capacity : "  << it_vector.capacity() << "\n";
+
+		std::cout << "\nassign 266 - 13 - 172 = 81\n";
+		int_vector_3.assign(266, 1);
+		it_vector.assign(int_vector_3.begin() + 13, int_vector_3.end() - 172);
+		ssize = it_vector.size();
+		for (int i = 0; i < ssize; i++)
+			std::cout << "[" << i << "] " << it_vector[i] << " - ";
+		std::cout << "\nsize : " << ssize << " , capacity : "  << it_vector.capacity() << "\n";
+	}
+	TESTEND
+}
+
+void	tests_vector_push_back()
+{
+	TEST(vector::push_back)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+
+		int	myint[] = {12434, -2432, 12, 5345, 23, 0, -4, 387, 8432, -934723, 1};
+		int	size = sizeof(myint) / sizeof(myint[0]);
+		for (int i = 0; i < size; i++)
+		{
+			myvector.push_back(myint[i]);
+			std::cout << "[capacity : "
+					  << std::setw(2) << myvector.capacity() << "] "
+					  << myvector[i] << "\n";
+		}
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << std::setw(2) << i << "] " << myvector[i] << "\n";
+		std::cout << "  -> size : " << myvector.size() << " , capacity :"  << myvector.capacity() << "\n";
+
+
+		// title
+		TITLE(big push back :)
+
+		for (int i = 0; i < 72363; i++)
+		{
+			myvector.push_back(9);
+			std::cout << "[" << i
+					  << ":" << myvector.capacity() << "] ";
+		}
+		std::cout << "  -> size : " << myvector.size() << " , capacity :"  << myvector.capacity() << "\n";
+	}
+	TESTEND
+}
+
+void	tests_vector_pop_back()
+{
+	TEST(vector::pop_back)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+
+		int sum (0);
+
+		myvector.push_back (100);
+		myvector.push_back (200);
+		myvector.push_back (300);
+
+		while (!myvector.empty())
+		{
+			sum+=myvector.back();
+			myvector.pop_back();
+		}
+
+		std::cout << "The elements of myvector add up to " << sum << '\n';
+
+
+		// title
+		TITLE(check state :)
+
+		std::cout << "size : "		<< myvector.size() << '\n';
+		std::cout << "capacity : "	<< myvector.capacity() << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_insert()
+{
+	TEST(vector::insert)
+	{
+		ft::vector<int>::iterator		it;
+		ft::vector<mystruct*>::iterator	its;
+		int								i;
+
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector (3,100);
+
+		it = myvector.begin();
+		it = myvector.insert ( it , 200 );
+		myvector.insert (it,2,300);
+
+		ft::vector<int> anothervector (2,400);
+		it = myvector.begin();
+		myvector.insert (it+2,anothervector.begin(),anothervector.end());
+
+		int myarray [] = { 501,502,503 };
+		myvector.insert (myvector.begin(), myarray, myarray+3);
+
+		std::cout << "myvector contains:";
+		for (it=myvector.begin(); it<myvector.end(); it++)
+			std::cout << ' ' << *it;
+		std::cout << '\n';
+
+
+		// title
+		TITLE(tests positions on insert(pos, value) :)
+
+		ft::vector<int>				myvector2 (3,100);
+
+		it = myvector2.begin();
+		std::cout << "size:" << myvector2.size() << " capacity:" << myvector2.capacity() << "\n";
+		myvector2.insert ( it , 200 );
+		std::cout << "myvector contains:";
+		for (it = myvector2.begin(); it < myvector2.end(); it++)
+			std::cout << ' ' << *it;
+		std::cout << "\nsize:" << myvector2.size() << " capacity:" << myvector2.capacity() << "\n";
+
+		ft::vector<int>				myvector3 (3,100);
+
+		it = myvector3.end();
+		std::cout << "\nsize:" << myvector3.size() << " capacity:" << myvector3.capacity() << "\n";
+		myvector3.insert ( it , 200 );
+		std::cout << "myvector contains:";
+		for (it = myvector3.begin(); it < myvector3.end(); it++)
+			std::cout << ' ' << *it;
+		std::cout << "\nsize:" << myvector3.size() << " capacity:" << myvector3.capacity() << "\n";
+
+
+		// title
+		TITLE(tests positions on insert(pos, value) with struct :)
+
+		ft::vector<mystruct*>			myvector4;
+		mystruct						*s;
+
+		i = 0;
+		while (i < 3)
+		{
+			s = new mystruct(i++);
+			myvector4.push_back(s);
+		}
+
+		its = myvector4.begin();
+		std::cout << "size:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
+		s = new mystruct(i++);
+		myvector4.insert ( its , s );
+		std::cout << "myvector contains:";
+		for (its = myvector4.begin(); its < myvector4.end(); its++)
+			std::cout << ' ' << **its;
+		std::cout << "\nsize:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
+
+		its = myvector4.begin() + 2;
+		std::cout << "\nsize:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
+		s = new mystruct(i++);
+		myvector4.insert ( its , s );
+		std::cout << "myvector contains:";
+		for (its = myvector4.begin(); its < myvector4.end(); its++)
+			std::cout << ' ' << **its;
+		std::cout << "\nsize:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
+
+		its = myvector4.end();
+		std::cout << "\nsize:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
+		s = new mystruct(i++);
+		myvector4.insert ( its , s );
+		std::cout << "myvector contains:";
+		for (its = myvector4.begin(); its < myvector4.end(); its++)
+			std::cout << ' ' << **its;
+		std::cout << "\nsize:" << myvector4.size() << " capacity:" << myvector4.capacity() << "\n";
+
+
+		// title
+		TITLE(tests insert(pos, size, value) :)
+
+		ft::vector<int>			myvector5;
+
+		for (i = 1; i <= 5; i++)
+			myvector5.push_back(i * 100);
+
+		it = myvector5.begin() + 1;
+		myvector5.insert ( it , 150 );
+
+		it = myvector5.end();
+		myvector5.insert (it,2,600);
+
+		it = myvector5.end() - 2;
+		myvector5.insert (it,2,550);
+
+		std::cout << "myvector contains:";
+		for (it = myvector5.begin(); it < myvector5.end(); it++)
+			std::cout << ' ' << *it;
+		std::cout << '\n';
+		std::cout << "\nsize:" << myvector5.size() << " capacity:" << myvector5.capacity() << "\n";
+
+
+		// title
+		TITLE(tests positions on insert(pos, value) with struct :)
+
+		ft::vector<mystruct*>			myvector6;
+
+		i = 1;
+		while (i <= 5)
+		{
+			s = new mystruct(i++ * 100);
+			myvector6.push_back(s);
+		}
+
+		its = myvector6.begin() + 1;
+		s = new mystruct(150);
+		myvector6.insert ( its , s );
+
+		its = myvector6.end();
+		s = new mystruct(600);
+		myvector6.insert ( its, 2, s );
+
+		its = myvector6.end() - 2;
+		s = new mystruct(550);
+		myvector6.insert ( its, 2, s );
+
+		std::cout << "myvector contains:";
+		for (its = myvector6.begin(); its < myvector6.end(); its++)
+			std::cout << ' ' << **its;
+		std::cout << "\nsize:" << myvector6.size() << " capacity:" << myvector6.capacity() << "\n";
+
+
+		// title
+		TITLE(tests insert(pos, first, last) with struct :)
+
+		ft::vector<mystruct*>			myvector7;
+
+		for (i = 0; i < 5; i++)
+		{
+			s = new mystruct(42);
+			myvector7.push_back(s);
+		}
+
+		its = myvector7.begin() + 2;
+		myvector7.insert ( its, myvector6.begin() + 3, myvector6.end() - 2 );
+
+		std::cout << "myvector contains:";
+		for (its = myvector7.begin(); its < myvector7.end(); its++)
+			std::cout << ' ' << **its;
+		std::cout << "\nsize:" << myvector7.size() << " capacity:" << myvector7.capacity() << "\n";
+	}
+	TESTEND
+}
+
+void	tests_vector_erase()
+{
+	TEST(vector::erase)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+
+		// set some values (from 1 to 10)
+		for (int i=1; i<=10; i++) myvector.push_back(i);
+
+		// erase the 6th element
+		myvector.erase (myvector.begin()+5);
+
+		// erase the first 3 elements:
+		myvector.erase (myvector.begin(),myvector.begin()+3);
+
+		std::cout << "myvector contains:";
+		for (unsigned i=0; i<myvector.size(); ++i)
+			std::cout << ' ' << myvector[i];
+		std::cout << '\n';
+
+
+		// title
+		TITLE(test iterator bigger or equal :)
+		ft::vector<int>	vector2;
+		int				size;
+
+		for (int i=1; i<=100; i++) vector2.push_back(i);
+		size = vector2.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << vector2[i] << " ";
+		std::cout << "\nsize:" << size << " capacity:" << vector2.capacity() << "\n";
+
+		std::cout << "\nerase pos(7,36) :\n";
+		vector2.erase(vector2.begin() + 7, vector2.begin() + 36);
+		size = vector2.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << vector2[i] << " ";
+		std::cout << "\nsize:" << size << " capacity:" << vector2.capacity() << "\n";
+
+		std::cout << "\nerase pos(46,54) :\n";
+		vector2.erase(vector2.begin() + 46, vector2.begin() + 54);
+		size = vector2.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << vector2[i] << " ";
+		std::cout << "\nsize:" << size << " capacity:" << vector2.capacity() << "\n";
+
+		std::cout << "\nerase pos(7,7) :\n";
+		vector2.erase(vector2.begin() + 7, vector2.begin() + 7);
+		size = vector2.size();
+		for (int i = 0; i < size; i++)
+			std::cout << "[" << i << "] " << vector2[i] << " ";
+		std::cout << "\nsize:" << size << " capacity:" << vector2.capacity() << "\n";
+	}
+	TESTEND
+}
+
+void	tests_vector_swap()
+{
+	TEST(vector::swap)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> foo (3,100);   // three ints with a value of 100
+		ft::vector<int> bar (5,200);   // five ints with a value of 200
+
+		foo.swap(bar);
+
+		std::cout << "foo contains:";
+		for (unsigned i=0; i<foo.size(); i++)
+			std::cout << ' ' << foo[i];
+		std::cout << '\n';
+
+		std::cout << "bar contains:";
+		for (unsigned i=0; i<bar.size(); i++)
+			std::cout << ' ' << bar[i];
+		std::cout << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_clear()
+{
+	TEST(vector::clear)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+		myvector.push_back (100);
+		myvector.push_back (200);
+		myvector.push_back (300);
+
+		std::cout << "myvector contains:";
+		for (unsigned i=0; i<myvector.size(); i++)
+			std::cout << ' ' << myvector[i];
+		std::cout << '\n';
+
+		myvector.clear();
+		myvector.push_back (1101);
+		myvector.push_back (2202);
+
+		std::cout << "myvector contains:";
+		for (unsigned i=0; i<myvector.size(); i++)
+			std::cout << ' ' << myvector[i];
+		std::cout << '\n';
+	}
+	TESTEND
+}
+
+void	tests_vector_get_allocator()
+{
+	TEST(vector::get_allocator)
+	{
+		// title
+		TITLE(cplusplus.com reference :)
+
+		ft::vector<int> myvector;
+		int * p;
+		unsigned int i;
+
+		// allocate an array with space for 5 elements using vector's allocator:
+		p = myvector.get_allocator().allocate(5);
+
+		// construct values in-place on the array:
+		for (i=0; i<5; i++) myvector.get_allocator().construct(&p[i],i);
+
+		std::cout << "The allocated array contains:";
+		for (i=0; i<5; i++) std::cout << ' ' << p[i];
+		std::cout << '\n';
+
+		// destroy and deallocate:
+		for (i=0; i<5; i++) myvector.get_allocator().destroy(&p[i]);
+		myvector.get_allocator().deallocate(p,5);
+	}
+	TESTEND
+}
+
+#endif