1 files changed, 0 insertions, 192 deletions
diff --git a/test/source/ConceptImpls.h b/test/source/ConceptImpls.h
deleted file mode 100644
index e6c20ef..0000000
--- a/test/source/ConceptImpls.h
+++ /dev/null
@@ -1,192 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Copyright (c) Electronic Arts Inc. All rights reserved.
-/////////////////////////////////////////////////////////////////////////////
-
-#ifndef CONCEPTSIMPLS_H
-#define CONCEPTSIMPLS_H
-
-#include <EASTL/type_traits.h>
-
-#if !defined(EA_COMPILER_NO_DEFAULTED_FUNCTIONS) && !defined(EA_COMPILER_NO_DELETED_FUNCTIONS)
-
-#define EASTL_TEST_CONCEPT_IMPLS
-
-// This header provides a variety of helper classes that have interfaces corresponding to the concepts used to specify
-// requirements of many STL containers and algorithms. These helper classes are used in tests to verify that containers
-// and algorithms do not impose stricter requirements than specified by the standard on their arguments.
-
-// Destructible - only valid operation on this class is to destroy it.
-
-class Destructible
-{
-public:
-	~Destructible() = default;
-
-	Destructible() = delete;
-	Destructible(const Destructible&) = delete;
-	Destructible(Destructible&&) = delete;
-	Destructible& operator=(const Destructible&) = delete;
-	Destructible& operator=(Destructible&&) = delete;
-};
-
-// Unfortunately not all compilers handle type_traits reliably correctly currently so we can't straightforwardly
-// static_assert everything that should be true of this class
-static_assert(eastl::is_destructible<Destructible>::value, "eastl::is_destructible<Destructible>::value");
-// static_assert(!eastl::is_default_constructible<Destructible>::value,
-// "!eastl::is_default_constructible<Destructible>::value");
-// static_assert(!is_copy_constructible<Destructible>::value, "!eastl::is_copy_constructible<Destructible>::value");
-static_assert(!eastl::is_copy_assignable<Destructible>::value, "!eastl::is_copy_assignable<Destructible>::value");
-// static_assert(!eastl::is_move_constructible<Destructible>::value,
-// "!eastl::is_move_constructible<Destructible>::value");
-static_assert(!eastl::is_move_assignable<Destructible>::value, "!eastl::is_move_assignable<Destructible>::value");
-
-class DefaultConstructible
-{
-public:
-	static const int defaultValue = 42;
-
-	DefaultConstructible() : value(defaultValue) {}
-	~DefaultConstructible() = default;
-
-	DefaultConstructible(const DefaultConstructible&) = delete;
-	DefaultConstructible(DefaultConstructible&&) = delete;
-	DefaultConstructible& operator=(const DefaultConstructible&) = delete;
-	DefaultConstructible& operator=(DefaultConstructible&&) = delete;
-
-	const int value;
-};
-
-
-struct NotDefaultConstructible
-{
-	NotDefaultConstructible() = delete;
-};
-static_assert(!eastl::is_default_constructible<NotDefaultConstructible>::value, "'NotDefaultConstructible' is default constructible.");
-
-
-class CopyConstructible
-{
-public:
-	static const int defaultValue = 42;
-	static CopyConstructible Create()
-	{
-		CopyConstructible x;
-		return x;
-	}
-
-	CopyConstructible(const CopyConstructible&) = default;
-	~CopyConstructible() = default;
-
-	CopyConstructible& operator=(const CopyConstructible&) = delete;
-	CopyConstructible& operator=(CopyConstructible&&) = delete;
-
-	const int value;
-
-private:
-	CopyConstructible() : value(defaultValue) {}
-};
-
-// Unfortunately not all compilers handle type_traits reliably correctly currently so we can't straightforwardly
-// static_assert everything that should be true of this class
-static_assert(eastl::is_destructible<CopyConstructible>::value, "eastl::is_destructible<CopyConstructible>::value");
-// static_assert(!eastl::is_default_constructible<CopyConstructible>::value,
-// "!eastl::is_default_constructible<CopyConstructible>::value");
-// static_assert(is_copy_constructible<CopyConstructible>::value, "is_copy_constructible<CopyConstructible>::value");
-static_assert(eastl::is_copy_constructible<CopyConstructible>::value,
-			  "eastl::is_copy_constructible<CopyConstructible>::value");
-static_assert(!eastl::is_copy_assignable<CopyConstructible>::value,
-			  "!eastl::is_copy_assignable<CopyConstructible>::value");
-// static_assert(!eastl::is_move_constructible<CopyConstructible>::value,
-// "!eastl::is_move_constructible<CopyConstructible>::value");
-static_assert(!eastl::is_move_assignable<CopyConstructible>::value,
-			  "!eastl::is_move_assignable<CopyConstructible>::value");
-
-class MoveConstructible
-{
-public:
-	static const int defaultValue = 42;
-	static MoveConstructible Create()
-	{
-		return MoveConstructible{};
-	}
-
-	MoveConstructible(MoveConstructible&& x) : value(x.value) {}
-	~MoveConstructible() = default;
-
-	MoveConstructible(const MoveConstructible&) = delete;
-	MoveConstructible& operator=(const MoveConstructible&) = delete;
-	MoveConstructible& operator=(MoveConstructible&&) = delete;
-
-	const int value;
-
-private:
-	MoveConstructible() : value(defaultValue) {}
-};
-
-class MoveAssignable
-{
-public:
-	static const int defaultValue = 42;
-	static MoveAssignable Create()
-	{
-		return MoveAssignable{};
-	}
-
-	MoveAssignable(MoveAssignable&& x) : value(x.value) {}
-	MoveAssignable& operator=(MoveAssignable&& x)
-	{
-		value = x.value;
-		return *this;
-	}
-	~MoveAssignable() = default;
-
-	MoveAssignable(const MoveAssignable&) = delete;
-	MoveAssignable& operator=(const MoveAssignable&) = delete;
-
-	int value;
-
-private:
-	MoveAssignable() : value(defaultValue) {}
-};
-
-struct MoveAndDefaultConstructible
-{
-	static const int defaultValue = 42;
-
-	MoveAndDefaultConstructible() : value(defaultValue) {}
-	MoveAndDefaultConstructible(MoveAndDefaultConstructible&& x) : value(x.value) {}
-	~MoveAndDefaultConstructible() = default;
-
-	MoveAndDefaultConstructible(const MoveAndDefaultConstructible&) = delete;
-	MoveAndDefaultConstructible& operator=(const MoveAndDefaultConstructible&) = delete;
-	MoveAndDefaultConstructible& operator=(MoveAndDefaultConstructible&&) = delete;
-
-	const int value;
-};
-
-struct MissingMoveConstructor
-{
-	MissingMoveConstructor() {}
-	MissingMoveConstructor(const MissingMoveConstructor&) {}
-	MissingMoveConstructor& operator=(MissingMoveConstructor&&) { return *this; }
-	MissingMoveConstructor& operator=(const MissingMoveConstructor&) { return *this; }
-	bool operator<(const MissingMoveConstructor&) const { return true; }
-};
-
-struct MissingMoveAssignable
-{
-	MissingMoveAssignable() {}
-	MissingMoveAssignable(const MissingMoveAssignable&) {}
-	MissingMoveAssignable(MissingMoveAssignable&&) {}
-	MissingMoveAssignable& operator=(const MissingMoveAssignable&) { return *this; }
-	bool operator<(const MissingMoveAssignable&) const { return true; }
-};
-
-struct MissingEquality
-{
-	MissingEquality& operator==(const MissingEquality&) = delete;
-};
-
-#endif  // !defined(EA_COMPILER_NO_DEFAULTED_FUNCTIONS) && !defined(EA_COMPILER_NO_DELETED_FUNCTIONS)
-
-#endif  // CONCEPTSIMPLS_H