diff --git a/include/EASTL/chrono.h b/include/EASTL/chrono.h
index e67df1e6..028c0f49 100644
--- a/include/EASTL/chrono.h
+++ b/include/EASTL/chrono.h
@@ -47,7 +47,7 @@
 
 #if defined(EA_PLATFORM_MICROSOFT) && !defined(EA_PLATFORM_MINGW)
 	#include <thr/xtimec.h>
-#elif defined(EA_PLATFORM_PS4)
+#elif defined(EA_PLATFORM_SONY)
 	#include <Dinkum/threads/xtimec.h>
 	#include <kernel.h>
 #elif defined(EA_PLATFORM_APPLE)
@@ -544,7 +544,7 @@ namespace chrono
 	{
 		#if defined(EA_PLATFORM_MICROSOFT) && !defined(EA_PLATFORM_MINGW)
 			#define EASTL_NS_PER_TICK 1 
-		#elif defined EA_PLATFORM_PS4
+		#elif defined EA_PLATFORM_SONY
 			#define EASTL_NS_PER_TICK _XTIME_NSECS_PER_TICK
 		#elif defined EA_PLATFORM_POSIX
 			#define EASTL_NS_PER_TICK _XTIME_NSECS_PER_TICK
@@ -585,7 +585,7 @@ namespace chrono
 			static auto frequency = queryFrequency(); // cache cpu frequency on first call
 			EA_RESTORE_VC_WARNING()
 			return uint64_t(frequency * queryCounter());
-        #elif defined EA_PLATFORM_PS4
+        #elif defined EA_PLATFORM_SONY
 			return sceKernelGetProcessTimeCounter();
 		#elif defined(EA_PLATFORM_APPLE)
 		   return mach_absolute_time();
diff --git a/include/EASTL/internal/config.h b/include/EASTL/internal/config.h
index 79e1a1bc..6f6b9e83 100644
--- a/include/EASTL/internal/config.h
+++ b/include/EASTL/internal/config.h
@@ -89,8 +89,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef EASTL_VERSION
-	#define EASTL_VERSION   "3.13.03"
-	#define EASTL_VERSION_N  31303
+	#define EASTL_VERSION   "3.13.04"
+	#define EASTL_VERSION_N  31304
 #endif
 
 
diff --git a/include/EASTL/internal/functional_base.h b/include/EASTL/internal/functional_base.h
index a3d19af4..669e5fc3 100644
--- a/include/EASTL/internal/functional_base.h
+++ b/include/EASTL/internal/functional_base.h
@@ -19,8 +19,8 @@ namespace eastl
 {
 	// foward declaration for swap
 	template <typename T>
-	inline void swap(T& a, T& b) EA_NOEXCEPT_IF(eastl::is_nothrow_move_constructible<T>::value &&
-	eastl::is_nothrow_move_assignable<T>::value);
+	inline void swap(T& a, T& b)
+	    EA_NOEXCEPT_IF(eastl::is_nothrow_move_constructible<T>::value&& eastl::is_nothrow_move_assignable<T>::value);
 
 
 	/// invoke
@@ -40,10 +40,8 @@ namespace eastl
 	///
 	template <typename R, typename C, typename T, typename... Args>
 	auto invoke_impl(R C::*func, T&& obj, Args&&... args) ->
-	typename enable_if<
-		is_base_of<C, decay_t<decltype(obj)>>::value,
-		decltype((eastl::forward<T>(obj).*func)(eastl::forward<Args>(args)...))
-	>::type
+	    typename enable_if<is_base_of<C, decay_t<decltype(obj)>>::value,
+	                       decltype((eastl::forward<T>(obj).*func)(eastl::forward<Args>(args)...))>::type
 	{
 		return (eastl::forward<T>(obj).*func)(eastl::forward<Args>(args)...);
 	}
diff --git a/include/EASTL/internal/type_compound.h b/include/EASTL/internal/type_compound.h
index fddf72f3..178a7342 100644
--- a/include/EASTL/internal/type_compound.h
+++ b/include/EASTL/internal/type_compound.h
@@ -54,6 +54,11 @@ namespace eastl
 	template<typename T, unsigned N = 0> // extent uses unsigned instead of size_t.
 	struct extent : public eastl::extent_help<T, N> { };
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template<typename T, unsigned N = 0> 
+		EA_CONSTEXPR auto extent_v = extent<T, N>::value;
+	#endif
+
 
 	///////////////////////////////////////////////////////////////////////
 	// is_array
@@ -324,13 +329,25 @@ namespace eastl
 
 	#endif
 
-
 	#if !defined(EA_COMPILER_NO_TEMPLATE_ALIASES)
 		template<typename From, typename To>
 		EA_CONSTEXPR bool is_convertible_v = is_convertible<From, To>::value;
 	#endif
 
 
+	///////////////////////////////////////////////////////////////////////
+	// is_nothrow_convertible
+	// 
+	// https://en.cppreference.com/w/cpp/types/is_convertible
+	//
+	// template<typename From, typename To>
+	// struct is_explicitly_convertible
+	//     : public is_constructible<To, From> {};
+	///////////////////////////////////////////////////////////////////////
+	// TODO(rparolin):  implement type-trait
+
+
+
 	///////////////////////////////////////////////////////////////////////
 	// is_explicitly_convertible
 	// 
@@ -367,6 +384,10 @@ namespace eastl
 
 	#define EASTL_DECLARE_UNION(T) namespace eastl{ template <> struct is_union<T> : public true_type{}; template <> struct is_union<const T> : public true_type{}; }
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template<typename T>
+		EA_CONSTEXPR bool is_union_v = is_union<T>::value;
+	#endif
 
 
 
@@ -724,7 +745,7 @@ namespace eastl
 		template <typename T>
 		struct is_final : public integral_constant<bool, __is_final(T)> {};
 	#else
-		// compiler support so we always return false
+		// no compiler support so we always return false
 		template <typename T>
 		struct is_final : public false_type {};
 	#endif
@@ -733,6 +754,42 @@ namespace eastl
 		template<typename T>
 		EA_CONSTEXPR bool is_final_v = is_final<T>::value;
 	#endif
+
+
+	///////////////////////////////////////////////////////////////////////
+	// is_aggregate
+	//
+	// https://en.cppreference.com/w/cpp/language/aggregate_initialization
+	//
+	// An aggregate is one of the following types:
+	// * array type
+	// * class type (typically, struct or union), that has
+	//     * no private or protected non-static data members
+	//     * no user-provided constructors (explicitly defaulted or deleted constructors are allowed)
+	//     * no user-provided, inherited, or explicit constructors 
+	//         * (explicitly defaulted or deleted constructors are allowed)
+	//     * no virtual, private, or protected (since C++17) base classes
+	//     * no virtual member functions
+	//     * no default member initializers
+	//
+	///////////////////////////////////////////////////////////////////////
+	#if EA_COMPILER_HAS_FEATURE(is_aggregate) || defined(_MSC_VER) && (_MSC_VER >= 1916)  // VS2017 15.9+
+		#define EASTL_TYPE_TRAIT_is_aggregate_CONFORMANCE 1  
+
+		template <typename T>
+		struct is_aggregate : public integral_constant<bool, __is_aggregate(T)> {};
+	#else
+		#define EASTL_TYPE_TRAIT_is_aggregate_CONFORMANCE 0 
+
+		// no compiler support so we always return false
+		template <typename T>
+		struct is_aggregate : public false_type {};
+	#endif
+
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <typename T>
+		EA_CONSTEXPR bool is_aggregate_v = is_aggregate<T>::value;
+	#endif
 } // namespace eastl
 
 
diff --git a/include/EASTL/internal/type_fundamental.h b/include/EASTL/internal/type_fundamental.h
index b0536fe4..a90cb445 100644
--- a/include/EASTL/internal/type_fundamental.h
+++ b/include/EASTL/internal/type_fundamental.h
@@ -208,6 +208,11 @@ namespace eastl
 	struct is_arithmetic 
 		: public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template<typename T>
+		EA_CONSTEXPR bool is_arithmetic_v = is_arithmetic<T>::value;
+	#endif
+
 
 	///////////////////////////////////////////////////////////////////////
 	// is_fundamental
@@ -225,6 +230,11 @@ namespace eastl
 	struct is_fundamental
 		: public bool_constant<is_void_v<T> || is_integral_v<T> || is_floating_point_v<T> || is_null_pointer_v<T>> {};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template<typename T>
+		EA_CONSTEXPR bool is_fundamental_v = is_fundamental<T>::value;
+	#endif
+
 
 	///////////////////////////////////////////////////////////////////////
 	// is_hat_type
@@ -243,6 +253,11 @@ namespace eastl
 	template <typename T>
 	struct is_hat_type : public eastl::is_hat_type_helper<T> {};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template<typename T>
+		EA_CONSTEXPR bool is_hat_type_v = is_hat_type<T>::value;
+	#endif
+
 } // namespace eastl
 
 
