401 строка
12 KiB
C#
401 строка
12 KiB
C#
#if !__WATCHOS__
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
#if XAMCORE_2_0
|
|
using CoreFoundation;
|
|
using Foundation;
|
|
using Network;
|
|
using ObjCRuntime;
|
|
using Security;
|
|
#else
|
|
using MonoTouch.CoreFoundation;
|
|
using MonoTouch.Foundation;
|
|
using MonoTouch.Network;
|
|
using MonoTouch.Security;
|
|
#endif
|
|
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTouchFixtures.Network {
|
|
|
|
[TestFixture]
|
|
[Preserve (AllMembers = true)]
|
|
public class NWParametersTest {
|
|
|
|
AutoResetEvent secureEvent; // used to let us know the handler was indeed called.
|
|
AutoResetEvent configureEvent; // used to let us know the handler was indeed called.
|
|
AutoResetEvent connectedEvent; // used to let us know when the connection was established so that we can access the NWPath
|
|
bool secureConnectionWasSet = false;
|
|
bool protocolConfigured = false;
|
|
List<NWInterface> interfaces = new List<NWInterface> ();
|
|
string host;
|
|
NWConnection connection;
|
|
|
|
|
|
[TestFixtureSetUp]
|
|
public void Init ()
|
|
{
|
|
TestRuntime.AssertXcodeVersion (10, 0);
|
|
// we want to use a single connection, since it is expensive
|
|
connectedEvent = new AutoResetEvent(false);
|
|
host = "www.google.com";
|
|
interfaces = new List<NWInterface> ();
|
|
using (var parameters = NWParameters.CreateUdp ())
|
|
using (var endpoint = NWEndpoint.Create (host, "80")) {
|
|
connection = new NWConnection (endpoint, parameters);
|
|
connection.SetQueue (DispatchQueue.DefaultGlobalQueue); // important, else we will get blocked
|
|
connection.SetStateChangeHandler (ConnectionStateHandler);
|
|
connection.Start ();
|
|
Assert.True (connectedEvent.WaitOne (20000), "Connection timed out.");
|
|
using (var path = connection.CurrentPath)
|
|
{
|
|
path.EnumerateInterfaces (EnumerateInterfacesHandler);
|
|
}
|
|
}
|
|
}
|
|
|
|
[TestFixtureTearDown]
|
|
public void Dispose()
|
|
{
|
|
connection?.Cancel ();
|
|
}
|
|
|
|
[SetUp]
|
|
public void SetUp ()
|
|
{
|
|
secureEvent = new AutoResetEvent(false);
|
|
configureEvent = new AutoResetEvent(false);
|
|
secureConnectionWasSet = false;
|
|
protocolConfigured = false;
|
|
}
|
|
|
|
void ConnectionStateHandler (NWConnectionState state, NWError error)
|
|
{
|
|
switch (state){
|
|
case NWConnectionState.Ready:
|
|
connectedEvent.Set ();
|
|
break;
|
|
case NWConnectionState.Cancelled:
|
|
connection?.Dispose ();
|
|
connection = null;
|
|
foreach (var i in interfaces)
|
|
i.Dispose ();
|
|
break;
|
|
case NWConnectionState.Invalid:
|
|
case NWConnectionState.Failed:
|
|
Assert.Inconclusive ("Network connection could not be performed.");
|
|
break;
|
|
}
|
|
}
|
|
|
|
[TearDown]
|
|
public void TearDown ()
|
|
{
|
|
secureEvent = null;
|
|
secureConnectionWasSet = false;
|
|
protocolConfigured = false;
|
|
}
|
|
|
|
void EnumerateInterfacesHandler (NWInterface nwInterface)
|
|
{
|
|
interfaces.Add (nwInterface);
|
|
}
|
|
|
|
Action<NWProtocolOptions> CreateTlsHandler ()
|
|
{
|
|
return (NWProtocolOptions options) => {
|
|
secureConnectionWasSet = true;
|
|
secureEvent.Set ();
|
|
};
|
|
}
|
|
|
|
Action<NWProtocolOptions> CreateConfigureProtocolHandler ()
|
|
{
|
|
return (NWProtocolOptions options) => {
|
|
protocolConfigured = true;
|
|
configureEvent.Set ();
|
|
};
|
|
}
|
|
|
|
[Test]
|
|
public void CreateSecureUpdTest ()
|
|
{
|
|
var setUpTls = CreateTlsHandler ();
|
|
var setUpProtocol = CreateConfigureProtocolHandler ();
|
|
|
|
using (var parameters = NWParameters.CreateSecureUdp (configureTls: setUpTls, configureUdp: setUpProtocol))
|
|
using (var endpoint = NWEndpoint.Create ("wwww.google.com", "80"))
|
|
using (var connection = new NWConnection (endpoint, parameters)) {
|
|
connection.SetQueue (DispatchQueue.MainQueue);
|
|
connection.Start ();
|
|
secureEvent.WaitOne ();
|
|
configureEvent.WaitOne ();
|
|
connection.Cancel ();
|
|
Assert.True (secureConnectionWasSet, "Configure TLS handler was not called.");
|
|
Assert.True (protocolConfigured, "Protocol configure handler was not called.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CreateSecureUpdTestDoNotSetUpProtocol ()
|
|
{
|
|
var setUpTls = CreateTlsHandler ();
|
|
|
|
using (var parameters = NWParameters.CreateSecureUdp (configureTls: setUpTls))
|
|
using (var endpoint = NWEndpoint.Create ("wwww.google.com", "80"))
|
|
using (var connection = new NWConnection (endpoint, parameters)) {
|
|
connection.SetQueue (DispatchQueue.MainQueue);
|
|
connection.Start ();
|
|
secureEvent.WaitOne ();
|
|
connection.Cancel ();
|
|
Assert.True (secureConnectionWasSet, "Configure TLS handler was not called.");
|
|
Assert.False (protocolConfigured, "Protocol configure handler was called.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CreateSecureUpdTestDoNotSetUpTls ()
|
|
{
|
|
var setUpProtocol = CreateConfigureProtocolHandler ();
|
|
|
|
using (var parameters = NWParameters.CreateSecureUdp (configureTls: null, configureUdp: setUpProtocol))
|
|
using (var endpoint = NWEndpoint.Create ("wwww.google.com", "80"))
|
|
using (var connection = new NWConnection (endpoint, parameters)) {
|
|
connection.SetQueue (DispatchQueue.MainQueue);
|
|
connection.Start ();
|
|
configureEvent.WaitOne ();
|
|
connection.Cancel ();
|
|
Assert.False (secureConnectionWasSet, "Configure TLS handler was not called.");
|
|
Assert.True (protocolConfigured, "Protocol configure handler was not called.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CreateSecureTcpTest ()
|
|
{
|
|
var setUpTls = CreateTlsHandler ();
|
|
var setUpProtocol = CreateConfigureProtocolHandler ();
|
|
|
|
using (var parameters = NWParameters.CreateSecureTcp (configureTls: setUpTls, configureTcp: setUpProtocol))
|
|
using (var endpoint = NWEndpoint.Create ("wwww.google.com", "80"))
|
|
using (var connection = new NWConnection (endpoint, parameters)) {
|
|
connection.SetQueue (DispatchQueue.MainQueue);
|
|
connection.Start ();
|
|
secureEvent.WaitOne ();
|
|
configureEvent.WaitOne ();
|
|
connection.Cancel ();
|
|
Assert.True (secureConnectionWasSet, "Configure TLS handler was not called.");
|
|
Assert.True (protocolConfigured, "Protocol configure handler was not called.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CreateSecureTcpTestDoNotSetUpProtocol ()
|
|
{
|
|
var setUpTls = CreateTlsHandler ();
|
|
var setUpProtocol = CreateConfigureProtocolHandler ();
|
|
|
|
using (var parameters = NWParameters.CreateSecureTcp (configureTls: setUpTls))
|
|
using (var endpoint = NWEndpoint.Create ("wwww.google.com", "80"))
|
|
using (var connection = new NWConnection (endpoint, parameters)) {
|
|
connection.SetQueue (DispatchQueue.MainQueue);
|
|
connection.Start ();
|
|
secureEvent.WaitOne ();
|
|
connection.Cancel ();
|
|
Assert.True (secureConnectionWasSet, "Configure TLS handler was not called.");
|
|
Assert.False (protocolConfigured, "Protocol configure handler was called.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CreateSecureTcpTestDoNotSetUpTls ()
|
|
{
|
|
var setUpProtocol = CreateConfigureProtocolHandler ();
|
|
|
|
using (var parameters = NWParameters.CreateSecureTcp (configureTls: null, configureTcp: setUpProtocol))
|
|
using (var endpoint = NWEndpoint.Create ("wwww.google.com", "80"))
|
|
using (var connection = new NWConnection (endpoint, parameters)) {
|
|
connection.SetQueue (DispatchQueue.MainQueue);
|
|
connection.Start ();
|
|
configureEvent.WaitOne ();
|
|
connection.Cancel ();
|
|
Assert.False (secureConnectionWasSet, "Configure TLS handler was called.");
|
|
Assert.True (protocolConfigured, "Protocol configure handler was not called.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void MultiPathServicePropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.MultipathService;
|
|
Assert.AreEqual (defaultValue, NWMultiPathService.Disabled, "Default value changed.");
|
|
var newValue = NWMultiPathService.Aggregate;
|
|
parameters.MultipathService = newValue;
|
|
Assert.AreEqual (newValue, parameters.MultipathService, "New value was not stored.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ProtocolStackPropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var stack = parameters.ProtocolStack;
|
|
Assert.AreNotEqual (IntPtr.Zero, stack.Handle);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void LocalOnlyPropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.LocalOnly;
|
|
Assert.False (defaultValue, "Default value changed.");
|
|
parameters.LocalOnly = true;
|
|
Assert.True (parameters.LocalOnly, "New value was not stored.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void PreferNoProxyPropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.PreferNoProxy;
|
|
Assert.False (defaultValue, "Default value changed.");
|
|
parameters.PreferNoProxy = true;
|
|
Assert.True (parameters.PreferNoProxy, "New value was not stored.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ExpiredDnsBehaviorPropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.ExpiredDnsBehavior;
|
|
Assert.AreEqual (NWParametersExpiredDnsBehavior.Default, defaultValue, "Default value changed.");
|
|
parameters.ExpiredDnsBehavior = NWParametersExpiredDnsBehavior.Allow;
|
|
Assert.AreEqual (NWParametersExpiredDnsBehavior.Allow, parameters.ExpiredDnsBehavior, "New value was not stored.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void RequiredInterfacePropertyTest ()
|
|
{
|
|
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.RequiredInterface;
|
|
Assert.IsNull (defaultValue, "Default value changed.");
|
|
// try to set a null value, we should have no issues
|
|
parameters.RequiredInterface = null;
|
|
Assert.IsNull (parameters.RequiredInterface, "Value should still be null.");
|
|
parameters.RequiredInterface = interfaces[0];
|
|
Assert.AreNotEqual (IntPtr.Zero, parameters.RequiredInterface.Handle, "New value was not set.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ProhibitInterfaceTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
Assert.Throws<ArgumentNullException> (() => parameters.ProhibitInterface (null), "");
|
|
Assert.AreNotEqual (0, interfaces.Count, "No network interfaces found.");
|
|
parameters.ProhibitInterface (interfaces[0]);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void RequiredInterfaceTypePropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.RequiredInterfaceType;
|
|
Assert.AreEqual (NWInterfaceType.Other, defaultValue, "Default value changed.");
|
|
parameters.RequiredInterfaceType = NWInterfaceType.Wifi;
|
|
Assert.AreEqual (NWInterfaceType.Wifi, parameters.RequiredInterfaceType, "BNe value was not stored.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ProhibitInterfaceTypeTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var types = new List<NWInterfaceType> ();
|
|
parameters.ProhibitInterfaceType (NWInterfaceType.Wifi);
|
|
parameters.IterateProhibitedInterfaces ((type) => {types.Add (type); return true;} );
|
|
Assert.True (types.Contains (NWInterfaceType.Wifi), "Type was not prohibited.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ReuseLocalAddressPropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.ReuseLocalAddress;
|
|
Assert.False (defaultValue, "Default value changed.");
|
|
parameters.ReuseLocalAddress = true;
|
|
Assert.True (parameters.ReuseLocalAddress, "New value was not stored.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void FastOpenEnabledPropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.FastOpenEnabled;
|
|
Assert.False (defaultValue, "Defalue value changed.");
|
|
parameters.FastOpenEnabled = true;
|
|
Assert.True (parameters.FastOpenEnabled, "New value was not stored.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ServiceClassPropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.ServiceClass;
|
|
Assert.AreEqual (NWServiceClass.BestEffort, defaultValue, "Default value changed.");
|
|
parameters.ServiceClass = NWServiceClass.InteractiveVideo;
|
|
Assert.AreEqual (NWServiceClass.InteractiveVideo, parameters.ServiceClass, "New value was not stored.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void LocalEndpointPropertyTest ()
|
|
{
|
|
Assert.Ignore ("nw_parameters_copy_local_endpoint always return null. Rdar filled 44095278.");
|
|
using (var parameters = NWParameters.CreateUdp ())
|
|
using (var endpoint = NWEndpoint.Create ("wwww.google.com", "80"))
|
|
{
|
|
var defaultValue = parameters.LocalEndpoint;
|
|
Assert.IsNull (defaultValue, "Default value changed.");
|
|
parameters.LocalEndpoint = endpoint;
|
|
Assert.IsNotNull (parameters.LocalEndpoint, "New value was not stored.");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void IncludePeerToPeerPropertyTest ()
|
|
{
|
|
using (var parameters = new NWParameters ())
|
|
{
|
|
var defaultValue = parameters.IncludePeerToPeer;
|
|
Assert.False (defaultValue, "Default value changed.");
|
|
parameters.IncludePeerToPeer = true;
|
|
Assert.True (parameters.IncludePeerToPeer, "New value was not stored.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif |