diff --git a/README.md b/README.md
index 4c54c1f..b4e7bc1 100644
--- a/README.md
+++ b/README.md
@@ -128,6 +128,20 @@ std::vector<MyStruct> allGatheredvTwo = mpiWorld().varyingAllGather(vecToSend,
 	receiveCounts,displacements);
 ```
 
+Every functions defined for a single [POD](http://en.cppreference.com/w/cpp/concept/PODType) type is also defined for a collection of [POD](http://en.cppreference.com/w/cpp/concept/PODType)s. This collection can either be held in a `std::vector` or in a `std::array`. For instance,
+
+```c++
+const int count = 2;
+if(mpiWorld().rank() == sourceIndex) {
+	const std::vector<MyStruct> collection(count,toSend);
+	mpiWorld().sendAndBlock(collection,destinationIndex);
+}
+if(mpiWorld().rank() == destinationIndex) {
+	const std::vector<MyStruct> received =
+		mpiWorld().receiveAndBlock<std::vector<MyStruct>>(count,sourceIndex);
+}
+```
+
 # Communicator
 
 ## Identical v.s. Congruent communicators
diff --git a/include/NiceMPI/NiceMPI.h b/include/NiceMPI/NiceMPI.h
index dee0767..b56b909 100644
--- a/include/NiceMPI/NiceMPI.h
+++ b/include/NiceMPI/NiceMPI.h
@@ -23,6 +23,8 @@ SOFTWARE. */
 #ifndef NICEMPI_H
 #define NICEMPI_H
 
+#include <array>
+#include <cstddef> // std::size_t
 #include <memory> // unique_ptr
 #include <type_traits> // std::is_pod, std::enable_if
 #include <utility> // std::move
@@ -44,6 +46,46 @@ Communicator &mpiSelf(); // Forward declaration
 Communicator createProxy(MPI_Comm mpiCommunicator); // Forward declaration
 
 
+
+/** \brief std::array that contains PODs are both POD and collection, so we need to distinguish them. */
+template<class T>
+struct is_std_array {
+	static constexpr bool value = false;
+};
+/** \brief std::array that contains PODs are both POD and collection, so we need to distinguish them.
+  *Specialization*.*/
+template<class T, std::size_t N>
+struct is_std_array<std::array<T,N>> {
+	static constexpr bool value = true;
+};
+
+
+
+/** \brief Type traits that defines an alias for the type contained in a container. Usefull in ReceiveRequest.
+  *Specialization*.*/
+template<class T>
+struct to_contained_type {
+	using type = T;
+};
+/** \brief Type traits that defines an alias for the type contained in a container. Usefull in ReceiveRequest.
+  *Specialization*.*/
+template<class T, class Allocator>
+struct to_contained_type<std::vector<T,Allocator>> {
+	using type = typename std::vector<T,Allocator>::value_type;
+};
+/** \brief Type traits that defines an alias for the type contained in a container. Usefull in ReceiveRequest.
+  *Specialization*.*/
+template<class T, std::size_t N>
+struct to_contained_type<std::array<T,N>> {
+	using type = typename std::array<T,N>::value_type;
+};
+/** \brief Type traits that defines an alias for the type contained in a container. Usefull in ReceiveRequest.
+  *Alias*.*/
+template<class T>
+using to_contained_type_t = typename to_contained_type<T>::type;
+
+
+
 /** \brief Returns after an asyncSend call, this object allows to control the status of the call. */
 class SendRequest {
 public:
@@ -73,7 +115,7 @@ template<class Type>
 class ReceiveRequest {
 public:
 	/** \brief The function asyncReceive initializes the member of the request directly. */
-	ReceiveRequest(): dataPtr(new Type)
+	ReceiveRequest(int count): data(count)
 	{}
 	/** \brief Destroys the handle \p rhs. Only there because of the
 		[rule of 5](http://en.cppreference.com/w/cpp/language/rule_of_three). */
@@ -98,8 +140,8 @@ class ReceiveRequest {
 		handleError(MPI_Wait(&value,MPI_STATUS_IGNORE));
 	}
 	/** Returns the data, assuming that the user made sure that the receiving operation was completed. */
-	std::unique_ptr<Type> take() {
-		return std::move(dataPtr);
+	std::vector<to_contained_type_t<Type>> take() {
+		return std::move(data);
 	}
 
 	/** \brief The function asyncReceive needs the address of \p data. */
@@ -109,7 +151,7 @@ class ReceiveRequest {
 	/** \brief MPI implementation. */
 	MPI_Request value;
 	/** \brief \p data to be received. */
-	std::unique_ptr<Type> dataPtr;
+	std::vector<to_contained_type_t<Type>> data;
 };
 
 
@@ -132,34 +174,87 @@ class Communicator {
 
 
 	/** \brief Regroups the \p data of every processes in a single vector and returns it. */
-	template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type = true>
+	template<typename Type,
+		typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type = true
+	>
 	std::vector<Type> allGather(Type data);
 
+	/** \brief Regroups the \p data of every processes in a single vector and returns it. */
+	template<class Collection,
+		typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type = true
+	>
+	std::vector<typename Collection::value_type> allGather(const Collection& data);
+
 	/** \brief Starts to receive data of type \p Type from the \p source. A \p tag can be required to be provided
   with the data. \p MPI_ANY_TAG can be used. Returns a ReceiveRequest object that can be used to find out if
   the data were received, or to wait until they are received and get them.*/
-	template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type = true>
+	template<typename Type,
+		typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type = true
+	>
 	ReceiveRequest<Type> asyncReceive(int source, int tag = 0);
 
+	/** \brief Starts to receive data of type \p Type from the \p source. A \p tag can be required to be provided
+  with the data. \p MPI_ANY_TAG can be used. Returns a ReceiveRequest object that can be used to find out if
+  the data were received, or to wait until they are received and get them.*/
+	template<class Collection,
+		typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type = true
+	>
+	ReceiveRequest<Collection> asyncReceive(int count, int source, int tag = 0);
+
 	/** \brief Starts to send \p data to the \p destination. A \p tag can be required to be provided with the data.
   \p MPI_ANY_TAG can be used. Returns a SendRequest object that can be used to find out if the data were sent, or
   to wait until they are sent.*/
-	template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type = true>
+	template<typename Type,
+		typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type = true
+	>
 	SendRequest asyncSend(Type data, int destination, int tag = 0);
 
+	/** \brief Starts to send \p data to the \p destination. A \p tag can be required to be provided with the data.
+  \p MPI_ANY_TAG can be used. Returns a SendRequest object that can be used to find out if the data were sent, or
+  to wait until they are sent.*/
+	template<class Collection,
+		typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type = true
+	>
+	SendRequest asyncSend(const Collection& data, int destination, int tag = 0);
+
 	/** \brief The \p source broadcast its \p data to every processes. */
-	template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type = true>
+	template<typename Type,
+		typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type = true
+	>
 	Type broadcast(int source, Type data);
 
+	/** \brief The \p source broadcast its \p data to every processes. */
+	template<class Collection,
+		typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type = true
+	>
+	Collection broadcast(int source, Collection data);
+
 	/** \brief The \p source gathers the \p data of every processes. */
-	template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type = true>
+	template<typename Type,
+		typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type = true
+	>
 	std::vector<Type> gather(int source, Type data);
 
+	/** \brief The \p source gathers the \p data of every processes. */
+	template<class Collection,
+		typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type = true
+	>
+	std::vector<typename Collection::value_type> gather(int source, const Collection& data);
+
 	/** \brief Wait to receive data of type \p Type from the \p source. A \p tag can be required to be provided with
   the data. \p MPI_ANY_TAG can be used.*/
-	template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type = true>
+	template<typename Type,
+		typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type = true
+	>
 	Type receiveAndBlock(int source, int tag = 0);
 
+	/** \brief Wait to receive data of type \p Type from the \p source. A \p tag can be required to be provided with
+  the data. \p MPI_ANY_TAG can be used.*/
+	template<class Collection,
+		typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type = true
+	>
+	Collection receiveAndBlock(int count, int source, int tag = 0);
+
 	/** \brief The \p source scatters \p sendCount of its data \p toSend to every processes. Hence, the process with
   rank \p i receives the data from \p toSend[i] to toSend[i+\p sendCount].*/
 	template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type = true>
@@ -167,9 +262,18 @@ class Communicator {
 
 	/** \brief Wait to send \p data to the \p destination. A \p tag can be required to be provided with
   the data. \p MPI_ANY_TAG can be used.*/
-	template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type = true>
+	template<typename Type,
+		typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type = true
+	>
 	void sendAndBlock(Type data, int destination, int tag = 0);
 
+	/** \brief Wait to send \p data to the \p destination. A \p tag can be required to be provided with
+  the data. \p MPI_ANY_TAG can be used.*/
+	template<class Collection,
+		typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type = true
+	>
+	void sendAndBlock(const Collection& data, int destination, int tag = 0);
+
 	/** \brief Regroups the \p data of every processes in a single vector and returns it. \p receiveCounts[i] data
   is received from the process with rank \p i. These data starts at the index \p displacements[i] of the
   returned vector.*/
@@ -217,6 +321,12 @@ class Communicator {
 	/** \brief Returns the \p displacements scaled by the size of \p Type.*/
 	template<typename Type>
 	static std::vector<int> createScaledDisplacements(std::vector<int> displacements);
+	/** \brief Initializes the collection with \p count elements. */
+	template<typename Type>
+	static std::vector<Type> initializeWithCount(std::vector<Type>, int count);
+	/** \brief Initializes the collection with \p count elements. */
+	template<typename Type, std::size_t N>
+	static std::array<Type,N> initializeWithCount(std::array<Type,N> a, int /*count*/);
 	/** \brief Returns the sum of the \p data. */
 	static int sum(const std::vector<int>& data);
 	/** \brief Implements \p varyingScatter(). */
diff --git a/include/NiceMPI/private/NiceMPI.hpp b/include/NiceMPI/private/NiceMPI.hpp
index 83eeb06..0aa3d14 100644
--- a/include/NiceMPI/private/NiceMPI.hpp
+++ b/include/NiceMPI/private/NiceMPI.hpp
@@ -54,7 +54,7 @@ inline Communicator Communicator::split(int color, int key) const {
 }
 
 
-template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type>
+template<typename Type, typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type>
 inline std::vector<Type> Communicator::allGather(Type data) {
 	std::vector<Type> result(size());
 	handleError(MPI_Allgather(&data,sizeof(Type),MPI_UNSIGNED_CHAR,result.data(),sizeof(Type),MPI_UNSIGNED_CHAR,
@@ -62,27 +62,69 @@ inline std::vector<Type> Communicator::allGather(Type data) {
 	return result;
 }
 
-template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type>
+template<class Collection,
+	typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type
+>
+inline std::vector<typename Collection::value_type> Communicator::allGather(const Collection& data) {
+	using Type = typename Collection::value_type;
+	std::vector<Type> result(size()*data.size());
+	handleError(MPI_Allgather(data.data(),sizeof(Type)*data.size(),MPI_UNSIGNED_CHAR,result.data(),
+		sizeof(Type)*data.size(),MPI_UNSIGNED_CHAR, handle.get() ));
+	return result;
+}
+
+template<typename Type, typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type>
 inline ReceiveRequest<Type> Communicator::asyncReceive(int source, int tag) {
-	ReceiveRequest<Type> r;
-	handleError(MPI_Irecv(r.dataPtr.get(),sizeof(Type),MPI_UNSIGNED_CHAR,source,tag,handle.get(),&r.value));
+	ReceiveRequest<Type> r(1);
+	handleError(MPI_Irecv(r.data.data(),sizeof(Type),MPI_UNSIGNED_CHAR,source,tag,handle.get(),&r.value));
 	return r;
 }
 
-template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type>
+template<class Collection,
+	typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type
+>
+inline ReceiveRequest<Collection> Communicator::asyncReceive(int count, int source, int tag) {
+	using Type = typename Collection::value_type;
+	ReceiveRequest<Collection> r(count);
+	handleError(MPI_Irecv(r.data.data(),sizeof(Type)*count,MPI_UNSIGNED_CHAR,source,tag,handle.get(),&r.value));
+	return r;
+}
+
+template<typename Type, typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type>
 inline SendRequest Communicator::asyncSend(Type data, int destination, int tag) {
 	MPI_Request x;
 	handleError(MPI_Isend(&data,sizeof(Type),MPI_UNSIGNED_CHAR,destination,tag,handle.get(),&x));
 	return SendRequest(x);
 }
 
-template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type>
+template<class Collection,
+	typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type
+>
+inline SendRequest Communicator::asyncSend(const Collection& data, int destination, int tag) {
+	using Type = typename Collection::value_type;
+	MPI_Request x;
+	handleError(MPI_Isend(data.data(),sizeof(Type)*data.size(),MPI_UNSIGNED_CHAR,destination,tag,handle.get(),&x));
+	return SendRequest(x);
+}
+
+template<typename Type, typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type>
 inline Type Communicator::broadcast(int source, Type data) {
 	handleError(MPI_Bcast(&data,sizeof(Type),MPI_UNSIGNED_CHAR,source,handle.get() ));
 	return data;
 }
 
-template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type>
+template<class Collection,
+	typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type
+>
+inline Collection Communicator::broadcast(int source, Collection data) {
+	using Type = typename Collection::value_type;
+	auto sizeToBroadcast = broadcast(source,data.size());
+	if(rank() != source) data = initializeWithCount(Collection{},sizeToBroadcast);
+	handleError(MPI_Bcast(data.data(),sizeof(Type)*sizeToBroadcast,MPI_UNSIGNED_CHAR,source,handle.get() ));
+	return data;
+}
+
+template<typename Type, typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type>
 inline std::vector<Type> Communicator::gather(int source, Type data) {
 	std::vector<Type> result;
 	if(rank() == source) result.resize(size());
@@ -91,13 +133,35 @@ inline std::vector<Type> Communicator::gather(int source, Type data) {
 	return result;
 }
 
-template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type>
+template<class Collection,
+	typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type
+>
+std::vector<typename Collection::value_type> Communicator::gather(int source, const Collection& data) {
+	using Type = typename Collection::value_type;
+	std::vector<Type> result;
+	if(rank() == source) result.resize(size()*data.size());
+	handleError(MPI_Gather(data.data(),sizeof(Type)*data.size(),MPI_UNSIGNED_CHAR,result.data(),
+		sizeof(Type)*data.size(),MPI_UNSIGNED_CHAR,source,handle.get() ));
+	return result;
+}
+
+template<typename Type, typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type>
 inline Type Communicator::receiveAndBlock(int source, int tag) {
 	Type data;
 	handleError(MPI_Recv(&data,sizeof(Type),MPI_UNSIGNED_CHAR,source,tag,handle.get() ,MPI_STATUS_IGNORE));
 	return data;
 }
 
+template<class Collection,
+	typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type
+>
+Collection Communicator::receiveAndBlock(int count, int source, int tag) {
+	Collection data = initializeWithCount(Collection{},count);
+	using Type = typename Collection::value_type;
+	handleError(MPI_Recv(data.data(),sizeof(Type)*count,MPI_UNSIGNED_CHAR,source,tag,handle.get() ,MPI_STATUS_IGNORE));
+	return data;
+}
+
 template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type>
 inline std::vector<Type> Communicator::scatter(int source, const std::vector<Type>& toSend, int sendCount) {
 	const bool enoughDataToSend = (static_cast<int>(toSend.size()) - sendCount*size()) >= 0;
@@ -108,11 +172,19 @@ inline std::vector<Type> Communicator::scatter(int source, const std::vector<Typ
 	return result;
 }
 
-template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type>
+template<typename Type, typename std::enable_if<std::is_pod<Type>::value and !is_std_array<Type>::value,bool>::type>
 inline void Communicator::sendAndBlock(Type data, int destination, int tag) {
 	handleError(MPI_Send(&data,sizeof(Type),MPI_UNSIGNED_CHAR,destination,tag,handle.get() ));
 }
 
+template<class Collection,
+	typename std::enable_if<std::is_pod<typename Collection::value_type>::value,bool>::type
+>
+inline void Communicator::sendAndBlock(const Collection& data, int destination, int tag) {
+	using Type = typename Collection::value_type;
+	handleError(MPI_Send(data.data(),sizeof(Type)*data.size(),MPI_UNSIGNED_CHAR,destination,tag,handle.get() ));
+}
+
 template<typename Type, typename std::enable_if<std::is_pod<Type>::value,bool>::type>
 inline std::vector<Type> Communicator::varyingAllGather(const std::vector<Type>& data,
 	const std::vector<int>& receiveCounts, const std::vector<int>& displacements)
@@ -187,6 +259,15 @@ inline std::vector<int> Communicator::createScaledDisplacements(std::vector<int>
 	return displacements;
 }
 
+template<typename Type>
+inline std::vector<Type> Communicator::initializeWithCount(std::vector<Type>, int count) {
+	return std::vector<Type>(count);
+}
+template<typename Type, std::size_t N>
+inline std::array<Type,N> Communicator::initializeWithCount(std::array<Type,N> a, int /*count*/) {
+	return a;
+}
+
 inline int Communicator::sum(const std::vector<int>& data) {
 	int theSum = 0;
 	for(auto&& x: data) theSum += x;
diff --git a/src/NiceMPI_tests.cpp b/src/NiceMPI_tests.cpp
index 3b72e73..db52d9c 100644
--- a/src/NiceMPI_tests.cpp
+++ b/src/NiceMPI_tests.cpp
@@ -54,12 +54,7 @@ class NiceMPItests : public ::testing::Test {
 		result.theInt = rank*2;
 		return result;
 	}
-	void expectNear(const PODtype& expected, const PODtype& actual, double tolerance) {
-		EXPECT_EQ(expected.theInt, actual.theInt);
-		EXPECT_NEAR(expected.theDouble, actual.theDouble, tolerance);
-		EXPECT_EQ(expected.theChar, actual.theChar);
-	}
-	void testGather(const std::vector<PODtype>& gathered) {
+	void expectGathered(const std::vector<PODtype>& gathered) {
 		ASSERT_EQ(mpiWorld().size(),gathered.size());
 		for(int i=0; i<mpiWorld().size(); ++i) {
 			PODtype expected{podTypeInstance};
@@ -67,6 +62,77 @@ class NiceMPItests : public ::testing::Test {
 			expectNear(expected,gathered[i],defaultTolerance);
 		}
 	}
+	void expectGatheredCollection(const std::vector<PODtype>& gathered, const int sizeByProcess) {
+		ASSERT_EQ(mpiWorld().size()*sizeByProcess,gathered.size());
+		for(int i=0; i<mpiWorld().size(); ++i) {
+			PODtype expected{podTypeInstance};
+			expected.theInt = 2*i;
+			expectNear(expected,gathered[sizeByProcess*i],defaultTolerance);
+			expectNear(expected,gathered[sizeByProcess*i+1],defaultTolerance);
+		}
+	}
+	void expectNear(const PODtype& expected, const PODtype& actual, double tolerance) {
+		EXPECT_EQ(expected.theInt, actual.theInt);
+		EXPECT_NEAR(expected.theDouble, actual.theDouble, tolerance);
+		EXPECT_EQ(expected.theChar, actual.theChar);
+	}
+	template<class CollectionType>
+	void testAsyncSendAndReceiveCollection() {
+		if(sourceIndex == destinationIndex) return;
+		CollectionType toSend;
+		const int count = 2;
+		if(mpiWorld().rank() == sourceIndex) {
+			toSend = {{ podTypeInstance, podTypeInstance }};
+			SendRequest r = mpiWorld().asyncSend(toSend,destinationIndex);
+			r.wait();
+		}
+		if(mpiWorld().rank() == destinationIndex) {
+			ReceiveRequest<CollectionType> r = mpiWorld().asyncReceive<CollectionType>(count,sourceIndex);
+			r.wait();
+			std::vector<PODtype> data = r.take();
+			EXPECT_EQ(count,data.size());
+			for(auto&& x: data) expectNear(podTypeInstance, x, defaultTolerance);
+		}
+	}
+	template<class CollectionType>
+	void testBroadcastCollection() {
+		CollectionType data;
+		if(mpiWorld().rank() == sourceIndex) data = {{ podTypeInstance, podTypeInstance }};
+		const CollectionType results = mpiWorld().broadcast(sourceIndex, data);
+		EXPECT_EQ(2,results.size());
+		for(auto&& x: results) expectNear(podTypeInstance, x, defaultTolerance);
+	}
+	template<class CollectionType>
+	void testAllGather() {
+		PODtype x = createPODtypeForRank(mpiWorld().rank());
+		const int sizeByProcess = 2;
+		const CollectionType toSend = {{ x, x }};
+		const std::vector<PODtype> gathered = mpiWorld().allGather(toSend);
+		expectGatheredCollection(gathered,sizeByProcess);
+	}
+	template<class CollectionType>
+	void testGather() {
+		PODtype x = createPODtypeForRank(mpiWorld().rank());
+		const int sizeByProcess = 2;
+		const CollectionType toSend = {{ x, x }};
+		const std::vector<PODtype> gathered = mpiWorld().gather(sourceIndex, toSend );
+		if(mpiWorld().rank()==sourceIndex) expectGatheredCollection(gathered,sizeByProcess);
+		else EXPECT_EQ(0,gathered.size());
+	}
+	template<class CollectionType>
+	void testSendAndReceiveCollection() {
+		if(sourceIndex == destinationIndex) return;
+		if(mpiWorld().rank() == sourceIndex) {
+			const CollectionType toSend = {{ podTypeInstance, podTypeInstance }};
+			mpiWorld().sendAndBlock(toSend,destinationIndex);
+		}
+		if(mpiWorld().rank() == destinationIndex) {
+			const int count = 2;
+			const CollectionType results = mpiWorld().receiveAndBlock<CollectionType>(count,sourceIndex);
+			EXPECT_EQ(count,results.size());
+			for(auto&& x: results) expectNear(podTypeInstance, x, defaultTolerance);
+		}
+	}
 
 	const Communicator world;
 	const int sourceIndex = 0;
@@ -194,12 +260,12 @@ TEST_F(NiceMPItests, scatterTwoWithSpare) {
 }
 TEST_F(NiceMPItests, gather) {
 	const std::vector<PODtype> gathered = mpiWorld().gather(sourceIndex, createPODtypeForRank(mpiWorld().rank()) );
-	if(mpiWorld().rank()==sourceIndex) testGather(gathered);
+	if(mpiWorld().rank()==sourceIndex) expectGathered(gathered);
 	else EXPECT_EQ(0,gathered.size());
 }
 TEST_F(NiceMPItests, allGather) {
 	const PODtype myData = createPODtypeForRank(mpiWorld().rank());
-	testGather(mpiWorld().allGather(myData));
+	expectGathered(mpiWorld().allGather(myData));
 }
 
 
@@ -242,7 +308,7 @@ TEST_F(NiceMPItests, varyingGatherOneFromEach) {
 	const std::vector<PODtype> data = { createPODtypeForRank(mpiWorld().rank()) };
 	const std::vector<int> receiveCounts(mpiWorld().size(),1);
 	const std::vector<PODtype> gathered = mpiWorld().varyingGather(sourceIndex,data,receiveCounts);
-	if(mpiWorld().rank()==sourceIndex) testGather(gathered);
+	if(mpiWorld().rank()==sourceIndex) expectGathered(gathered);
 	else EXPECT_EQ(0,gathered.size());
 }
 TEST_F(NiceMPItests, varyingGatherWithDisplacements) {
@@ -273,7 +339,7 @@ TEST_F(NiceMPItests, varyingAllGatherOneFromEach) {
 	const std::vector<PODtype> data = { createPODtypeForRank(mpiWorld().rank()) };
 	const std::vector<int> receiveCounts(mpiWorld().size(),1);
 	const std::vector<PODtype> gathered = mpiWorld().varyingAllGather(data,receiveCounts);
-	testGather(gathered);
+	expectGathered(gathered);
 }
 TEST_F(NiceMPItests, varyingAllGatherWithDisplacements) {
 	std::vector<PODtype> data;
@@ -318,8 +384,9 @@ TEST_F(NiceMPItests, asyncSendAndReceiveAndWait) {
 	if(mpiWorld().rank() == destinationIndex) {
 		ReceiveRequest<PODtype> r = mpiWorld().asyncReceive<PODtype>(sourceIndex);
 		r.wait();
-		std::unique_ptr<PODtype> data = r.take();
-		expectNear(podTypeInstance, *data, defaultTolerance);
+		std::vector<PODtype> data = r.take();
+		ASSERT_EQ(1,data.size());
+		expectNear(podTypeInstance, data[0], defaultTolerance);
 	}
 }
 TEST_F(NiceMPItests, asyncSendAndReceiveWithTag) {
@@ -332,8 +399,9 @@ TEST_F(NiceMPItests, asyncSendAndReceiveWithTag) {
 	if(mpiWorld().rank() == destinationIndex) {
 		ReceiveRequest<PODtype> r = mpiWorld().asyncReceive<PODtype>(sourceIndex,MPI_ANY_TAG);
 		r.wait();
-		std::unique_ptr<PODtype> data = r.take();
-		expectNear(podTypeInstance, *data, defaultTolerance);
+		std::vector<PODtype> data = r.take();
+		ASSERT_EQ(1,data.size());
+		expectNear(podTypeInstance, data[0], defaultTolerance);
 	}
 }
 TEST_F(NiceMPItests, asyncSendAndReceiveAndTest) {
@@ -345,7 +413,40 @@ TEST_F(NiceMPItests, asyncSendAndReceiveAndTest) {
 	if(mpiWorld().rank() == destinationIndex) {
 		ReceiveRequest<PODtype> r = mpiWorld().asyncReceive<PODtype>(sourceIndex);
 		while(!r.isCompleted()) std::this_thread::sleep_for(std::chrono::microseconds{});
-		std::unique_ptr<PODtype> data = r.take();
-		expectNear(podTypeInstance, *data, defaultTolerance);
+		std::vector<PODtype> data = r.take();
+		ASSERT_EQ(1,data.size());
+		expectNear(podTypeInstance, data[0], defaultTolerance);
 	}
 }
+
+
+TEST_F(NiceMPItests, sendAndReceiveAnythingVector) {
+	testSendAndReceiveCollection<std::vector<PODtype>>();
+}
+TEST_F(NiceMPItests, sendAndReceiveAnythingArray) {
+	testSendAndReceiveCollection<std::array<PODtype,2>>();
+}
+TEST_F(NiceMPItests, broadcastVector) {
+	testBroadcastCollection<std::vector<PODtype>>();
+}
+TEST_F(NiceMPItests, broadcastArray) {
+	testBroadcastCollection<std::array<PODtype,2>>();
+}
+TEST_F(NiceMPItests, gatherVector) {
+	testGather<std::vector<PODtype>>();
+}
+TEST_F(NiceMPItests, gatherArray) {
+	testGather<std::array<PODtype,2>>();
+}
+TEST_F(NiceMPItests, allGatherVector) {
+	testAllGather<std::vector<PODtype>>();
+}
+TEST_F(NiceMPItests, allGatherArray) {
+	testAllGather<std::array<PODtype,2>>();
+}
+TEST_F(NiceMPItests, asyncSendAndReceiveAndWaitVector) {
+	testAsyncSendAndReceiveCollection<std::vector<PODtype>>();
+}
+TEST_F(NiceMPItests, asyncSendAndReceiveAndWaitArray) {
+	testAsyncSendAndReceiveCollection<std::array<PODtype,2>>();
+}