diff --git a/include/EASTL/internal/type_pod.h b/include/EASTL/internal/type_pod.h
index f000e527..8726a7e6 100644
--- a/include/EASTL/internal/type_pod.h
+++ b/include/EASTL/internal/type_pod.h
@@ -140,6 +140,11 @@ namespace eastl
 		struct is_standard_layout : public eastl::integral_constant<bool, is_void<T>::value || is_scalar<T>::value>{};
 	#endif
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		EA_CONSTEXPR bool is_standard_layout_v = is_standard_layout<T>::value;
+    #endif
+
 	#define EASTL_DECLARE_IS_STANDARD_LAYOUT(T, isStandardLayout)                                                    \
 		namespace eastl {                                                                                            \
 			template <> struct is_standard_layout<T>                : public eastl::integral_constant<bool, isStandardLayout>  { }; \
@@ -536,6 +541,11 @@ namespace eastl
 		struct has_virtual_destructor : public eastl::false_type{};
 	#endif
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		EA_CONSTEXPR bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
+    #endif
+
 	#define EASTL_DECLARE_HAS_VIRTUAL_DESTRUCTOR(T, hasVirtualDestructor)                                                                   \
 		namespace eastl {                                                                                                                   \
 			template <> struct has_virtual_destructor<T>                : public eastl::integral_constant<bool, hasVirtualDestructor>  { }; \
@@ -1145,6 +1155,13 @@ namespace eastl
 
 
 
+	///////////////////////////////////////////////////////////////////////
+	// is_nothrow_default_constructible
+	///////////////////////////////////////////////////////////////////////
+	// TODO(rparolin):  implement type-trait
+
+
+
 	///////////////////////////////////////////////////////////////////////
 	// is_copy_constructible
 	//
@@ -1512,11 +1529,10 @@ namespace eastl
 			template <> struct is_nothrow_assignable<const volatile T> : public eastl::integral_constant<bool, isNothrowAssignable>  { }; \
 		}
 
-
 	#if EASTL_VARIABLE_TEMPLATES_ENABLED
 		template <class T, class U>
 		EA_CONSTEXPR bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
-    #endif
+	#endif
 
 
 
@@ -1641,6 +1657,10 @@ namespace eastl
 		: public eastl::is_trivially_assignable<typename eastl::add_lvalue_reference<T>::type,
 												typename eastl::add_rvalue_reference<T>::type> {};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		EA_CONSTEXPR bool is_trivially_move_assignable_v = is_trivially_move_assignable<T>::value;
+	#endif
 
 
 	///////////////////////////////////////////////////////////////////////
@@ -1880,6 +1900,11 @@ namespace eastl
 			template <> struct is_nothrow_destructible<const volatile T> { static const bool value = isNoThrowDestructible; }; \
 		}
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		EA_CONSTEXPR bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
+	#endif
+
 
 
 	///////////////////////////////////////////////////////////////////////
@@ -1892,6 +1917,10 @@ namespace eastl
 	struct is_nothrow_default_constructible
 		: public eastl::is_nothrow_constructible<T> {};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		EA_CONSTEXPR bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<T>::value;
+	#endif
 
 
 	///////////////////////////////////////////////////////////////////////
diff --git a/include/EASTL/internal/type_properties.h b/include/EASTL/internal/type_properties.h
index 4b59dd87..5276f878 100644
--- a/include/EASTL/internal/type_properties.h
+++ b/include/EASTL/internal/type_properties.h
@@ -127,6 +127,10 @@ namespace eastl
 	template <typename T>
 	struct is_signed : public eastl::is_signed_helper<typename eastl::remove_cv<T>::type>{};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		EA_CONSTEXPR bool is_signed_v = is_signed<T>::value;
+	#endif
 
 	#define EASTL_DECLARE_SIGNED(T)                                             \
 	namespace eastl{                                                            \
@@ -177,6 +181,11 @@ namespace eastl
 	template <typename T>
 	struct is_unsigned : public eastl::is_unsigned_helper<typename eastl::remove_cv<T>::type>{};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		EA_CONSTEXPR bool is_unsigned_v = is_unsigned<T>::value;
+	#endif
+
 	#define EASTL_DECLARE_UNSIGNED(T)                                             \
 	namespace eastl{                                                              \
 		template <> struct is_unsigned<T>                : public true_type{};    \
@@ -255,6 +264,11 @@ namespace eastl
 	template<typename T, size_t N>
 	struct rank<T[N]> : public eastl::integral_constant<size_t, rank<T>::value + 1> {};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		EA_CONSTEXPR auto rank_v = rank<T>::value;
+	#endif
+
 
 	///////////////////////////////////////////////////////////////////////
 	// is_base_of
@@ -295,21 +309,25 @@ namespace eastl
 	template<typename T> struct is_lvalue_reference     : public eastl::false_type {};
 	template<typename T> struct is_lvalue_reference<T&> : public eastl::true_type {};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template<typename T>
+		EA_CONSTEXPR bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
+	#endif
+
 
 	///////////////////////////////////////////////////////////////////////
 	// is_rvalue_reference
 	//
 	///////////////////////////////////////////////////////////////////////
 
-	#if EASTL_NO_RVALUE_REFERENCES
-		#define EASTL_TYPE_TRAIT_is_rvalue_reference_CONFORMANCE 0    // Given that the compiler doesn't support rvalue references, maybe the conformance here should be 1, since the result of this is always correct.
+	#define EASTL_TYPE_TRAIT_is_rvalue_reference_CONFORMANCE 1    // is_rvalue_reference is conforming.
 
-		template <typename T> struct is_rvalue_reference      : public eastl::false_type {};
-	#else
-		#define EASTL_TYPE_TRAIT_is_rvalue_reference_CONFORMANCE 1    // is_rvalue_reference is conforming.
+	template <typename T> struct is_rvalue_reference      : public eastl::false_type {};
+	template <typename T> struct is_rvalue_reference<T&&> : public eastl::true_type {};
 
-		template <typename T> struct is_rvalue_reference      : public eastl::false_type {};
-		template <typename T> struct is_rvalue_reference<T&&> : public eastl::true_type {};
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template<typename T>
+		EA_CONSTEXPR bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
 	#endif
 
 
diff --git a/include/EASTL/internal/type_transformations.h b/include/EASTL/internal/type_transformations.h
index bb3a5b0c..cffa65e5 100644
--- a/include/EASTL/internal/type_transformations.h
+++ b/include/EASTL/internal/type_transformations.h
@@ -157,6 +157,11 @@ namespace eastl
 		#endif
 	#endif
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		using make_signed_t = typename make_signed<T>::type;
+	#endif
+
 
 	///////////////////////////////////////////////////////////////////////
 	// add_signed
@@ -222,6 +227,11 @@ namespace eastl
 		#endif
 	#endif
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <class T>
+		using make_unsigned_t = typename make_unsigned<T>::type;
+	#endif
+
 
 
 	///////////////////////////////////////////////////////////////////////
diff --git a/include/EASTL/string_hash_map.h b/include/EASTL/string_hash_map.h
index 694a7675..8f90f305 100644
--- a/include/EASTL/string_hash_map.h
+++ b/include/EASTL/string_hash_map.h
@@ -25,7 +25,7 @@ class string_hash_map : public eastl::hash_map<const char*, T, Hash, Predicate,
 	typedef typename base::base_type::allocator_type allocator_type;
 	typedef typename base::base_type::insert_return_type insert_return_type;
 	typedef typename base::base_type::iterator iterator;
-	//typedef typename base::base_type::reverse_iterator reverse_iterator;
+//  typedef typename base::base_type::reverse_iterator reverse_iterator;
 	typedef typename base::base_type::const_iterator const_iterator;
 	typedef typename base::base_type::size_type size_type;
 	typedef typename base::base_type::value_type value_type;
@@ -39,24 +39,24 @@ class string_hash_map : public eastl::hash_map<const char*, T, Hash, Predicate,
 
 	this_type&			operator=(const this_type& x);
 
-	insert_return_type	insert(const char* key, const T& value);
-	insert_return_type	insert(const char* key);
-	iterator			erase(const_iterator position);
-	size_type			erase(const char* key);
-	mapped_type&		operator[](const char* key);
+	insert_return_type	 insert(const char* key, const T& value);
+	insert_return_type	 insert(const char* key);
+	pair<iterator, bool> insert_or_assign(const char* key, const T& value);
+	iterator			 erase(const_iterator position);
+	size_type			 erase(const char* key);
+	mapped_type&		 operator[](const char* key);
 
 private:
 	char*				strduplicate(const char* str);
 
 	// Not implemented right now
-	//insert_return_type	insert(const value_type& value);
-	//iterator			insert(iterator position, const value_type& value);
-    //reverse_iterator	erase(reverse_iterator position);
-    //reverse_iterator	erase(reverse_iterator first, reverse_iterator last);
+	// insert_return_type	insert(const value_type& value);
+	// iterator				insert(iterator position, const value_type& value);
+    // reverse_iterator		erase(reverse_iterator position);
+    // reverse_iterator		erase(reverse_iterator first, reverse_iterator last);
 };
 
 
-
 template<typename T, typename Hash, typename Predicate, typename Allocator>
 string_hash_map<T, Hash, Predicate, Allocator>::string_hash_map(const string_hash_map& src, const allocator_type& allocator) : base(allocator)
 {
@@ -71,8 +71,7 @@ string_hash_map<T, Hash, Predicate, Allocator>::~string_hash_map()
 }
 
 template<typename T, typename Hash, typename Predicate, typename Allocator>
-void
-string_hash_map<T, Hash, Predicate, Allocator>::clear()
+void string_hash_map<T, Hash, Predicate, Allocator>::clear()
 {
 	allocator_type& allocator = base::base_type::get_allocator();
 	for (const_iterator i=base::base_type::begin(), e=base::base_type::end(); i!=e; ++i)
@@ -81,8 +80,7 @@ string_hash_map<T, Hash, Predicate, Allocator>::clear()
 }
 
 template<typename T, typename Hash, typename Predicate, typename Allocator>
-void
-string_hash_map<T, Hash, Predicate, Allocator>::clear(bool clearBuckets)
+void string_hash_map<T, Hash, Predicate, Allocator>::clear(bool clearBuckets)
 {
 	allocator_type& allocator = base::base_type::get_allocator();
 	for (const_iterator i=base::base_type::begin(), e=base::base_type::end(); i!=e; ++i)
@@ -123,6 +121,13 @@ string_hash_map<T, Hash, Predicate, Allocator>::insert(const char* key, const T&
 	return base::base_type::insert(eastl::make_pair(strduplicate(key), value));
 }
 
+template<typename T, typename Hash, typename Predicate, typename Allocator>
+eastl::pair<typename string_hash_map<T, Hash, Predicate, Allocator>::iterator, bool>
+string_hash_map<T, Hash, Predicate, Allocator>::insert_or_assign(const char* key, const T& value)
+{
+	return base::base_type::insert_or_assign(strduplicate(key), value);
+}
+
 template<typename T, typename Hash, typename Predicate, typename Allocator>
 typename string_hash_map<T, Hash, Predicate, Allocator>::iterator
 string_hash_map<T, Hash, Predicate, Allocator>::erase(const_iterator position)
diff --git a/include/EASTL/type_traits.h b/include/EASTL/type_traits.h
index bb767279..a8129889 100644
--- a/include/EASTL/type_traits.h
+++ b/include/EASTL/type_traits.h
@@ -573,9 +573,36 @@ namespace eastl
 	// Dinkumware has an identity, but adds a member function to it:
 	//     const T& operator()(const T& t) const{ return t; }
 	//
+	// NOTE(rparolin): Use 'eastl::type_identity' it was included in the C++20
+	// standard. This is a legacy EASTL type we continue to support for
+	// backwards compatibility. 
+	//
 	template <typename T>
 	struct identity { using type = T; };
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <typename T>
+		using identity_t = typename identity<T>::type;
+	#endif
+
+
+	///////////////////////////////////////////////////////////////////////
+	// type_identity
+	//
+	// The purpose of this is typically to deal with non-deduced template
+	// contexts. See the C++11 Standard, 14.8.2.5 p5.
+	// Also: http://cppquiz.org/quiz/question/109?result=CE&answer=&did_answer=Answer
+	//
+	// https://en.cppreference.com/w/cpp/types/type_identity
+	//
+	template <typename T>
+	struct type_identity { using type = T; };
+
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template <typename T>
+		using type_identity_t = typename type_identity<T>::type;
+	#endif
+
 
 
 	///////////////////////////////////////////////////////////////////////
@@ -657,6 +684,10 @@ namespace eastl
 	template <typename T> struct is_reference     : public eastl::false_type{};
 	template <typename T> struct is_reference<T&> : public eastl::true_type{};
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template<typename T>
+		EA_CONSTEXPR bool is_reference_v = is_reference<T>::value;
+	#endif
 
 
 	///////////////////////////////////////////////////////////////////////
@@ -703,6 +734,11 @@ namespace eastl
 			: public eastl::true_type {};
 	#endif
 
+	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+		template<typename T>
+		EA_CONSTEXPR bool is_function_v = is_function<T>::value;
+	#endif
+
 
 	// The following remove utilities are defined here instead of in the headers
 	// below because they are core utilits that many other type traits need.
diff --git a/test/packages/EABase/.gitlab-ci.yml b/test/packages/EABase/.gitlab-ci.yml
index e75c69e8..1b297724 100644
--- a/test/packages/EABase/.gitlab-ci.yml
+++ b/test/packages/EABase/.gitlab-ci.yml
@@ -1,14 +1,7 @@
 image: registry.gitlab.ea.com/dre/automation/frostbite/framework-linux:7.19.01
-
-before_script:
-    - git clone https://gitlab-ci-token:${CI_JOB_TOKEN}@gitlab.ea.com/foundation/foundation-ci-files.git ci-files
-
-debug:
+build:
     script:
+        - git clone https://gitlab-ci-token:${CI_JOB_TOKEN}@gitlab.ea.com/foundation/foundation-ci-files.git ci-files
         - mono $FRAMEWORK_HOME/bin/nant.exe -masterconfigfile:ci-files/dev.xml -buildroot:/br -D:config=unix64-clang-dev-debug test-run
-debug-opt:
-    script:
         - mono $FRAMEWORK_HOME/bin/nant.exe -masterconfigfile:ci-files/dev.xml -buildroot:/br -D:config=unix64-clang-dev-debug-opt test-run
-opt:
-    script:
         - mono $FRAMEWORK_HOME/bin/nant.exe -masterconfigfile:ci-files/dev.xml -buildroot:/br -D:config=unix64-clang-dev-opt test-run
diff --git a/test/packages/EABase/include/Common/EABase/eahave.h b/test/packages/EABase/include/Common/EABase/eahave.h
index e263af6f..c341f7aa 100644
--- a/test/packages/EABase/include/Common/EABase/eahave.h
+++ b/test/packages/EABase/include/Common/EABase/eahave.h
@@ -225,7 +225,7 @@
 
 // #include <signal.h>
 #if !defined(EA_HAVE_SIGNAL_H) && !defined(EA_NO_HAVE_SIGNAL_H)
-	#if !defined(EA_PLATFORM_BSD) && !defined(EA_PLATFORM_SONY)
+	#if !defined(EA_PLATFORM_BSD) && !defined(EA_PLATFORM_SONY) && !defined(CS_UNDEFINED_STRING)
 		#define EA_HAVE_SIGNAL_H 1
 	#else
 		#define EA_NO_HAVE_SIGNAL_H 1
diff --git a/test/packages/EABase/include/Common/EABase/version.h b/test/packages/EABase/include/Common/EABase/version.h
index 00c58938..b691b03b 100644
--- a/test/packages/EABase/include/Common/EABase/version.h
+++ b/test/packages/EABase/include/Common/EABase/version.h
@@ -29,8 +29,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef EABASE_VERSION
-    #define EABASE_VERSION "2.09.02"
-    #define EABASE_VERSION_N 20902
+    #define EABASE_VERSION "2.09.03"
+    #define EABASE_VERSION_N 20903
 #endif
 
 #endif
diff --git a/test/source/TestStringHashMap.cpp b/test/source/TestStringHashMap.cpp
index db848dee..6c131733 100644
--- a/test/source/TestStringHashMap.cpp
+++ b/test/source/TestStringHashMap.cpp
@@ -215,5 +215,70 @@ int TestStringHashMap()
 
 	}
 
+	// pair<iterator, bool> insert_or_assign(const char* key, const T& value);
+	{
+		{
+			string_hash_map<int> m;
+
+			m.insert_or_assign("hello", 0);
+			EATEST_VERIFY(m["hello"] == 0);
+
+			m.insert_or_assign("hello", 42);
+			EATEST_VERIFY(m["hello"] == 42);
+
+			m.insert_or_assign("hello", 43);
+			EATEST_VERIFY(m["hello"] == 43);
+
+			m.insert_or_assign("hello", 1143);
+			EATEST_VERIFY(m["hello"] == 1143);
+
+			EATEST_VERIFY(m.size() == 1);
+			m.clear(); 
+			EATEST_VERIFY(m.size() == 0);
+		}
+
+		{
+			string_hash_map<int> m;
+			m.insert_or_assign("hello", 0);
+			m.insert_or_assign("hello2", 0);
+
+			EATEST_VERIFY(m.size() == 2);
+			m.clear(); 
+			EATEST_VERIFY(m.size() == 0);
+		}
+
+		{
+			string_hash_map<int> m;
+			m.insert_or_assign("hello", 0);
+			m.insert_or_assign("hello2", 0);
+
+			EATEST_VERIFY(m.size() == 2);
+			m.clear(true); 
+			EATEST_VERIFY(m.size() == 0);
+		}
+
+		{
+			string_hash_map<int> m;
+			m.insert_or_assign("hello", 0);
+			m.insert_or_assign("hello2", 0);
+
+			EATEST_VERIFY(m.size() == 2);
+			m.clear(false); 
+			EATEST_VERIFY(m.size() == 0);
+		}
+
+		{
+			string_hash_map<TestObject> m;
+
+			m.insert_or_assign("hello", TestObject(42));
+			EATEST_VERIFY(m["hello"].mX == 42);
+
+			m.insert_or_assign("hello", TestObject(43));
+			EATEST_VERIFY(m["hello"].mX == 43);
+
+			EATEST_VERIFY(m.size() == 1);
+		}
+	}
+
 	return nErrorCount;
 }
