Merge remote-tracking branch 'origin/development' into android-clang-3

ras0219-msft · ras0219-msft · commit f2d22aad6a1d · 2014-11-12T13:24:49.000-08:00
diff --git a/Release/tests/functional/http/client/authentication_tests.cpp b/Release/tests/functional/http/client/authentication_tests.cpp
@@ -1,12 +1,12 @@
 /***
 * ==++==
 *
-* Copyright (c) Microsoft Corporation. All rights reserved. 
+* Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
-* 
+*
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -37,7 +37,7 @@
 #endif
 #endif
 
-using namespace web; 
+using namespace web;
 using namespace utility;
 using namespace concurrency;
 using namespace web::http;
@@ -76,7 +76,7 @@ TEST_FIXTURE(uri_address, auth_no_data, "Ignore:Linux", "89", "Ignore:Apple", "8
         headers[U("WWW-Authenticate")] = U("Basic realm = \"WallyWorld\"");
 
         // unauthorized
-        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers); 
+        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers);
 
     }).then([&scoped, replyFunc]()
     {
@@ -118,7 +118,7 @@ TEST_FIXTURE(uri_address, proxy_auth_known_contentlength, "Ignore:Linux", "88",
         headers[U("WWW-Authenticate")] = U("Basic realm = \"WallyWorld\"");
 
         // unauthorized
-        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers); 
+        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers);
 
     }).then([&scoped, replyFunc]()
     {
@@ -153,7 +153,7 @@ TEST_FIXTURE(uri_address, proxy_auth_noseek, "Ignore:Linux", "88", "Ignore:Apple
         headers[U("WWW-Authenticate")] = U("Basic realm = \"WallyWorld\"");
 
         // unauthorized
-        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers); 
+        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers);
 
     });
 
@@ -194,7 +194,7 @@ TEST_FIXTURE(uri_address, proxy_auth_unknown_contentlength, "Ignore:Linux", "88"
         headers[U("WWW-Authenticate")] = U("Basic realm = \"WallyWorld\"");
 
         // unauthorized
-        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers); 
+        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers);
 
     }).then([&scoped, replyFunc]()
     {
@@ -218,7 +218,7 @@ TEST_FIXTURE(uri_address, empty_username_password)
         // Auth header
         headers[U("WWW-Authenticate")] = U("Basic realm = \"myRealm\"");
         // unauthorized
-        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers, "a" ); 
+        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers, "a" );
     });
 
     http_response response = client.request(methods::GET).get();
@@ -249,7 +249,7 @@ TEST_FIXTURE(uri_address, error_after_valid_credentials, "Ignore:Linux", "89", "
             headers[U("WWW-Authenticate")] = U("Basic realm = \"WallyWorld\"");
             headers[U("h1")] = U("data2");
             // still unauthorized after the user has resent the request with the credentials
-            p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers, "def" ); 
+            p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers, "def" );
         };
 
     scoped.server()->next_request().then([&](test_request *p_request)
@@ -259,7 +259,7 @@ TEST_FIXTURE(uri_address, error_after_valid_credentials, "Ignore:Linux", "89", "
         // Auth header
         headers[U("WWW-Authenticate")] = U("Basic realm = \"myRealm\"");
         // unauthorized
-        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers, "abc" ); 
+        p_request->reply(status_codes::Unauthorized, U("Authentication Failed"), headers, "abc" );
     }).then([&scoped, &replyFunc]()
     {
         // Client resent the request
@@ -348,7 +348,7 @@ TEST_FIXTURE(server_properties, unsuccessful_auth_with_basic_cred, "Requires", "
 
     http_client_config config;
     config.set_credentials(credentials(m_username, m_password));
-    
+
     http_client client(m_uri, config);
     http_response response = client.request(methods::GET).get();
     VERIFY_ARE_EQUAL(status_codes::Unauthorized, response.status_code());
@@ -423,7 +423,7 @@ TEST_FIXTURE(uri_address, set_user_options_winrt)
     test_http_server::scoped_server scoped(m_uri);
     scoped.server()->next_request().then([](test_request *p_request)
     {
-        p_request->reply(status_codes::OK); 
+        p_request->reply(status_codes::OK);
     });
 
     http_client_config config;
@@ -451,7 +451,7 @@ TEST_FIXTURE(server_properties, set_user_options, "Requires", "Server;UserName;P
         DWORD policy = WINHTTP_AUTOLOGON_SECURITY_LEVEL_LOW;
         if (!WinHttpSetOption(handle,
                          WINHTTP_OPTION_AUTOLOGON_POLICY,
-                         &policy, 
+                         &policy,
                          sizeof(policy)))
         {
             throw std::runtime_error("The Test Error");
@@ -595,7 +595,7 @@ TEST_FIXTURE(uri_address, set_user_options_exceptions)
     VERIFY_THROWS(client.request(methods::GET).get(), std::runtime_error);
 }
 #endif // _MS_WINDOWS
-#pragma endregion 
+#pragma endregion
 
 // Fix for 522831 AV after failed authentication attempt
 TEST_FIXTURE(uri_address, failed_authentication_attempt, "Ignore:Linux", "89", "Ignore:Apple", "89")
diff --git a/Release/tests/functional/streams/istream_tests.cpp b/Release/tests/functional/streams/istream_tests.cpp
@@ -1,12 +1,12 @@
 /***
 * ==++==
 *
-* Copyright (c) Microsoft Corporation. All rights reserved. 
+* Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
-* 
+*
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -23,6 +23,8 @@
 #include "unittestpp.h"
 #include "stdafx.h"
 
+#include <float.h>
+
 #if defined(__cplusplus_winrt)
 using namespace Windows::Storage;
 #endif
@@ -1280,6 +1282,31 @@ TEST(istream_extract_unsigned_long_long)
 #endif
 }
 
+template <typename T>
+void compare_floating(T expected, T actual, T relativeDiff)
+{
+    // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+    if (expected != actual)
+    {
+        const auto diff = fabs(expected - actual);
+        const auto absExpected = fabs(expected);
+        const auto absActual = fabs(actual);
+        const auto largest = absExpected > absActual ? absExpected : absActual;
+        if (diff > largest * relativeDiff)
+        {
+            VERIFY_IS_TRUE(false);
+        }
+    }
+}
+void compare_double(double expected, double actual)
+{
+    compare_floating(expected, actual, DBL_EPSILON);
+}
+void compare_float(float expected, float actual)
+{
+    compare_floating(expected, actual, FLT_EPSILON);
+}
+
 TEST(extract_floating_point)
 {
     std::string test_string;
@@ -1310,13 +1337,14 @@ TEST(extract_floating_point)
 
     do
     {
-        double expected=0, actual;
+        double expected = 0;
         std_istream >> expected;
         
-        VERIFY_ARE_EQUAL(expected, actual = istream_double.extract<double>().get());
+        const auto actual = istream_double.extract<double>().get();
+        compare_double(expected, actual);
         
         if (actual <= std::numeric_limits<float>::max())
-            VERIFY_ARE_EQUAL(float(expected), istream_float.extract<float>().get());
+            compare_float(float(expected), istream_float.extract<float>().get());
         else
             VERIFY_THROWS(istream_float.extract<float>().get(), std::exception);
 
diff --git a/Release/tests/functional/utils/datetime.cpp b/Release/tests/functional/utils/datetime.cpp
@@ -35,6 +35,8 @@ SUITE(datetime)
 // This is by no means a comprehensive test suite for the datetime functionality.
 // It's a response to a particular bug and should be amended over time.
 
+// CodePlex 311
+#if !defined(_MS_WINDOWS) || (defined(_MSC_VER) && _MSC_VER < 1900)
 TEST(parsing_dateandtime_basic)
 {
     // ISO 8601
@@ -62,6 +64,7 @@ TEST(parsing_dateandtime_extended)
 
     VERIFY_ARE_EQUAL(dt1.to_interval(), dt2.to_interval());
 }
+#endif
 
 TEST(parsing_date_basic)
 {
diff --git a/Release/tests/functional/websockets/client/authentication_tests.cpp b/Release/tests/functional/websockets/client/authentication_tests.cpp
@@ -1,12 +1,12 @@
 /***
 * ==++==
 *
-* Copyright (c) Microsoft Corporation. All rights reserved. 
+* Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
-* 
+*
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -44,7 +44,7 @@ void auth_helper(test_websocket_server& server, const utility::string_t &usernam
     server.set_http_handler([username, password](test_http_request request)
     {
         test_http_response resp;
-        if (request->username().empty()) // No credentials -> challenge the request 
+        if (request->username().empty()) // No credentials -> challenge the request
         {
             resp.set_status_code(401); // Unauthorized.
             resp.set_realm("My Realm");
@@ -86,6 +86,19 @@ TEST_FIXTURE(uri_address, auth_with_credentials, "Ignore", "245")
 }
 #endif
 
+// helper function to check if failure is due to timeout.
+bool is_timeout(const std::string &msg)
+{
+    if (msg.find("set_fail_handler") != std::string::npos)
+    {
+        if (msg.find("TLS handshake timed out") != std::string::npos || msg.find("Timer Expired") != std::string::npos)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
 TEST(ssl_test)
 {
     websocket_client client;
@@ -112,15 +125,11 @@ TEST(ssl_test)
     }
     catch (const websocket_exception &e)
     {
-        const auto msg = std::string(e.what());
-        if (msg.find("set_fail_handler") != std::string::npos)
+        if (is_timeout(e.what()))
         {
-            if (msg.find("TLS handshake timed out") != std::string::npos || msg.find("Timer Expired") != std::string::npos)
-            {
-                // Since this test depends on an outside server sometimes it sporadically can fail due to timeouts
-                // especially on our build machines.
-                return;
-            }
+            // Since this test depends on an outside server sometimes it sporadically can fail due to timeouts
+            // especially on our build machines.
+            return;
         }
         throw;
     }
@@ -139,6 +148,12 @@ void handshake_error_test_impl(const ::utility::string_t &host)
     }
     catch (const websocket_exception &e)
     {
+        if (is_timeout(e.what()))
+        {
+            // Since this test depends on an outside server sometimes it sporadically can fail due to timeouts
+            // especially on our build machines.
+            return;
+        }
         VERIFY_ARE_EQUAL("TLS handshake failed", e.error_code().message());
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,8 @@ SUITE(datetime)`
`35`	`35`	`// This is by no means a comprehensive test suite for the datetime functionality.`
`36`	`36`	`// It's a response to a particular bug and should be amended over time.`
`37`	`37`
	`38`	`+// CodePlex 311`
	`39`	`+#if !defined(_MS_WINDOWS) \|\| (defined(_MSC_VER) && _MSC_VER < 1900)`
`38`	`40`	`TEST(parsing_dateandtime_basic)`
`39`	`41`	`{`
`40`	`42`	`// ISO 8601`
`@@ -62,6 +64,7 @@ TEST(parsing_dateandtime_extended)`
`62`	`64`
`63`	`65`	`VERIFY_ARE_EQUAL(dt1.to_interval(), dt2.to_interval());`
`64`	`66`	`}`
	`67`	`+#endif`
`65`	`68`
`66`	`69`	`TEST(parsing_date_basic)`
`67`	`70`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,12 @@`
`1`	`1`	`/***`
`2`	`2`	`* ==++==`
`3`	`3`	`*`
`4`		`-* Copyright (c) Microsoft Corporation. All rights reserved.`
	`4`	`+* Copyright (c) Microsoft Corporation. All rights reserved.`
`5`	`5`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`6`	`6`	`* you may not use this file except in compliance with the License.`
`7`	`7`	`* You may obtain a copy of the License at`
`8`	`8`	`* http://www.apache.org/licenses/LICENSE-2.0`
`9`		`-*`
	`9`	`+*`
`10`	`10`	`* Unless required by applicable law or agreed to in writing, software`
`11`	`11`	`* distributed under the License is distributed on an "AS IS" BASIS,`
`12`	`12`	`* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.`
`@@ -44,7 +44,7 @@ void auth_helper(test_websocket_server& server, const utility::string_t &usernam`
`44`	`44`	`server.set_http_handler([username, password](test_http_request request)`
`45`	`45`	`{`
`46`	`46`	`test_http_response resp;`
`47`		`- if (request->username().empty()) // No credentials -> challenge the request`
	`47`	`+ if (request->username().empty()) // No credentials -> challenge the request`
`48`	`48`	`{`
`49`	`49`	`resp.set_status_code(401); // Unauthorized.`
`50`	`50`	`resp.set_realm("My Realm");`
`@@ -86,6 +86,19 @@ TEST_FIXTURE(uri_address, auth_with_credentials, "Ignore", "245")`
`86`	`86`	`}`
`87`	`87`	`#endif`
`88`	`88`
	`89`	`+// helper function to check if failure is due to timeout.`
	`90`	`+bool is_timeout(const std::string &msg)`
	`91`	`+{`
	`92`	`+ if (msg.find("set_fail_handler") != std::string::npos)`
	`93`	`+ {`
	`94`	`+ if (msg.find("TLS handshake timed out") != std::string::npos \|\| msg.find("Timer Expired") != std::string::npos)`
	`95`	`+ {`
	`96`	`+ return true;`
	`97`	`+ }`
	`98`	`+ }`
	`99`	`+ return false;`
	`100`	`+}`
	`101`	`+`
`89`	`102`	`TEST(ssl_test)`
`90`	`103`	`{`
`91`	`104`	`websocket_client client;`
`@@ -112,15 +125,11 @@ TEST(ssl_test)`
`112`	`125`	`}`
`113`	`126`	`catch (const websocket_exception &e)`
`114`	`127`	`{`
`115`		`- const auto msg = std::string(e.what());`
`116`		`- if (msg.find("set_fail_handler") != std::string::npos)`
	`128`	`+ if (is_timeout(e.what()))`
`117`	`129`	`{`
`118`		`- if (msg.find("TLS handshake timed out") != std::string::npos \|\| msg.find("Timer Expired") != std::string::npos)`
`119`		`- {`
`120`		`- // Since this test depends on an outside server sometimes it sporadically can fail due to timeouts`
`121`		`- // especially on our build machines.`
`122`		`- return;`
`123`		`- }`
	`130`	`+ // Since this test depends on an outside server sometimes it sporadically can fail due to timeouts`
	`131`	`+ // especially on our build machines.`
	`132`	`+ return;`
`124`	`133`	`}`
`125`	`134`	`throw;`
`126`	`135`	`}`
`@@ -139,6 +148,12 @@ void handshake_error_test_impl(const ::utility::string_t &host)`
`139`	`148`	`}`
`140`	`149`	`catch (const websocket_exception &e)`
`141`	`150`	`{`
	`151`	`+ if (is_timeout(e.what()))`
	`152`	`+ {`
	`153`	`+ // Since this test depends on an outside server sometimes it sporadically can fail due to timeouts`
	`154`	`+ // especially on our build machines.`
	`155`	`+ return;`
	`156`	`+ }`
`142`	`157`	`VERIFY_ARE_EQUAL("TLS handshake failed", e.error_code().message());`
`143`	`158`	`}`
`144`	`159`	`}`