Enable and fix CRLSet and remoting tests on non-Android OpenSSL.

remoting/protocol/third_party_authenticator_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/bind.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/protocol/authenticator_test_base.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/connection_tester.h"
@@ skipping 103 matching lines @@
     client_.reset(new ThirdPartyClientAuthenticator(token_fetcher.Pass()));
   }
 
   FakeTokenFetcher* token_fetcher_;
   FakeTokenValidator* token_validator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ThirdPartyAuthenticatorTest);
 };
 
-// These tests use net::SSLServerSocket which is not implemented for OpenSSL.
-#if defined(USE_OPENSSL)
-#define MAYBE(x) DISABLED_##x
-#else
-#define MAYBE(x) x
-#endif
-
-TEST_F(ThirdPartyAuthenticatorTest, MAYBE(SuccessfulAuth)) {
+TEST_F(ThirdPartyAuthenticatorTest, SuccessfulAuth) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators());
   ASSERT_NO_FATAL_FAILURE(RunHostInitiatedAuthExchange());
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, client_->state());
   ASSERT_NO_FATAL_FAILURE(token_fetcher_->OnTokenFetched(
       kToken, kSharedSecret));
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, host_->state());
   ASSERT_NO_FATAL_FAILURE(
       token_validator_->OnTokenValidated(kSharedSecret));
 
   // Both sides have finished.
   ASSERT_EQ(Authenticator::ACCEPTED, host_->state());
   ASSERT_EQ(Authenticator::ACCEPTED, client_->state());
 
   // An authenticated channel can be created after the authentication.
   client_auth_ = client_->CreateChannelAuthenticator();
   host_auth_ = host_->CreateChannelAuthenticator();
   RunChannelAuth(false);
 
   StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
                                 kMessageSize, kMessages);
 
   tester.Start();
   message_loop_.Run();
   tester.CheckResults();
 }
 
-TEST_F(ThirdPartyAuthenticatorTest, MAYBE(ClientNoSecret)) {
+TEST_F(ThirdPartyAuthenticatorTest, ClientNoSecret) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators());
   ASSERT_NO_FATAL_FAILURE(RunHostInitiatedAuthExchange());
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, client_->state());
   ASSERT_NO_FATAL_FAILURE(
       token_fetcher_->OnTokenFetched(kToken, std::string()));
 
   // The end result is that the client rejected the connection, since it
   // couldn't fetch the secret.
   ASSERT_EQ(Authenticator::REJECTED, client_->state());
 }
 
-TEST_F(ThirdPartyAuthenticatorTest, MAYBE(InvalidToken)) {
+TEST_F(ThirdPartyAuthenticatorTest, InvalidToken) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators());
   ASSERT_NO_FATAL_FAILURE(RunHostInitiatedAuthExchange());
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, client_->state());
   ASSERT_NO_FATAL_FAILURE(token_fetcher_->OnTokenFetched(
       kToken, kSharedSecret));
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, host_->state());
   ASSERT_NO_FATAL_FAILURE(token_validator_->OnTokenValidated(std::string()));
 
   // The end result is that the host rejected the token.
   ASSERT_EQ(Authenticator::REJECTED, host_->state());
 }
 
-TEST_F(ThirdPartyAuthenticatorTest, MAYBE(CannotFetchToken)) {
+TEST_F(ThirdPartyAuthenticatorTest, CannotFetchToken) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators());
   ASSERT_NO_FATAL_FAILURE(RunHostInitiatedAuthExchange());
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, client_->state());
   ASSERT_NO_FATAL_FAILURE(
       token_fetcher_->OnTokenFetched(std::string(), std::string()));
 
   // The end result is that the client rejected the connection, since it
   // couldn't fetch the token.
   ASSERT_EQ(Authenticator::REJECTED, client_->state());
 }
 
 // Test that negotiation stops when the fake authentication is rejected.
-TEST_F(ThirdPartyAuthenticatorTest, MAYBE(HostBadSecret)) {
+TEST_F(ThirdPartyAuthenticatorTest, HostBadSecret) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators());
   ASSERT_NO_FATAL_FAILURE(RunHostInitiatedAuthExchange());
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, client_->state());
   ASSERT_NO_FATAL_FAILURE(token_fetcher_->OnTokenFetched(
       kToken, kSharedSecret));
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, host_->state());
   ASSERT_NO_FATAL_FAILURE(
       token_validator_->OnTokenValidated(kSharedSecretBad));
 
   // The end result is that the host rejected the fake authentication.
   ASSERT_EQ(Authenticator::REJECTED, client_->state());
 }
 
-TEST_F(ThirdPartyAuthenticatorTest, MAYBE(ClientBadSecret)) {
+TEST_F(ThirdPartyAuthenticatorTest, ClientBadSecret) {
   ASSERT_NO_FATAL_FAILURE(InitAuthenticators());
   ASSERT_NO_FATAL_FAILURE(RunHostInitiatedAuthExchange());
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, client_->state());
   ASSERT_NO_FATAL_FAILURE(
       token_fetcher_->OnTokenFetched(kToken, kSharedSecretBad));
   ASSERT_EQ(Authenticator::PROCESSING_MESSAGE, host_->state());
   ASSERT_NO_FATAL_FAILURE(
       token_validator_->OnTokenValidated(kSharedSecret));
 
   // The end result is that the host rejected the fake authentication.
   ASSERT_EQ(Authenticator::REJECTED, client_->state());
 }
 
 }  // namespace protocol
 }  // namespace remoting