diff --git a/test/source/TestTypeTraits.cpp b/test/source/TestTypeTraits.cpp
index c4244567..0fb6280f 100644
--- a/test/source/TestTypeTraits.cpp
+++ b/test/source/TestTypeTraits.cpp
@@ -504,6 +504,13 @@ int TestTypeTraits()
 	static_assert(sizeof(identity<int>::type) == sizeof(int), "identity failure");
 	static_assert((is_same<int, identity<int>::type >::value == true), "identity failure");
 
+	// type_identity
+	static_assert(sizeof(type_identity<int>::type) == sizeof(int), "type_identity failure");
+	static_assert((is_same<int, type_identity<int>::type >::value == true), "type_identity failure");
+	static_assert(sizeof(type_identity_t<int>) == sizeof(int), "type_identity failure");
+	static_assert((is_same_v<int, type_identity_t<int>> == true), "type_identity failure");
+
+
 
 	// is_void
 	static_assert(is_void<void>::value == true, "is_void failure");
@@ -566,25 +573,32 @@ int TestTypeTraits()
 
 	// is_arithmetic
 	static_assert(is_arithmetic<float>::value == true, "is_arithmetic failure");
+	static_assert(is_arithmetic_v<float> == true,      "is_arithmetic failure");
 	EATEST_VERIFY(GetType(is_arithmetic<float>()) == true);
 
 	static_assert(is_arithmetic<Class>::value == false, "is_arithmetic failure");
