--- a/media/mtransport/test/ice_unittest.cpp
+++ b/media/mtransport/test/ice_unittest.cpp
@@ -494,21 +494,20 @@ class IceTestPeer : public sigslot::has_
if (stream >= ice_ctx_->GetStreamCount() || !ice_ctx_->GetStream(stream)) {
EXPECT_TRUE(false) << "No such stream " << stream;
return candidates;
}
std::vector<std::string> candidates_in =
ice_ctx_->GetStream(stream)->GetCandidates();
-
for (size_t i=0; i < candidates_in.size(); i++) {
std::string candidate(FilterCandidate(candidates_in[i]));
if (!candidate.empty()) {
- std::cerr << "Returning candidate: " << candidate << std::endl;
+ std::cerr << name_ << " Returning candidate: " << candidate << std::endl;
candidates.push_back(candidate);
}
}
return candidates;
}
void SetExpectedTypes(NrIceCandidate::Type local,
@@ -575,31 +574,32 @@ class IceTestPeer : public sigslot::has_
void Connect_s(IceTestPeer *remote, TrickleMode trickle_mode,
bool start = true) {
nsresult res;
remote_ = remote;
trickle_mode_ = trickle_mode;
ice_complete_ = false;
+ ice_reached_checking_ = false;
res = ice_ctx_->ParseGlobalAttributes(remote->GetGlobalAttributes());
ASSERT_TRUE(NS_SUCCEEDED(res));
if (trickle_mode == TRICKLE_NONE ||
trickle_mode == TRICKLE_REAL) {
for (size_t i=0; i<ice_ctx_->GetStreamCount(); ++i) {
RefPtr<NrIceMediaStream> aStream = ice_ctx_->GetStream(i);
if (!aStream || aStream->HasParsedAttributes()) {
continue;
}
std::vector<std::string> candidates =
remote->GetCandidates(i);
for (size_t j=0; j<candidates.size(); ++j) {
- std::cerr << "Candidate: " + candidates[j] << std::endl;
+ std::cerr << name_ << " Candidate: " + candidates[j] << std::endl;
}
res = aStream->ParseAttributes(candidates);
ASSERT_TRUE(NS_SUCCEEDED(res));
}
} else {
// Parse empty attributes and then trickle them out later
for (size_t i=0; i<ice_ctx_->GetStreamCount(); ++i) {
RefPtr<NrIceMediaStream> aStream = ice_ctx_->GetStream(i);
@@ -624,17 +624,17 @@ class IceTestPeer : public sigslot::has_
bool start = true) {
test_utils->sts_target()->Dispatch(
WrapRunnable(
this, &IceTestPeer::Connect_s, remote, trickle_mode, start),
NS_DISPATCH_SYNC);
}
void SimulateTrickle(size_t stream) {
- std::cerr << "Doing trickle for stream " << stream << std::endl;
+ std::cerr << name_ << " Doing trickle for stream " << stream << std::endl;
// If we are in trickle deferred mode, now trickle in the candidates
// for |stream|
// The size of streams is not going to change out from under us, so should
// be safe here.
ASSERT_GT(remote_->ice_ctx_->GetStreamCount(), stream);
ASSERT_TRUE(remote_->ice_ctx_->GetStream(stream).get());
@@ -734,24 +734,24 @@ class IceTestPeer : public sigslot::has_
<< cand.cand_addr.transport
<< tcp_type
<< " codeword="
<< cand.codeword
<< std::endl;
}
void DumpAndCheckActiveCandidates_s() {
- std::cerr << "Active candidates:" << std::endl;
+ std::cerr << name_ << " Active candidates:" << std::endl;
for (size_t i=0; i < ice_ctx_->GetStreamCount(); ++i) {
if (!ice_ctx_->GetStream(i)) {
continue;
}
for (size_t j=0; j < ice_ctx_->GetStream(i)->components(); ++j) {
- std::cerr << "Stream " << i << " component " << j+1 << std::endl;
+ std::cerr << name_ << " Stream " << i << " component " << j+1 << std::endl;
NrIceCandidate *local;
NrIceCandidate *remote;
nsresult res = ice_ctx_->GetStream(i)->GetActivePair(j+1, &local, &remote);
if (res == NS_ERROR_NOT_AVAILABLE) {
std::cerr << "Component unpaired or disabled." << std::endl;
} else {
@@ -795,16 +795,17 @@ class IceTestPeer : public sigslot::has_
void Close() {
test_utils->sts_target()->Dispatch(
WrapRunnable(ice_ctx_, &NrIceCtx::destroy_peer_ctx),
NS_DISPATCH_SYNC);
}
void Shutdown() {
+ std::cerr << name_ << " Shutdown" << std::endl;
for (auto s = controlled_trickle_candidates_.begin();
s != controlled_trickle_candidates_.end();
++s) {
for (auto cand = s->second.begin(); cand != s->second.end(); ++cand) {
delete *cand;
}
}
@@ -837,17 +838,17 @@ class IceTestPeer : public sigslot::has_
(void)ctx;
if (state != NrIceCtx::ICE_CTX_GATHER_COMPLETE) {
return;
}
std::cerr << "Gathering complete for " << name_ << std::endl;
gathering_complete_ = true;
- std::cerr << "CANDIDATES:" << std::endl;
+ std::cerr << name_ << " CANDIDATES:" << std::endl;
for (size_t i=0; i<ice_ctx_->GetStreamCount(); ++i) {
std::cerr << "Stream " << name_ << std::endl;
if (!ice_ctx_->GetStream(i)) {
std::cerr << "DISABLED" << std::endl;
continue;
}
@@ -1027,60 +1028,60 @@ class IceTestPeer : public sigslot::has_
}
ASSERT_TRUE(removed_pairs.empty()) << "At least one candidate pair has "
"gone missing.";
}
void StreamReady(NrIceMediaStream *stream) {
++ready_ct_;
- std::cerr << "Stream ready " << stream->name() << " ct=" << ready_ct_ << std::endl;
+ std::cerr << "Stream ready for " << stream->name() << " ct=" << ready_ct_ << std::endl;
DumpCandidatePairs_s(stream);
}
void StreamFailed(NrIceMediaStream *stream) {
- std::cerr << "Stream failed " << stream->name() << " ct=" << ready_ct_ << std::endl;
+ std::cerr << "Stream failed for " << stream->name() << " ct=" << ready_ct_ << std::endl;
DumpCandidatePairs_s(stream);
}
void ConnectionStateChange(NrIceCtx* ctx,
NrIceCtx::ConnectionState state) {
(void)ctx;
switch (state) {
case NrIceCtx::ICE_CTX_INIT:
break;
case NrIceCtx::ICE_CTX_CHECKING:
- std::cerr << "ICE checking " << name_ << std::endl;
+ std::cerr << "ICE reached checking for " << name_ << std::endl;
ice_reached_checking_ = true;
break;
case NrIceCtx::ICE_CTX_OPEN:
- std::cerr << "ICE completed " << name_ << std::endl;
+ std::cerr << "ICE completed for " << name_ << std::endl;
ice_complete_ = true;
break;
case NrIceCtx::ICE_CTX_FAILED:
break;
}
}
void PacketReceived(NrIceMediaStream *stream, int component, const unsigned char *data,
int len) {
- std::cerr << "Received " << len << " bytes" << std::endl;
+ std::cerr << name_ << ": received " << len << " bytes" << std::endl;
++received_;
}
void SendPacket(int stream, int component, const unsigned char *data,
int len) {
if (!ice_ctx_->GetStream(stream)) {
ADD_FAILURE() << "No such stream " << stream;
return;
}
ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->GetStream(stream)->SendPacket(component, data, len)));
++sent_;
- std::cerr << "Sent " << len << " bytes" << std::endl;
+ std::cerr << name_ << ": sent " << len << " bytes" << std::endl;
}
void SetCandidateFilter(CandidateFilter filter) {
candidate_filter_ = filter;
}
void ParseCandidate_s(size_t i, const std::string& candidate) {
ASSERT_TRUE(ice_ctx_->GetStream(i).get()) << "No such stream " << i;
@@ -1365,16 +1366,17 @@ class IceGatherTest : public ::testing::
protected:
mozilla::ScopedDeletePtr<IceTestPeer> peer_;
};
class IceConnectTest : public ::testing::Test {
public:
IceConnectTest() :
initted_(false),
+ test_stun_server_initedd_(false),
use_nat_(false),
filtering_type_(TestNat::ENDPOINT_INDEPENDENT),
mapping_type_(TestNat::ENDPOINT_INDEPENDENT),
block_udp_(false) {}
void SetUp() {
nsresult rv;
target_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
@@ -1400,89 +1402,119 @@ class IceConnectTest : public ::testing:
p2_->AddStream(components);
}
void RemoveStream(size_t index) {
p1_->RemoveStream(index);
p2_->RemoveStream(index);
}
- void Init(bool allow_loopback, bool enable_tcp, bool default_only = false) {
- if (!initted_) {
- p1_ = new IceTestPeer("P1", true, allow_loopback,
- enable_tcp, false, default_only);
- p2_ = new IceTestPeer("P2", false, allow_loopback,
- enable_tcp, false, default_only);
+ void Init(bool allow_loopback,
+ bool enable_tcp,
+ bool default_only = false,
+ bool setupStunServers = true) {
+ if (initted_) {
+ return;
}
+
+ p1_ = new IceTestPeer("P1", true, allow_loopback,
+ enable_tcp, false, default_only);
+ p2_ = new IceTestPeer("P2", false, allow_loopback,
+ enable_tcp, false, default_only);
+ InitPeer(p1_, setupStunServers);
+ InitPeer(p2_, setupStunServers);
+
initted_ = true;
}
- bool Gather(unsigned int waitTime = kDefaultTimeout,
- bool setupStunServers = true) {
- Init(false, false);
+ void InitPeer(IceTestPeer* peer, bool setupStunServers = true) {
if (use_nat_) {
// If we enable nat simulation, but still use a real STUN server somewhere
// on the internet, we will see failures if there is a real NAT in
// addition to our simulated one, particularly if it disallows
// hairpinning.
if (setupStunServers) {
- UseTestStunServer();
+ InitTestStunServer();
+ peer->UseTestStunServer();
}
- p1_->UseNat();
- p2_->UseNat();
- p1_->SetFilteringType(filtering_type_);
- p2_->SetFilteringType(filtering_type_);
- p1_->SetMappingType(mapping_type_);
- p2_->SetMappingType(mapping_type_);
- p1_->SetBlockUdp(block_udp_);
- p2_->SetBlockUdp(block_udp_);
+ peer->UseNat();
+ peer->SetFilteringType(filtering_type_);
+ peer->SetMappingType(mapping_type_);
+ peer->SetBlockUdp(block_udp_);
} else if (setupStunServers) {
std::vector<NrIceStunServer> stun_servers;
stun_servers.push_back(*NrIceStunServer::Create(g_stun_server_address,
kDefaultStunServerPort, kNrIceTransportUdp));
stun_servers.push_back(*NrIceStunServer::Create(g_stun_server_address,
kDefaultStunServerPort, kNrIceTransportTcp));
- p1_->SetStunServers(stun_servers);
- p2_->SetStunServers(stun_servers);
+ peer->SetStunServers(stun_servers);
}
-
- p1_->Gather();
- p2_->Gather();
+ }
+
+ bool Gather(unsigned int waitTime = kDefaultTimeout) {
+ Init(false, false);
+
+ return GatherCallerAndCallee(p1_, p2_, waitTime);
+ }
+
+ bool GatherCallerAndCallee(IceTestPeer* caller,
+ IceTestPeer* callee,
+ unsigned int waitTime = kDefaultTimeout) {
+ caller->Gather();
+ callee->Gather();
if (waitTime) {
- EXPECT_TRUE_WAIT(p1_->gathering_complete(), waitTime);
- if (!p1_->gathering_complete())
+ EXPECT_TRUE_WAIT(caller->gathering_complete(), waitTime);
+ if (!caller->gathering_complete())
return false;
- EXPECT_TRUE_WAIT(p2_->gathering_complete(), waitTime);
- if (!p2_->gathering_complete())
+ EXPECT_TRUE_WAIT(callee->gathering_complete(), waitTime);
+ if (!callee->gathering_complete())
return false;
}
return true;
}
void UseNat() {
+ // to be useful, this method should be called before Init
+ ASSERT_FALSE(initted_);
use_nat_ = true;
}
void SetFilteringType(TestNat::NatBehavior type) {
+ // to be useful, this method should be called before Init
+ ASSERT_FALSE(initted_);
filtering_type_ = type;
}
void SetMappingType(TestNat::NatBehavior type) {
+ // to be useful, this method should be called before Init
+ ASSERT_FALSE(initted_);
mapping_type_ = type;
}
void BlockUdp() {
+ // to be useful, this method should be called before Init
+ ASSERT_FALSE(initted_);
block_udp_ = true;
}
+ void InitTestStunServer() {
+ if (test_stun_server_initedd_) {
+ return;
+ }
+
+ std::cerr << "Resetting TestStunServer" << std::endl;
+ TestStunServer::GetInstance(AF_INET)->Reset();
+ test_stun_server_initedd_ = true;
+ }
+
void UseTestStunServer() {
- TestStunServer::GetInstance(AF_INET)->Reset();
+ InitTestStunServer();
p1_->UseTestStunServer();
p2_->UseTestStunServer();
}
void SetTurnServer(const std::string addr, uint16_t port,
const std::string username,
const std::string password,
const char* transport = kNrIceTransportUdp) {
@@ -1498,31 +1530,44 @@ class IceConnectTest : public ::testing:
void SetCandidateFilter(CandidateFilter filter, bool both=true) {
p1_->SetCandidateFilter(filter);
if (both) {
p2_->SetCandidateFilter(filter);
}
}
void Connect() {
+ ConnectCallerAndCallee(p2_, p1_);
+ }
+
+ void ConnectCallerAndCallee(IceTestPeer* caller, IceTestPeer* callee) {
+ ASSERT_TRUE(caller->ready_ct() == 0 &&
+ caller->ice_complete() == 0 &&
+ caller->ice_reached_checking() == 0);
+ ASSERT_TRUE(callee->ready_ct() == 0 &&
+ callee->ice_complete() == 0 &&
+ callee->ice_reached_checking() == 0);
+
// IceTestPeer::Connect grabs attributes from the first arg, and gives them
// to |this|, meaning that p2_->Connect(p1_, ...) simulates p1 sending an
// offer to p2. Order matters here because it determines which peer is
// controlling.
- p2_->Connect(p1_, TRICKLE_NONE);
- p1_->Connect(p2_, TRICKLE_NONE);
-
- ASSERT_TRUE_WAIT(p1_->ready_ct() == 1 && p2_->ready_ct() == 1,
+ caller->Connect(callee, TRICKLE_NONE);
+ callee->Connect(caller, TRICKLE_NONE);
+
+ ASSERT_TRUE_WAIT(callee->ready_ct() == 1 && caller->ready_ct() == 1,
+ kDefaultTimeout);
+ ASSERT_TRUE_WAIT(callee->ice_complete() && caller->ice_complete(),
kDefaultTimeout);
- ASSERT_TRUE_WAIT(p1_->ice_complete() && p2_->ice_complete(),
- kDefaultTimeout);
- AssertCheckingReached();
-
- p1_->DumpAndCheckActiveCandidates();
- p2_->DumpAndCheckActiveCandidates();
+
+ ASSERT_TRUE(callee->ice_reached_checking());
+ ASSERT_TRUE(caller->ice_reached_checking());
+
+ callee->DumpAndCheckActiveCandidates();
+ caller->DumpAndCheckActiveCandidates();
}
void SetExpectedTypes(NrIceCandidate::Type local, NrIceCandidate::Type remote,
std::string transport = kNrIceTransportUdp) {
p1_->SetExpectedTypes(local, remote, transport);
p2_->SetExpectedTypes(local, remote, transport);
}
@@ -1596,29 +1641,45 @@ class IceConnectTest : public ::testing:
&IceConnectTest::CloseP1),
NS_DISPATCH_SYNC);
p2_->StartChecks();
// Wait to see if we crash
PR_Sleep(PR_MillisecondsToInterval(kDefaultTimeout));
}
+ // default is p1_ sending to p2_
void SendReceive() {
- // p1_->Send(2);
+ SendReceive(p1_, p2_);
+ }
+
+ void SendReceive(IceTestPeer *p1, IceTestPeer *p2,
+ bool expectTxFailure = false,
+ bool expectRxFailure = false) {
test_utils->sts_target()->Dispatch(
- WrapRunnable(p1_.get(),
+ WrapRunnable(p1,
&IceTestPeer::SendPacket, 0, 1,
reinterpret_cast<const unsigned char *>("TEST"), 4),
NS_DISPATCH_SYNC);
- ASSERT_EQ(1u, p1_->sent());
- ASSERT_TRUE_WAIT(p2_->received() == 1, 1000);
+ if (expectTxFailure) {
+ ASSERT_NE(1u, p1->sent());
+ } else {
+ ASSERT_EQ(1u, p1->sent());
+ }
+ if (expectRxFailure) {
+ usleep(1000);
+ ASSERT_TRUE(p2->received() == 0);
+ } else {
+ ASSERT_TRUE_WAIT(p2->received() == 1, 1000);
+ }
}
protected:
bool initted_;
+ bool test_stun_server_initedd_;
nsCOMPtr<nsIEventTarget> target_;
mozilla::ScopedDeletePtr<IceTestPeer> p1_;
mozilla::ScopedDeletePtr<IceTestPeer> p2_;
bool use_nat_;
TestNat::NatBehavior filtering_type_;
TestNat::NatBehavior mapping_type_;
bool block_udp_;
};
@@ -2172,20 +2233,20 @@ TEST_F(IceConnectTest, DISABLED_TestConn
AddStream("first", 1);
ASSERT_TRUE(Gather());
SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
NrIceCandidate::Type::ICE_SERVER_REFLEXIVE, kNrIceTransportTcp);
Connect();
}
TEST_F(IceConnectTest, TestLoopbackOnlySortOf) {
- Init(true, false);
+ Init(true, false, false, false);
AddStream("first", 1);
SetCandidateFilter(IsLoopbackCandidate);
- ASSERT_TRUE(Gather(kDefaultTimeout, false));
+ ASSERT_TRUE(Gather());
SetExpectedRemoteCandidateAddr("127.0.0.1");
Connect();
}
TEST_F(IceConnectTest, TestConnectBothControllingP1Wins) {
AddStream("first", 1);
p1_->SetTiebreaker(1);
p2_->SetTiebreaker(0);
@@ -2247,140 +2308,132 @@ TEST_F(IceConnectTest, TestTrickleIceLit
ConnectTrickle();
SimulateTrickle(0);
ASSERT_TRUE_WAIT(p1_->ice_complete(), 1000);
ASSERT_TRUE_WAIT(p2_->ice_complete(), 1000);
AssertCheckingReached();
}
TEST_F(IceConnectTest, TestGatherFullCone) {
+ UseNat();
AddStream("first", 1);
- UseNat();
- SetFilteringType(TestNat::ENDPOINT_INDEPENDENT);
- SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
ASSERT_TRUE(Gather());
}
TEST_F(IceConnectTest, TestGatherFullConeAutoPrioritize) {
+ UseNat();
Init(true, false);
AddStream("first", 1);
- UseNat();
- SetFilteringType(TestNat::ENDPOINT_INDEPENDENT);
- SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
ASSERT_TRUE(Gather());
}
TEST_F(IceConnectTest, TestConnectFullCone) {
+ UseNat();
AddStream("first", 1);
- UseNat();
- SetFilteringType(TestNat::ENDPOINT_INDEPENDENT);
- SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
ASSERT_TRUE(Gather());
Connect();
}
TEST_F(IceConnectTest, TestConnectNoNatRouteOnly) {
- Init(false, false, true);
+ Init(false, false, true, false);
AddStream("first", 1);
UseTestStunServer();
// Because we are connecting from our host candidate to the
// other side's apparent srflx (which is also their host)
// we see a host/srflx pair.
SetExpectedTypes(NrIceCandidate::Type::ICE_HOST,
NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
- ASSERT_TRUE(Gather(kDefaultTimeout, false));
+ ASSERT_TRUE(Gather());
Connect();
}
TEST_F(IceConnectTest, TestConnectFullConeDefaultRouteOnly) {
+ UseNat();
Init(false, false, true);
AddStream("first", 1);
- UseNat();
- SetFilteringType(TestNat::ENDPOINT_INDEPENDENT);
- SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
ASSERT_TRUE(Gather());
Connect();
}
TEST_F(IceConnectTest, TestGatherAddressRestrictedCone) {
- AddStream("first", 1);
UseNat();
SetFilteringType(TestNat::ADDRESS_DEPENDENT);
SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+ AddStream("first", 1);
ASSERT_TRUE(Gather());
}
TEST_F(IceConnectTest, TestConnectAddressRestrictedCone) {
- AddStream("first", 1);
UseNat();
SetFilteringType(TestNat::ADDRESS_DEPENDENT);
SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+ AddStream("first", 1);
SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
ASSERT_TRUE(Gather());
Connect();
}
TEST_F(IceConnectTest, TestGatherPortRestrictedCone) {
- AddStream("first", 1);
UseNat();
SetFilteringType(TestNat::PORT_DEPENDENT);
SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+ AddStream("first", 1);
ASSERT_TRUE(Gather());
}
TEST_F(IceConnectTest, TestConnectPortRestrictedCone) {
- AddStream("first", 1);
UseNat();
SetFilteringType(TestNat::PORT_DEPENDENT);
SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+ AddStream("first", 1);
SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
ASSERT_TRUE(Gather());
Connect();
}
TEST_F(IceConnectTest, TestGatherSymmetricNat) {
- AddStream("first", 1);
UseNat();
SetFilteringType(TestNat::PORT_DEPENDENT);
SetMappingType(TestNat::PORT_DEPENDENT);
+ AddStream("first", 1);
ASSERT_TRUE(Gather());
}
TEST_F(IceConnectTest, TestConnectSymmetricNat) {
if (g_turn_server.empty())
return;
- AddStream("first", 1);
UseNat();
SetFilteringType(TestNat::PORT_DEPENDENT);
SetMappingType(TestNat::PORT_DEPENDENT);
+ AddStream("first", 1);
p1_->SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
NrIceCandidate::Type::ICE_RELAYED);
p2_->SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
NrIceCandidate::Type::ICE_RELAYED);
SetTurnServer(g_turn_server, kDefaultStunServerPort,
g_turn_user, g_turn_password);
ASSERT_TRUE(Gather());
Connect();
}
TEST_F(IceConnectTest, TestGatherNatBlocksUDP) {
if (g_turn_server.empty())
return;
- AddStream("first", 1);
UseNat();
BlockUdp();
+ AddStream("first", 1);
std::vector<NrIceTurnServer> turn_servers;
std::vector<unsigned char> password_vec(g_turn_password.begin(),
g_turn_password.end());
turn_servers.push_back(
*NrIceTurnServer::Create(g_turn_server, kDefaultStunServerPort,
g_turn_user, password_vec, kNrIceTransportTcp));
turn_servers.push_back(
*NrIceTurnServer::Create(g_turn_server, kDefaultStunServerPort,
@@ -2389,19 +2442,19 @@ TEST_F(IceConnectTest, TestGatherNatBloc
// We have to wait for the UDP-based stuff to time out.
ASSERT_TRUE(Gather(kDefaultTimeout * 3));
}
TEST_F(IceConnectTest, TestConnectNatBlocksUDP) {
if (g_turn_server.empty())
return;
- AddStream("first", 1);
UseNat();
BlockUdp();
+ AddStream("first", 1);
std::vector<NrIceTurnServer> turn_servers;
std::vector<unsigned char> password_vec(g_turn_password.begin(),
g_turn_password.end());
turn_servers.push_back(
*NrIceTurnServer::Create(g_turn_server, kDefaultStunServerPort,
g_turn_user, password_vec, kNrIceTransportTcp));
turn_servers.push_back(
*NrIceTurnServer::Create(g_turn_server, kDefaultStunServerPort,
@@ -2947,18 +3000,19 @@ TEST_F(IceConnectTest, TestPollCandPairs
r = p2_->GetCandidatePairs(0, &pairs);
ASSERT_EQ(NS_OK, r);
ASSERT_NE(0U, pairs.size());
ASSERT_TRUE(p2_->CandidatePairsPriorityDescending(pairs));
ASSERT_TRUE(ContainsSucceededPair(pairs));
}
TEST_F(IceConnectTest, TestHostCandPairingFilter) {
+ Init(false, false, false, false);
AddStream("first", 1);
- ASSERT_TRUE(Gather(kDefaultTimeout, false));
+ ASSERT_TRUE(Gather(kDefaultTimeout));
SetCandidateFilter(IsIpv4Candidate);
int host_net = p1_->GetCandidatesPrivateIpv4Range(0);
if (host_net <= 0) {
// TODO bug 1226838: make this work with multiple private IPs
FAIL() << "This test needs exactly one private IPv4 host candidate to work" << std::endl;
}
@@ -2980,16 +3034,17 @@ TEST_F(IceConnectTest, TestHostCandPairi
}
// TODO Bug 1226838 - See Comment 2 - this test can't work as written
TEST_F(IceConnectTest, DISABLED_TestSrflxCandPairingFilter) {
if (g_stun_server_address.empty()) {
return;
}
+ Init(false, false, false, false);
AddStream("first", 1);
ASSERT_TRUE(Gather(kDefaultTimeout));
SetCandidateFilter(IsSrflxCandidate);
if (p1_->GetCandidatesPrivateIpv4Range(0) <= 0) {
// TODO bug 1226838: make this work with public IP addresses
std::cerr << "Don't run this test at IETF meetings!" << std::endl;
FAIL() << "This test needs one private IPv4 host candidate to work" << std::endl;