War on tabs.

llvm-svn: 185865

libcxx/include/chrono

@@ -728,8 +728,8 @@ public:
 
     // arithmetic
 
-	_LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
-	_LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
+    _LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
+    _LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
 
     // special values
 

libcxx/include/utility

@@ -692,10 +692,10 @@ template<class _T1, class _T2 = _T1>
 _LIBCPP_INLINE_VISIBILITY inline
 _T1 exchange(_T1& __obj, _T2 && __new_value)
 {
-	_T1 __old_value = _VSTD::move(__obj);
-	__obj = _VSTD::forward<_T2>(__new_value);
-	return __old_value;
-}	
+    _T1 __old_value = _VSTD::move(__obj);
+    __obj = _VSTD::forward<_T2>(__new_value);
+    return __old_value;
+}    
 #endif  // _LIBCPP_STD_VER > 11
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/support/win32/support.cpp

@@ -18,9 +18,9 @@
 
 namespace { // Private
 
-	struct free_deleter { 
-		inline void operator()(char* p) { free(p); } 
-	}; 
+    struct free_deleter { 
+        inline void operator()(char* p) { free(p); } 
+    }; 
 }
 // Some of these functions aren't standard or if they conform, the name does not.
 

libcxx/test/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp

@@ -20,7 +20,7 @@
 #include "test_iterators.h"
 
 #if _LIBCPP_STD_VER > 11
-#define	HAS_FOUR_ITERATOR_VERSION
+#define HAS_FOUR_ITERATOR_VERSION
 #endif
 
 int main()

libcxx/test/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp

@@ -22,15 +22,15 @@
 #include "test_iterators.h"
 
 #if _LIBCPP_STD_VER > 11
-#define	HAS_FOUR_ITERATOR_VERSION
+#define HAS_FOUR_ITERATOR_VERSION
 #endif
 
 int comparison_count = 0;
 template <typename T>
 bool counting_equals ( const T &a, const T &b ) {
-	++comparison_count;
-	return a == b;
-	}
+    ++comparison_count;
+    return a == b;
+}
 
 int main()
 {

libcxx/test/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp

@@ -20,7 +20,7 @@
 #include "test_iterators.h"
 
 #if _LIBCPP_STD_VER > 11
-#define	HAS_FOUR_ITERATOR_VERSION
+#define HAS_FOUR_ITERATOR_VERSION
 #endif
 
 int main()

libcxx/test/containers/sequences/array/array.tuple/get.fail.cpp

@@ -20,6 +20,6 @@ int main()
         typedef double T;
         typedef std::array<T, 3> C;
         C c = {1, 2, 3.5};
-        std::get<3>(c) = 5.5;	// Can't get element 3!
+        std::get<3>(c) = 5.5;    // Can't get element 3!
     }
 }

libcxx/test/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp

@@ -19,14 +19,14 @@ static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {
-	public: CMyClass();
-	public: CMyClass(const CMyClass& iOther);
-	public: ~CMyClass();
+    public: CMyClass();
+    public: CMyClass(const CMyClass& iOther);
+    public: ~CMyClass();
 
-	private: int fMagicValue;
+    private: int fMagicValue;
 
-	private: static int kStartedConstructionMagicValue;
-	private: static int kFinishedConstructionMagicValue;
+    private: static int kStartedConstructionMagicValue;
+    private: static int kFinishedConstructionMagicValue;
 };
 
 // Value for fMagicValue when the constructor has started running, but not yet finished
@@ -35,39 +35,39 @@ int CMyClass::kStartedConstructionMagicValue = 0;
 int CMyClass::kFinishedConstructionMagicValue = 12345;
 
 CMyClass::CMyClass() :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::CMyClass(const CMyClass& /*iOther*/) :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