+	static_assert(is_arithmetic_v<Class> == false,      "is_arithmetic failure");
 	EATEST_VERIFY(GetType(is_arithmetic<Class>()) == false);
 
 
 	// is_fundamental
 	static_assert(is_fundamental<void>::value == true, "is_fundamental failure");
+	static_assert(is_fundamental_v<void> == true,      "is_fundamental failure");
 	EATEST_VERIFY(GetType(is_fundamental<void>()) == true);
 
 	#ifndef EA_WCHAR_T_NON_NATIVE // If wchar_t is a native type instead of simply a define to an existing type which is already handled...
 		static_assert(is_fundamental<wchar_t>::value == true, "is_fundamental failure");
+		static_assert(is_fundamental_v<wchar_t> == true,      "is_fundamental failure");
 		EATEST_VERIFY(GetType(is_fundamental<wchar_t>()) == true);
 	#endif
 
 	static_assert(is_fundamental<Class>::value == false, "is_fundamental failure");
+	static_assert(is_fundamental_v<Class> == false,      "is_fundamental failure");
 	EATEST_VERIFY(GetType(is_fundamental<Class>()) == false);
 
 	static_assert(is_fundamental<std::nullptr_t>::value == true, "is_fundamental failure");
+	static_assert(is_fundamental_v<std::nullptr_t> == true,      "is_fundamental failure");
+
 
 	// is_array
 	static_assert(is_array<Array>::value == true, "is_array failure");
@@ -644,24 +658,30 @@ int TestTypeTraits()
 	#endif
 
 	// is_enum
-	static_assert(is_enum<Enum>::value == true, "is_enum failure");
+	static_assert(is_enum<Enum>::value == true,            "is_enum failure ");
+	static_assert(is_enum_v<Enum> == true,                 "is_enum failure ");
 	EATEST_VERIFY(GetType(is_enum<Enum>()) == true);
 
-	static_assert(is_enum<const Enum>::value == true, "is_enum failure");
+	static_assert(is_enum<const Enum>::value == true,      "is_enum failure ");
+	static_assert(is_enum_v<const Enum> == true,           "is_enum failure ");
 	EATEST_VERIFY(GetType(is_enum<const Enum>()) == true);
 
-	static_assert(is_enum<Enum*>::value == false, "is_enum failure");
+	static_assert(is_enum<Enum*>::value == false,          "is_enum failure ");
+	static_assert(is_enum_v<Enum*> == false,               "is_enum failure ");
 	EATEST_VERIFY(GetType(is_enum<Enum*>()) == false);
 
-	static_assert(is_enum<Class>::value == false, "is_enum failure");
+	static_assert(is_enum<Class>::value == false,          "is_enum failure ");
+	static_assert(is_enum_v<Class> == false,               "is_enum failure ");
 	EATEST_VERIFY(GetType(is_enum<Class>()) == false);
 
 
 	// is_union
 	static_assert(is_union<Union>::value == true, "is_union failure");
+	static_assert(is_union_v<Union> == true,      "is_union failure");
 	EATEST_VERIFY(GetType(is_union<Union>()) == true);
 
 	static_assert(is_union<int>::value == false, "is_union failure");
+	static_assert(is_union_v<int> == false,      "is_union failure");
 	EATEST_VERIFY(GetType(is_union<int>()) == false);
 
 
@@ -683,19 +703,34 @@ int TestTypeTraits()
 
 
 	// is_function
-	static_assert(is_function<void>::value == false,                                "is_function failure");
-	static_assert(is_function<FunctionVoidVoid>::value == true,                     "is_function failure");
-	static_assert(is_function<FunctionVoidVoid&>::value == false,                   "is_function failure");
-	static_assert(is_function<FunctionIntVoid>::value == true,                      "is_function failure");
-	static_assert(is_function<FunctionIntFloat>::value == true,                     "is_function failure");
-	static_assert(is_function<FunctionVoidVoidPtr>::value == false,                 "is_function failure");
-	static_assert(is_function<int>::value == false,                                 "is_function failure");
-	static_assert(is_function<int[3]>::value == false,                              "is_function failure");
-	static_assert(is_function<int[]>::value == false,                               "is_function failure");
-	static_assert(is_function<Class>::value == false,                               "is_function failure");
+	static_assert(is_function<void>::value == false,                      "is_function failure");
+	static_assert(is_function<FunctionVoidVoid>::value == true,           "is_function failure");
+	static_assert(is_function<FunctionVoidVoid&>::value == false,         "is_function failure");
+	static_assert(is_function<FunctionIntVoid>::value == true,            "is_function failure");
+	static_assert(is_function<FunctionIntFloat>::value == true,           "is_function failure");
+	static_assert(is_function<FunctionVoidVoidPtr>::value == false,       "is_function failure");
+	static_assert(is_function<int>::value == false,                       "is_function failure");
+	static_assert(is_function<int[3]>::value == false,                    "is_function failure");
+	static_assert(is_function<int[]>::value == false,                     "is_function failure");
+	static_assert(is_function<Class>::value == false,                     "is_function failure");
 	#if EASTL_TYPE_TRAIT_is_function_CONFORMANCE
 		// typedef int PrintfConst(const char*, ...) const;
-		static_assert(is_function<int (const char*, ...)>::value == true,           "is_function failure");  // This is the signature of printf.
+		static_assert(is_function<int (const char*, ...)>::value == true, "is_function failure");  // This is the signature of printf.
+	#endif
+
+	static_assert(is_function_v<void> == false,                           "is_function failure");
+	static_assert(is_function_v<FunctionVoidVoid> == true,                "is_function failure");
+	static_assert(is_function_v<FunctionVoidVoid&> == false,              "is_function failure");
+	static_assert(is_function_v<FunctionIntVoid> == true,                 "is_function failure");
+	static_assert(is_function_v<FunctionIntFloat> == true,                "is_function failure");
+	static_assert(is_function_v<FunctionVoidVoidPtr> == false,            "is_function failure");
+	static_assert(is_function_v<int> == false,                            "is_function failure");
+	static_assert(is_function_v<int[3]> == false,                         "is_function failure");
+	static_assert(is_function_v<int[]> == false,                          "is_function failure");
+	static_assert(is_function_v<Class> == false,                          "is_function failure");
+	#if EASTL_TYPE_TRAIT_is_function_CONFORMANCE
+		// typedef int PrintfConst(const char*, ...) const;
+		static_assert(is_function_v<int (const char*, ...)> == true,      "is_function failure");  // This is the signature of printf.
 	#endif
 
 
@@ -842,30 +877,39 @@ int TestTypeTraits()
 
 	// is_standard_layout
 	static_assert(is_standard_layout<Pod1>::value == true, "is_standard_layout<Pod1> failure");
+	static_assert(is_standard_layout_v<Pod1> == true,      "is_standard_layout<Pod1> failure");
 	EATEST_VERIFY(GetType(is_standard_layout<Pod1>()) == true);
 
 	static_assert(is_standard_layout<Pod2>::value == true, "is_standard_layout<Pod2> failure");
+	static_assert(is_standard_layout_v<Pod2> == true,      "is_standard_layout<Pod2> failure");
 	EATEST_VERIFY(GetType(is_standard_layout<Pod2>()) == true);
 
 	static_assert(is_standard_layout<Pod3>::value == true, "is_standard_layout<Pod3> failure");
+	static_assert(is_standard_layout_v<Pod3> == true,      "is_standard_layout<Pod3> failure");
 	EATEST_VERIFY(GetType(is_standard_layout<Pod3>()) == true);
 
 	static_assert(is_standard_layout<float>::value == true, "is_standard_layout<float> failure");
+	static_assert(is_standard_layout_v<float> == true,      "is_standard_layout<float> failure");
 	EATEST_VERIFY(GetType(is_standard_layout<float>()) == true);
 
 	static_assert(is_standard_layout<Pod1*>::value == true, "is_standard_layout<Pod1*> failure");
+	static_assert(is_standard_layout_v<Pod1*> == true,      "is_standard_layout<Pod1*> failure");
 	EATEST_VERIFY(GetType(is_standard_layout<Pod1*>()) == true);
 
 	static_assert(is_standard_layout<NonPod1>::value == false, "is_standard_layout<NonPod1> failure");
+	static_assert(is_standard_layout_v<NonPod1> == false,      "is_standard_layout<NonPod1> failure");
 	EATEST_VERIFY(GetType(is_standard_layout<NonPod1>()) == false);
 
 	static_assert(is_standard_layout<NonPod2>::value == false, "is_standard_layout<NonPod2> failure");
+	static_assert(is_standard_layout_v<NonPod2> == false,      "is_standard_layout<NonPod2> failure");
 	EATEST_VERIFY(GetType(is_standard_layout<NonPod2>()) == false);
 
 	static_assert(is_standard_layout<HasTrivialConstructor>::value == true, "is_standard_layout<HasTrivialConstructor> failure");