-	if (gCopyConstructorShouldThow) {
-		throw std::exception();
-	}
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
+    if (gCopyConstructorShouldThow) {
+        throw std::exception();
+    }
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::~CMyClass() {
-	// Only instances for which the constructor has finished running should be destructed
-	assert(fMagicValue == kFinishedConstructionMagicValue);
+    // Only instances for which the constructor has finished running should be destructed
+    assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
 int main()
 {
-	CMyClass instance;
-	std::deque<CMyClass> vec;
+    CMyClass instance;
+    std::deque<CMyClass> vec;
 
-	vec.push_back(instance);
+    vec.push_back(instance);
 
-	gCopyConstructorShouldThow = true;
-	try {
-		vec.push_back(instance);
-	}
-	catch (...) {
-	}
+    gCopyConstructorShouldThow = true;
+    try {
+        vec.push_back(instance);
+    }
+    catch (...) {
+    }
 }

libcxx/test/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp

@@ -19,14 +19,14 @@ static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {
-	public: CMyClass();
-	public: CMyClass(const CMyClass& iOther);
-	public: ~CMyClass();
+    public: CMyClass();
+    public: CMyClass(const CMyClass& iOther);
+    public: ~CMyClass();
 
-	private: int fMagicValue;
+    private: int fMagicValue;
 
-	private: static int kStartedConstructionMagicValue;
-	private: static int kFinishedConstructionMagicValue;
+    private: static int kStartedConstructionMagicValue;
+    private: static int kFinishedConstructionMagicValue;
 };
 
 // Value for fMagicValue when the constructor has started running, but not yet finished
@@ -35,39 +35,39 @@ int CMyClass::kStartedConstructionMagicValue = 0;
 int CMyClass::kFinishedConstructionMagicValue = 12345;
 
 CMyClass::CMyClass() :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::CMyClass(const CMyClass& /*iOther*/) :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
-	if (gCopyConstructorShouldThow) {
-		throw std::exception();
-	}
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
+    if (gCopyConstructorShouldThow) {
+        throw std::exception();
+    }
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::~CMyClass() {
-	// Only instances for which the constructor has finished running should be destructed
-	assert(fMagicValue == kFinishedConstructionMagicValue);
+    // Only instances for which the constructor has finished running should be destructed
+    assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
 int main()
 {
-	CMyClass instance;
-	std::deque<CMyClass> vec;
+    CMyClass instance;
+    std::deque<CMyClass> vec;
 
-	vec.push_front(instance);
+    vec.push_front(instance);
 
-	gCopyConstructorShouldThow = true;
-	try {
-		vec.push_front(instance);
-	}
-	catch (...) {
-	}
+    gCopyConstructorShouldThow = true;
+    try {
+        vec.push_front(instance);
+    }
+    catch (...) {
+    }
 }

libcxx/test/containers/sequences/forwardlist/forwardlist.modifiers/push_front_exception_safety.pass.cpp

@@ -19,14 +19,14 @@ static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {
-	public: CMyClass();
-	public: CMyClass(const CMyClass& iOther);
-	public: ~CMyClass();
+    public: CMyClass();
+    public: CMyClass(const CMyClass& iOther);
+    public: ~CMyClass();
 
-	private: int fMagicValue;
+    private: int fMagicValue;
 
-	private: static int kStartedConstructionMagicValue;
-	private: static int kFinishedConstructionMagicValue;
+    private: static int kStartedConstructionMagicValue;
+    private: static int kFinishedConstructionMagicValue;
 };
 
 // Value for fMagicValue when the constructor has started running, but not yet finished
@@ -35,39 +35,39 @@ int CMyClass::kStartedConstructionMagicValue = 0;
 int CMyClass::kFinishedConstructionMagicValue = 12345;
 
 CMyClass::CMyClass() :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::CMyClass(const CMyClass& /*iOther*/) :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
-	if (gCopyConstructorShouldThow) {
-		throw std::exception();
-	}
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
+    if (gCopyConstructorShouldThow) {
+        throw std::exception();
+    }
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::~CMyClass() {
-	// Only instances for which the constructor has finished running should be destructed
-	assert(fMagicValue == kFinishedConstructionMagicValue);
+    // Only instances for which the constructor has finished running should be destructed
+    assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
 int main()
 {
-	CMyClass instance;
-	std::forward_list<CMyClass> vec;
+    CMyClass instance;
+    std::forward_list<CMyClass> vec;
 
-	vec.push_front(instance);
+    vec.push_front(instance);
 
-	gCopyConstructorShouldThow = true;
-	try {
-		vec.push_front(instance);
-	}
-	catch (...) {
-	}
+    gCopyConstructorShouldThow = true;
+    try {
+        vec.push_front(instance);
+    }
+    catch (...) {
+    }
 }

libcxx/test/containers/sequences/list/list.modifiers/push_back_exception_safety.pass.cpp

@@ -19,14 +19,14 @@ static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {
-	public: CMyClass();
-	public: CMyClass(const CMyClass& iOther);
-	public: ~CMyClass();
+    public: CMyClass();
+    public: CMyClass(const CMyClass& iOther);
+    public: ~CMyClass();
 
-	private: int fMagicValue;
+    private: int fMagicValue;
 
-	private: static int kStartedConstructionMagicValue;
-	private: static int kFinishedConstructionMagicValue;
+    private: static int kStartedConstructionMagicValue;
+    private: static int kFinishedConstructionMagicValue;
 };
 
 // Value for fMagicValue when the constructor has started running, but not yet finished
@@ -35,39 +35,39 @@ int CMyClass::kStartedConstructionMagicValue = 0;
 int CMyClass::kFinishedConstructionMagicValue = 12345;
 
 CMyClass::CMyClass() :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::CMyClass(const CMyClass& /*iOther*/) :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
-	if (gCopyConstructorShouldThow) {
-		throw std::exception();
-	}
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
+    if (gCopyConstructorShouldThow) {
+        throw std::exception();
+    }
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::~CMyClass() {
-	// Only instances for which the constructor has finished running should be destructed
-	assert(fMagicValue == kFinishedConstructionMagicValue);
+    // Only instances for which the constructor has finished running should be destructed
+    assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
 int main()
 {
-	CMyClass instance;
-	std::list<CMyClass> vec;
+    CMyClass instance;
+    std::list<CMyClass> vec;
 
-	vec.push_back(instance);
+    vec.push_back(instance);
 
-	gCopyConstructorShouldThow = true;
-	try {
-		vec.push_back(instance);
-	}
-	catch (...) {
-	}
+    gCopyConstructorShouldThow = true;
+    try {
+        vec.push_back(instance);
+    }
+    catch (...) {
+    }
 }

libcxx/test/containers/sequences/list/list.modifiers/push_front_exception_safety.pass.cpp

@@ -19,14 +19,14 @@ static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {
-	public: CMyClass();
-	public: CMyClass(const CMyClass& iOther);
-	public: ~CMyClass();
+    public: CMyClass();
+    public: CMyClass(const CMyClass& iOther);
+    public: ~CMyClass();
 
-	private: int fMagicValue;
+    private: int fMagicValue;
 
-	private: static int kStartedConstructionMagicValue;
-	private: static int kFinishedConstructionMagicValue;
+    private: static int kStartedConstructionMagicValue;
+    private: static int kFinishedConstructionMagicValue;
 };
 
 // Value for fMagicValue when the constructor has started running, but not yet finished
@@ -35,39 +35,39 @@ int CMyClass::kStartedConstructionMagicValue = 0;
 int CMyClass::kFinishedConstructionMagicValue = 12345;
 
 CMyClass::CMyClass() :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::CMyClass(const CMyClass& /*iOther*/) :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
-	if (gCopyConstructorShouldThow) {
-		throw std::exception();
-	}
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
+    if (gCopyConstructorShouldThow) {
+        throw std::exception();
+    }
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::~CMyClass() {
-	// Only instances for which the constructor has finished running should be destructed
-	assert(fMagicValue == kFinishedConstructionMagicValue);
+    // Only instances for which the constructor has finished running should be destructed
+    assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
 int main()
 {
-	CMyClass instance;
-	std::list<CMyClass> vec;
+    CMyClass instance;
+    std::list<CMyClass> vec;
 
-	vec.push_front(instance);
+    vec.push_front(instance);
 
-	gCopyConstructorShouldThow = true;
-	try {
-		vec.push_front(instance);
-	}
-	catch (...) {
-	}
+    gCopyConstructorShouldThow = true;
+    try {
+        vec.push_front(instance);
+    }
+    catch (...) {
+    }
 }

libcxx/test/containers/sequences/vector/vector.modifiers/push_back_exception_safety.pass.cpp

@@ -19,14 +19,14 @@ static bool gCopyConstructorShouldThow = false;
 
 
 class CMyClass {
-	public: CMyClass();
-	public: CMyClass(const CMyClass& iOther);
-	public: ~CMyClass();
+    public: CMyClass();
+    public: CMyClass(const CMyClass& iOther);
+    public: ~CMyClass();
 
-	private: int fMagicValue;
+    private: int fMagicValue;
 
-	private: static int kStartedConstructionMagicValue;
-	private: static int kFinishedConstructionMagicValue;
+    private: static int kStartedConstructionMagicValue;
+    private: static int kFinishedConstructionMagicValue;
 };
 
 // Value for fMagicValue when the constructor has started running, but not yet finished
@@ -35,39 +35,39 @@ int CMyClass::kStartedConstructionMagicValue = 0;
 int CMyClass::kFinishedConstructionMagicValue = 12345;
 
 CMyClass::CMyClass() :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::CMyClass(const CMyClass& /*iOther*/) :
-	fMagicValue(kStartedConstructionMagicValue)
+    fMagicValue(kStartedConstructionMagicValue)
 {
-	// If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
-	if (gCopyConstructorShouldThow) {
-		throw std::exception();
-	}
-	// Signal that the constructor has finished running
-	fMagicValue = kFinishedConstructionMagicValue;
+    // If requested, throw an exception _before_ setting fMagicValue to kFinishedConstructionMagicValue
+    if (gCopyConstructorShouldThow) {
+        throw std::exception();
+    }
+    // Signal that the constructor has finished running
+    fMagicValue = kFinishedConstructionMagicValue;
 }
 
 CMyClass::~CMyClass() {
-	// Only instances for which the constructor has finished running should be destructed
-	assert(fMagicValue == kFinishedConstructionMagicValue);
+    // Only instances for which the constructor has finished running should be destructed
+    assert(fMagicValue == kFinishedConstructionMagicValue);
 }
 
 int main()
 {
-	CMyClass instance;
-	std::vector<CMyClass> vec;
+    CMyClass instance;
+    std::vector<CMyClass> vec;
 
-	vec.push_back(instance);
+    vec.push_back(instance);
 
-	gCopyConstructorShouldThow = true;
-	try {
-		vec.push_back(instance);
-	}
-	catch (...) {
-	}
+    gCopyConstructorShouldThow = true;
+    try {
+        vec.push_back(instance);
+    }
+    catch (...) {
+    }
 }

libcxx/test/input.output/iostream.format/input.streams/istream.unformatted/ignore_0xff.pass.cpp

@@ -22,16 +22,16 @@
 
 int main()
 {
-	int bad=-1;
-	std::ostringstream os;
-	os << "aaaabbbb" << static_cast<char>(bad) 
-	   << "ccccdddd" << std::endl;
-	std::string s=os.str();
-	
-	std::istringstream is(s);
-	const unsigned int ignoreLen=10;
-	size_t a=is.tellg();
-	is.ignore(ignoreLen);
-	size_t b=is.tellg();
-	assert((b-a)==ignoreLen);
+    int bad=-1;
+    std::ostringstream os;
+    os << "aaaabbbb" << static_cast<char>(bad) 
+       << "ccccdddd" << std::endl;
+    std::string s=os.str();
+    
+    std::istringstream is(s);
+    const unsigned int ignoreLen=10;
+    size_t a=is.tellg();
+    is.ignore(ignoreLen);
+    size_t b=is.tellg();
+    assert((b-a)==ignoreLen);
 }

libcxx/test/language.support/support.exception/uncaught/uncaught_exception.pass.cpp

@@ -22,11 +22,11 @@ struct A
 
 struct B
 {
-	B()
-	{
-		// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#475
+    B()
+    {
+        // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#475
         assert(!std::uncaught_exception());
-	}
+    }
 };
 
 int main()

libcxx/test/support/test_iterators.h

@@ -290,7 +290,7 @@ inline Iter base(bidirectional_iterator<Iter> i) { return i.base(); }
 template <class Iter>
 inline Iter base(random_access_iterator<Iter> i) { return i.base(); }
 
-template <class Iter>	// everything else
+template <class Iter>    // everything else
 inline Iter base(Iter i) { return i; }
 
 #endif  // ITERATORS_H

libcxx/test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp

@@ -18,10 +18,10 @@
 #include <functional>
 
 struct X{
-	typedef std::function<void(X&)> callback_type;
-	virtual ~X() {}
+    typedef std::function<void(X&)> callback_type;
+    virtual ~X() {}
 private:
-	callback_type _cb;
+    callback_type _cb;
 };
 
 int main()

libcxx/test/utilities/meta/meta.hel/integral_constant.pass.cpp

@@ -27,8 +27,8 @@ int main()
 #endif
 
 #if _LIBCPP_STD_VER > 11
-	static_assert ( _5{}() == 5, "" );
-	static_assert ( std::true_type{}(), "" );
+    static_assert ( _5{}() == 5, "" );
+    static_assert ( std::true_type{}(), "" );
 #endif
 
     static_assert(std::false_type::value == false, "");

libcxx/test/utilities/meta/meta.rel/is_convertible.pass.cpp

@@ -134,8 +134,8 @@ int main()
     test_is_not_convertible<char, Array> ();
     test_is_not_convertible<char, Array&> ();
 
-	test_is_convertible<char, char> ();
-	
+    test_is_convertible<char, char> ();
+    
     static_assert((!std::is_convertible<char, char&>::value), "");
     static_assert(( std::is_convertible<char, const char&>::value), "");
     static_assert((!std::is_convertible<const char, char&>::value), "");
@@ -151,8 +151,8 @@ int main()
     test_is_not_convertible<char&, Array> ();
     test_is_not_convertible<char&, Array&> ();
 
-	test_is_convertible<char&, char> ();
-	
+    test_is_convertible<char&, char> ();
+    
     static_assert(( std::is_convertible<char&, char&>::value), "");
     static_assert(( std::is_convertible<char&, const char&>::value), "");
     static_assert((!std::is_convertible<const char&, char&>::value), "");
@@ -168,9 +168,9 @@ int main()
     test_is_not_convertible<char*, Array> ();
     test_is_not_convertible<char*, Array&> ();
 
-	test_is_not_convertible<char*, char> ();
-	test_is_not_convertible<char*, char&> ();
-	
+    test_is_not_convertible<char*, char> ();
+    test_is_not_convertible<char*, char&> ();
+    
     static_assert(( std::is_convertible<char*, char*>::value), "");
     static_assert(( std::is_convertible<char*, const char*>::value), "");
     static_assert((!std::is_convertible<const char*, char*>::value), "");

libcxx/test/utilities/utility/exchange/exchange.pass.cpp

@@ -18,30 +18,30 @@
 int main()
 {
 #if _LIBCPP_STD_VER > 11
-	{
-	int v = 12;
-	assert ( std::exchange ( v, 23 ) == 12 );
-	assert ( v == 23 );
-	assert ( std::exchange ( v, 67.2 ) == 23 );
-	assert ( v = 67 );
-	}
+    {
+    int v = 12;
+    assert ( std::exchange ( v, 23 ) == 12 );
+    assert ( v == 23 );
+    assert ( std::exchange ( v, 67.2 ) == 23 );
+    assert ( v = 67 );
+    }
 
-	{
-	bool b = false;
-	assert ( !std::exchange ( b, true ));
-	assert ( b );
-	}
+    {
+    bool b = false;
+    assert ( !std::exchange ( b, true ));
+    assert ( b );
+    }
 
-	{
-	const std::string s1 ( "Hi Mom!" );
-	const std::string s2 ( "Yo Dad!" );
-	std::string s3 = s1; // Mom
-	assert ( std::exchange ( s3, s2 ) == s1 );
-	assert ( s3 == s2 );
-	assert ( std::exchange ( s3, "Hi Mom!" ) == s2 );
-	assert ( s3 == s1 );
-	assert ( std::exchange ( s3, "" ) == s1 );
-	assert ( s3.size () == 0 );
-	}
+    {
+    const std::string s1 ( "Hi Mom!" );
+    const std::string s2 ( "Yo Dad!" );
+    std::string s3 = s1; // Mom
+    assert ( std::exchange ( s3, s2 ) == s1 );
+    assert ( s3 == s2 );
+    assert ( std::exchange ( s3, "Hi Mom!" ) == s2 );
+    assert ( s3 == s1 );
+    assert ( std::exchange ( s3, "" ) == s1 );
+    assert ( s3.size () == 0 );
+    }
 #endif
 }