+	static_assert(is_standard_layout_v<HasTrivialConstructor> == true,      "is_standard_layout<HasTrivialConstructor> failure");
 	EATEST_VERIFY(GetType(is_standard_layout<HasTrivialConstructor>()) == true);
 
 	static_assert(is_standard_layout<NoTrivialConstructor>::value == true, "is_standard_layout<NoTrivialConstructor> failure");        // A key difference between a POD and Standard Layout is that the latter is true if there is a constructor.
+	static_assert(is_standard_layout_v<NoTrivialConstructor> == true, "is_standard_layout<NoTrivialConstructor> failure");        // A key difference between a POD and Standard Layout is that the latter is true if there is a constructor.
 	EATEST_VERIFY(GetType(is_standard_layout<NoTrivialConstructor>()) == true);
 
 
@@ -971,69 +1015,87 @@ int TestTypeTraits()
 
 
 	// is_signed
-	static_assert(is_signed<int>::value == true,            "is_unsigned failure");
+	static_assert(is_signed<int>::value == true,                "is_signed failure ");
+	static_assert(is_signed_v<int> == true,                     "is_signed failure ");
 	EATEST_VERIFY(GetType(is_signed<int>()) == true);
 
-	static_assert(is_signed<const int64_t>::value == true,  "is_unsigned failure");
+	static_assert(is_signed<const int64_t>::value == true,      "is_signed failure ");
+	static_assert(is_signed_v<const int64_t> == true,           "is_signed failure ");
 	EATEST_VERIFY(GetType(is_signed<const int64_t>()) == true);
 
-	static_assert(is_signed<uint32_t>::value == false,      "is_unsigned failure");
+	static_assert(is_signed<uint32_t>::value == false,          "is_signed failure ");
+	static_assert(is_signed_v<uint32_t> == false,               "is_signed failure ");
 	EATEST_VERIFY(GetType(is_signed<uint32_t>()) == false);
 
-	static_assert(is_signed<bool>::value == false,          "is_unsigned failure");
+	static_assert(is_signed<bool>::value == false,              "is_signed failure ");
+	static_assert(is_signed_v<bool> == false,                   "is_signed failure ");
 	EATEST_VERIFY(GetType(is_signed<bool>()) == false);
 
-	static_assert(is_signed<float>::value == true,          "is_unsigned failure");
+	static_assert(is_signed<float>::value == true,              "is_signed failure ");
+	static_assert(is_signed_v<float> == true,                   "is_signed failure ");
 	EATEST_VERIFY(GetType(is_signed<float>()) == true);
 
-	static_assert(is_signed<double>::value == true,         "is_unsigned failure");
+	static_assert(is_signed<double>::value == true,             "is_signed failure ");
+	static_assert(is_signed_v<double> == true,                  "is_signed failure ");
 	EATEST_VERIFY(GetType(is_signed<double>()) == true);
 
 
 	// is_unsigned
-	static_assert(is_unsigned<unsigned int>::value == true,    "is_unsigned failure");
+	static_assert(is_unsigned<unsigned int>::value == true,        "is_unsigned failure ");
+	static_assert(is_unsigned_v<unsigned int> == true,             "is_unsigned failure ");
 	EATEST_VERIFY(GetType(is_unsigned<unsigned int>()) == true);
 
-	static_assert(is_unsigned<const uint64_t>::value == true,  "is_unsigned failure");
+	static_assert(is_unsigned<const uint64_t>::value == true,      "is_unsigned failure ");
+	static_assert(is_unsigned_v<const uint64_t> == true,           "is_unsigned failure ");
 	EATEST_VERIFY(GetType(is_unsigned<const uint64_t>()) == true);
 
-	static_assert(is_unsigned<int32_t>::value == false,        "is_unsigned failure");
+	static_assert(is_unsigned<int32_t>::value == false,            "is_unsigned failure ");
+	static_assert(is_unsigned_v<int32_t> == false,                 "is_unsigned failure ");
 	EATEST_VERIFY(GetType(is_unsigned<int32_t>()) == false);
 
-	static_assert(is_unsigned<bool>::value == false,           "is_unsigned failure");
+	static_assert(is_unsigned<bool>::value == false,               "is_unsigned failure ");
+	static_assert(is_unsigned_v<bool> == false,                    "is_unsigned failure ");
 	EATEST_VERIFY(GetType(is_unsigned<bool>()) == false);
 
-	static_assert(is_unsigned<float>::value == false,          "is_unsigned failure");
+	static_assert(is_unsigned<float>::value == false,              "is_unsigned failure ");
+	static_assert(is_unsigned_v<float> == false,                   "is_unsigned failure ");
 	EATEST_VERIFY(GetType(is_unsigned<float>()) == false);
 
-	static_assert(is_unsigned<double>::value == false,         "is_unsigned failure");
+	static_assert(is_unsigned<double>::value == false,             "is_unsigned failure ");
+	static_assert(is_unsigned_v<double> == false,                  "is_unsigned failure ");
 	EATEST_VERIFY(GetType(is_unsigned<double>()) == false);
 
 
 	// is_lvalue_reference
-	static_assert((is_lvalue_reference<Class>::value == false),        "is_lvalue_reference failure");
-	static_assert((is_lvalue_reference<Class&>::value == true),        "is_lvalue_reference failure");
-	#if !EASTL_NO_RVALUE_REFERENCES
-		static_assert((is_lvalue_reference<Class&&>::value == false),  "is_lvalue_reference failure");
-	#endif
-	static_assert((is_lvalue_reference<int>::value == false),          "is_lvalue_reference failure");
-	static_assert((is_lvalue_reference<int&>::value == true),          "is_lvalue_reference failure");
-	#if !EASTL_NO_RVALUE_REFERENCES
-		static_assert((is_lvalue_reference<int&&>::value == false),    "is_lvalue_reference failure");
-	#endif
+	static_assert((is_lvalue_reference<Class>::value == false),   "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference<Class&>::value == true),   "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference<Class&&>::value == false), "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference<int>::value == false),     "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference<int&>::value == true),     "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference<int&&>::value == false),   "is_lvalue_reference failure");
+
+	static_assert((is_lvalue_reference_v<Class> == false),        "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference_v<Class&> == true),        "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference_v<Class&&> == false),      "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference_v<int> == false),          "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference_v<int&> == true),          "is_lvalue_reference failure");
+	static_assert((is_lvalue_reference_v<int&&> == false),        "is_lvalue_reference failure");
 
 
 	// is_rvalue_reference
-	static_assert((is_rvalue_reference<Class>::value == false),       "is_rvalue_reference failure");
-	static_assert((is_rvalue_reference<Class&>::value == false),      "is_rvalue_reference failure");
-	#if !EASTL_NO_RVALUE_REFERENCES
-		static_assert((is_rvalue_reference<Class&&>::value == true),  "is_rvalue_reference failure");
-	#endif
-	static_assert((is_rvalue_reference<int>::value == false),         "is_rvalue_reference failure");
-	static_assert((is_rvalue_reference<int&>::value == false),        "is_rvalue_reference failure");
-	#if !EASTL_NO_RVALUE_REFERENCES
-		static_assert((is_rvalue_reference<int&&>::value == true),    "is_rvalue_reference failure");
-	#endif
+	static_assert((is_rvalue_reference<Class>::value == false),  "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference<Class&>::value == false), "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference<Class&&>::value == true), "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference<int>::value == false),    "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference<int&>::value == false),   "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference<int&&>::value == true),   "is_rvalue_reference failure");
+
+	static_assert((is_rvalue_reference_v<Class> == false),  "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference_v<Class&> == false), "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference_v<Class&&> == true), "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference_v<int> == false),    "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference_v<int&> == false),   "is_rvalue_reference failure");
+	static_assert((is_rvalue_reference_v<int&&> == true),   "is_rvalue_reference failure");
 
 
 	// is_assignable
@@ -1369,6 +1431,11 @@ int TestTypeTraits()
 	static_assert(rank<int>::value == 0,                   "rank failure");
 	static_assert(rank<void>::value == 0,                  "rank failure");
 
+	static_assert(rank_v<int[1][2][3][4][5][6]> == 6,      "rank failure");
+	static_assert(rank_v<int[][1][2]> == 3,                "rank failure");
+	static_assert(rank_v<int> == 0,                        "rank failure");
+	static_assert(rank_v<void> == 0,                       "rank failure");
+
 
 
 	// extent
@@ -1382,6 +1449,16 @@ int TestTypeTraits()
 	static_assert((extent<int[2][4], 1>::value == 4), "extent failure");
 	static_assert((extent<int[][4], 1> ::value == 4), "extent failure");
 
+	static_assert((extent_v<int>          == 0),      "extent failure");
+	static_assert((extent_v<int[2]>       == 2),      "extent failure");
+	static_assert((extent_v<int[2][4]>    == 2),      "extent failure");
+	static_assert((extent_v<int[]>        == 0),      "extent failure");
+	static_assert((extent_v<int[][4]>     == 0),      "extent failure");
+	static_assert((extent_v<int, 1>       == 0),      "extent failure");
+	static_assert((extent_v<int[2], 1>    == 0),      "extent failure");
+	static_assert((extent_v<int[2][4], 1> == 4),      "extent failure");
+	static_assert((extent_v<int[][4], 1>  == 4),      "extent failure");
+
 
 
 	// is_aligned
@@ -1424,15 +1501,13 @@ int TestTypeTraits()
 	static_assert((is_same<uint64_t, uint32_t>::value  == false), "is_same failure");
 	static_assert((is_same<Class, ClassAlign32>::value == false), "is_same failure");
 
-	#if EASTL_VARIABLE_TEMPLATES_ENABLED
-		static_assert((is_same_v<uint32_t, uint32_t>  == true),  "is_same_v failure");
-		static_assert((is_same_v<void, void>          == true),  "is_same_v failure");
-		static_assert((is_same_v<void*, void*>        == true),  "is_same_v failure");
-		static_assert((is_same_v<uint64_t, uint64_t>  == true),  "is_same_v failure");
-		static_assert((is_same_v<Class, Class>        == true),  "is_same_v failure");
-		static_assert((is_same_v<uint64_t, uint32_t>  == false), "is_same_v failure");
-		static_assert((is_same_v<Class, ClassAlign32> == false), "is_same_v failure");
-	#endif
+	static_assert((is_same_v<uint32_t, uint32_t>  == true),       "is_same_v failure");
+	static_assert((is_same_v<void, void>          == true),       "is_same_v failure");
+	static_assert((is_same_v<void*, void*>        == true),       "is_same_v failure");
+	static_assert((is_same_v<uint64_t, uint64_t>  == true),       "is_same_v failure");
+	static_assert((is_same_v<Class, Class>        == true),       "is_same_v failure");
+	static_assert((is_same_v<uint64_t, uint32_t>  == false),      "is_same_v failure");
+	static_assert((is_same_v<Class, ClassAlign32> == false),      "is_same_v failure");
 
 
 
@@ -1921,6 +1996,37 @@ int TestTypeTraits()
 		static_assert(!has_equality_v<MissingEquality>, "has_equality failure");
 	}
 
+	// is_aggregate
+	#if EASTL_TYPE_TRAIT_is_aggregate_CONFORMANCE
+	{
+		static_assert(!is_aggregate_v<int>, "is_aggregate failure");
+		static_assert( is_aggregate_v<int[]>, "is_aggregate failure");
+
+		{
+			struct Aggregrate {};
+			static_assert(is_aggregate_v<Aggregrate>, "is_aggregate failure");
+		}
+
+		{
+			struct NotAggregrate { NotAggregrate() {} }; // user provided ctor
+			static_assert(!is_aggregate_v<NotAggregrate>, "is_aggregate failure");
+		}
+
+		#ifndef EA_COMPILER_MSVC
+		// NOTE(rparolin): MSVC is incorrectly categorizing the aggregate type in this test-case.
+		{
+			struct NotAggregrate { int data = 42; }; // default member initializer 
+			static_assert(!is_aggregate_v<NotAggregrate>, "is_aggregate failure");
+		}
+		#endif
+
+		{
+			struct NotAggregrate { virtual void foo() {} }; // virtual member function
+			static_assert(!is_aggregate_v<NotAggregrate>, "is_aggregate failure");
+		}
+	}
+	#endif
+
 	return nErrorCount;
 }