private void ExecuteInternal()
{
try
{
WiFiDirectTestController disconnectTestController = localWFDController;
WiFiDirectTestController otherTestController = remoteWFDController;
WiFiDirectTestLogger.Log(
"Starting Disconnect for session with handle {0} on device {1} ({2}), expect session with handle {3} to close on device {4} ({5})",
disconnectParameters.SessionHandle,
disconnectTestController.DeviceAddress,
disconnectTestController.MachineName,
disconnectParameters.OtherSessionHandle,
otherTestController.DeviceAddress,
otherTestController.MachineName
);
disconnectTestController.DisconnectServiceSession(disconnectParameters.SessionHandle);
otherTestController.WaitForDisconnectServiceSession(disconnectParameters.OtherSessionHandle);
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service session disconnect scenario: {0}", e);
}
}
public ReconnectScenarioResult Execute()
{
try
{
bool pairingSucceeded = Pair();
if (!pairingSucceeded)
{
return(new ReconnectScenarioResult(false));
}
Disconnect();
bool discoverySucceeded = Discover();
if (!discoverySucceeded)
{
return(new ReconnectScenarioResult(false));
}
Reconnect();
WiFiDirectTestUtilities.RunDataPathValidation(localWFDController, remoteWFDController);
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing reconnect scenario: {0}", e);
return(new ReconnectScenarioResult(false));
}
return(new ReconnectScenarioResult(true));
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log("Beginning Discover/Connect scenario");
// Do all discovers
foreach (var discoveryParams in discoveryConnectParameters.DiscoveryParameters)
{
var discoveryScenario = new ServicesDiscoveryScenario(seekerTestController, advertiserTestController, discoveryParams);
ServicesDiscoveryScenarioResult discoveryResult = discoveryScenario.Execute();
discoveryResults.Add(discoveryResult);
if (!discoveryResult.ScenarioSucceeded)
{
throw new Exception("Discovery failed!");
}
}
// BUG: [TH2] Fix race on back-to-back discoveries
Task.Delay(500).Wait();
// Do all connects
foreach (var connectPreParams in discoveryConnectParameters.ConnectParameters)
{
// Need to translate indices to handles
if (connectPreParams.DiscoveryResultIndex > discoveryResults.Count ||
connectPreParams.DiscoveryResultIndex < 0 ||
connectPreParams.DiscoveredHandleIndex > discoveryResults[connectPreParams.DiscoveryResultIndex].DiscoveryHandles.Count ||
connectPreParams.DiscoveredHandleIndex < 0)
{
throw new Exception("Bad connect parameters! Index out of range for discovered device");
}
WFDSvcWrapperHandle discoveredDevice = discoveryResults[connectPreParams.DiscoveryResultIndex].DiscoveryHandles[connectPreParams.DiscoveredHandleIndex];
// Now run scenario
ServicesConnectParameters connectParams = new ServicesConnectParameters(
discoveredDevice,
connectPreParams.AdvertiserHandle,
connectPreParams.Options
);
var connectScenario = new ServicesConnectScenario(seekerTestController, advertiserTestController, connectParams);
ServicesConnectScenarioResult connectResult = connectScenario.Execute();
connectResults.Add(connectResult);
if (!connectResult.ScenarioSucceeded)
{
throw new Exception("Connect failed!");
}
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service discover/connect scenario: {0}", e);
}
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Starting Discovery for \"{0}\" on device {1} ({2})",
discoveryParameters.Query,
discoveryTestController.DeviceAddress,
discoveryTestController.MachineName
);
if (discoveryParameters.Type == ServicesDiscoveryType.FindAllAsync)
{
DoFindAllDiscovery();
}
else if (discoveryParameters.Type == ServicesDiscoveryType.Watcher)
{
DoWatcherDiscovery();
}
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service discovery scenario: {0}", e);
}
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Starting Publish for service \"{0}\" on device {1} ({2})",
publishParameters.ServiceName,
advertisingWFDController.DeviceAddress,
advertisingWFDController.MachineName
);
List <WiFiDirectServiceConfigurationMethod> configMethods = null;
if (publishParameters.ConfigMethods != ServicePublishConfigMethods.NotSet)
{
configMethods = new List <WiFiDirectServiceConfigurationMethod>();
if (publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOnlyDisplay ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOnlyDisplayKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOrDefaultDisplay ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.Any)
{
configMethods.Add(WiFiDirectServiceConfigurationMethod.PinDisplay);
}
if (publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOnlyKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOnlyDisplayKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOrDefaultKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.Any)
{
configMethods.Add(WiFiDirectServiceConfigurationMethod.PinEntry);
}
if (publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOrDefaultDisplay ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.PinOrDefaultKeypad ||
publishParameters.ConfigMethods == ServicePublishConfigMethods.Any)
{
configMethods.Add(WiFiDirectServiceConfigurationMethod.Default);
}
}
handle = advertisingWFDController.PublishService(
publishParameters.ServiceName,
publishParameters.AutoAccept,
publishParameters.PreferGO,
configMethods,
WiFiDirectServiceStatus.Available, // TODO status
0, // TODO custom status
publishParameters.ServiceInfo,
publishParameters.SessionInfo,
publishParameters.PrefixList
);
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service publish scenario: {0}", e);
}
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log("Beginning Publish/Discover scenario");
// Do all publications
foreach (var publishParams in publishDiscoveryParameters.PublishParameters)
{
var publishScenario = new ServicesPublishScenario(advertiserTestController, publishParams);
ServicesPublishScenarioResult publishResult = publishScenario.Execute();
publishResults.Add(publishResult);
if (!publishResult.ScenarioSucceeded)
{
throw new Exception("Publication failed!");
}
}
// Do all discoveries
foreach (var discoveryPreParams in publishDiscoveryParameters.DiscoveryParameters)
{
// Need to translate indices to handles
List <WFDSvcWrapperHandle> advertisersToMatch = new List <WFDSvcWrapperHandle>();
foreach (int i in discoveryPreParams.AdvertisersToMatchIndices)
{
if (i > publishResults.Count || i < 0)
{
throw new Exception("Bad discovery parameters! Index out of range");
}
advertisersToMatch.Add(publishResults[i].AdvertiserHandle);
}
ServicesDiscoveryParameters discoveryParams = new ServicesDiscoveryParameters(
discoveryPreParams.Parameters.Query,
discoveryPreParams.Parameters.ExpectedMatchCount,
advertisersToMatch,
discoveryPreParams.Parameters.Type,
discoveryPreParams.Parameters.ServiceInfoRequest,
discoveryPreParams.Parameters.AdvertiserServiceInfoMatch
);
var discoveryScenario = new ServicesDiscoveryScenario(discoveryTestController, advertiserTestController, discoveryParams);
ServicesDiscoveryScenarioResult discoveryResult = discoveryScenario.Execute();
discoveryResults.Add(discoveryResult);
if (!discoveryResult.ScenarioSucceeded)
{
throw new Exception("Discovery failed!");
}
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service publish/discovery scenario: {0}", e);
}
}
public void RemoveSession(WFDSvcWrapperHandle handle)
{
bool fRemoved = sessionCollection.Remove(handle);
if (!fRemoved)
{
WiFiDirectTestLogger.Error("Remove session failed to find session in list! (Session={0})", handle);
throw new Exception("Failed to remove session");
}
}
public void RemoveDiscovery(WFDSvcWrapperHandle handle)
{
bool fRemoved = discoveryCollection.Remove(handle);
if (!fRemoved)
{
WiFiDirectTestLogger.Error("Remove discovery failed to find discovery in list! (Session={0})", handle);
throw new Exception("Failed to remove discovery");
}
}
public void TestMethodCleanup()
{
try
{
localWFDController.CheckServicesManagerErrors();
remoteWFDController.CheckServicesManagerErrors();
}
catch (Exception ex)
{
WiFiDirectTestLogger.Error("Found error in Wi-Fi Direct Services manager: {0}", ex);
}
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Sending data ({6} char string) from socket with handle {0} on device {1} ({2}), expect received on socket with handle {3} on device {4} ({5})",
dataParameters.SenderSocketHandle,
senderWFDController.DeviceAddress,
senderWFDController.MachineName,
dataParameters.ReceiverSocketHandle,
receiverWFDController.DeviceAddress,
receiverWFDController.MachineName,
dataParameters.DataSize
);
// Generate message of "DataSize" characters
StringBuilder builder = new StringBuilder();
for (int i = 0; i < dataParameters.DataSize; i++)
{
builder.Append(s_chars[rng.Next(s_chars.Length)]);
}
string msg = builder.ToString();
senderWFDController.SendServiceSocketMessage(
dataParameters.SenderSessionHandle,
dataParameters.SenderSocketHandle,
msg
);
string rcv = receiverWFDController.ReceiveServiceSocketMessage(
dataParameters.ReceiverSessionHandle,
dataParameters.ReceiverSocketHandle
);
// Validate
if (msg != rcv)
{
WiFiDirectTestLogger.Error("Sent: '{0}', Received: '{1}'",
WiFiDirectTestUtilities.GetTruncatedString(msg, 32),
WiFiDirectTestUtilities.GetTruncatedString(rcv, 32)
);
throw new Exception("Received Message was not the same as expected!");
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service send data scenario: {0}", e);
}
}
private WfdDeviceDescriptor PerformWildcardDiscovery()
{
WfdDeviceDescriptor discoveredDeviceDescriptor = null;
//
// Perform the discovery
//
WiFiDirectTestLogger.Log("Performing wildcard discovery for device {0} ({1}) as {2}, Timeout: {3} ms, Discovery Type: {4}",
remoteWFDController.DeviceAddress,
remoteWFDController.MachineName,
GetFriendlyStringForDiscoveryScenarioType(discoveryScenarioType),
searchTimeoutMs,
GetFriendlyStringForDiscoverType(discoverType)
);
List <WfdDeviceDescriptor> discoveryResults = localWFDController.DiscoverDevices(searchTimeoutMs, discoverType);
WiFiDirectTestLogger.Log("Discovery returned {0} results.", discoveryResults == null ? 0 : discoveryResults.Count);
if (discoveryResults != null)
{
foreach (WfdDeviceDescriptor discoveryResult in discoveryResults)
{
if (discoveryResult.DeviceAddress == remoteWFDController.DeviceAddress)
{
WiFiDirectTestLogger.Log("Target device {0} ({1}) found in discovery results", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
if (discoveryScenarioType == DiscoveryScenarioType.DiscoverAsGo &&
!discoveryResult.GroupCapabilities.GroupOwner)
{
WiFiDirectTestLogger.Error("Expected to find device {0} ({1}) as a group owner, but there's no GO running on the device.", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
}
else
{
discoveredDeviceDescriptor = discoveryResult;
}
break;
}
}
}
if (discoveredDeviceDescriptor == null)
{
WiFiDirectTestLogger.Error("Target device {0} ({1}) not found.", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
}
return(discoveredDeviceDescriptor);
}
public LegacyPairingScenarioResult Execute()
{
try
{
ExecuteInternal();
this.scenarioSucceeded = true;
}
catch (Exception exception)
{
WiFiDirectTestLogger.Error("Caught exception while running legacy pairing scenario: {0}", exception);
}
return(new LegacyPairingScenarioResult(this.scenarioSucceeded));
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Starting open socket ({6} {7}) from session with handle {0} on device {1} ({2}), expect socket added on session with handle {3} on device {4} ({5})",
socketParameters.SenderSessionHandle,
senderWFDController.DeviceAddress,
senderWFDController.MachineName,
socketParameters.ReceiverSessionHandle,
receiverWFDController.DeviceAddress,
receiverWFDController.MachineName,
socketParameters.Protocol.ToString(),
socketParameters.Port
);
if (socketParameters.Protocol == WiFiDirectServiceIPProtocol.Tcp)
{
senderSocketHandle = senderWFDController.AddServiceStreamSocket(
socketParameters.SenderSessionHandle,
socketParameters.Port
);
receiverSocketHandle = receiverWFDController.GetServiceRemoteSocketAdded(
socketParameters.ReceiverSessionHandle
);
}
else if (socketParameters.Protocol == WiFiDirectServiceIPProtocol.Udp)
{
senderSocketHandle = senderWFDController.AddServiceDatagramSocket(
socketParameters.SenderSessionHandle,
socketParameters.Port
);
receiverSocketHandle = receiverWFDController.GetServiceRemoteSocketAdded(
socketParameters.ReceiverSessionHandle
);
}
else
{
throw new Exception("Unsupported Protocol!");
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service open socket scenario: {0}", e);
}
}
public void ConnectASPOverExistingP2PGroup()
{
using (RemoteControllerLogGroup lg = new RemoteControllerLogGroup(remoteWFDController))
{
// Start by doing WFD pairing
// NOTE: use invitation (not used for services) and config method push button (not used for services)
ExecutePairingScenario(PairingScenarioType.Invitation, DOT11_WPS_CONFIG_METHOD.DOT11_WPS_CONFIG_METHOD_PUSHBUTTON);
// Make sure we close this session on cleanup
needToCloseSession = true;
// Connect, auto accept
string serviceName = remoteWFDController.GenerateUniqueServiceName();
ServicesPublishDiscoverConnectParameters connectParams = new ServicesPublishDiscoverConnectParameters(
serviceName,
new ServicesConnectOptions(validateData: true)
);
var pairResults = ExecutePublishDiscoverConnectScenario(connectParams);
Verify.AreEqual(1, pairResults.ConnectResults.Count);
// Disconnect
ExecuteDisconnectScenario(
new ServicesDisconnectParameters(
pairResults.ConnectResults[0].AdvertiserSessionHandle,
pairResults.ConnectResults[0].SeekerSessionHandle
),
false
);
// WFD connection should stay up
WiFiDirectTestLogger.Log("Closed ASP Session, waiting to make sure WFD session stays active...");
Task.Delay(8000).Wait();
WfdGlobalSessionState globalSessionStateLocal = localWFDController.QueryGlobalSessionState();
if (globalSessionStateLocal.Sessions.Length != 1)
{
WiFiDirectTestLogger.Error("Expected a single active session. Current session count = {0}", globalSessionStateLocal.Sessions.Length);
throw new Exception("Local machine session is closed");
}
WiFiDirectTestUtilities.RunDataPathValidation(localWFDController, remoteWFDController, "6001");
// Close WFD connection
localWFDController.CloseSession();
needToCloseSession = false;
}
}
public List <WFDSvcWrapperHandle> WatchServices(string serviceName, string serviceInfo = "")
{
if (!watcher.HasExpectations())
{
WiFiDirectTestLogger.Error("Watcher needs expected services to run");
throw new Exception("Cannot use watcher without a condition to stop");
}
watcher.Start(serviceName, serviceInfo);
watcher.WaitForFindAll();
watcher.Stop();
List <WFDSvcWrapperHandle> results = discoveryCollection.Keys.ToList();
return(results);
}
private WfdDeviceDescriptor PerformTargetedDiscovery()
{
DOT11_WFD_DISCOVER_DEVICE_FILTER_BITMASK deviceFilterBitmask;
switch (discoveryScenarioType)
{
case DiscoveryScenarioType.DiscoverAsDevice:
deviceFilterBitmask = DOT11_WFD_DISCOVER_DEVICE_FILTER_BITMASK.Device;
break;
case DiscoveryScenarioType.DiscoverAsGo:
deviceFilterBitmask = DOT11_WFD_DISCOVER_DEVICE_FILTER_BITMASK.GO;
break;
default:
throw new Exception("Unable to map from discovery scenario type to discovery filter bitmask");
}
//
// Perform the discovery
//
WiFiDirectTestLogger.Log("Performing targetted discovery for device {0} ({1}) as {2}, Timeout: {3} ms, Discovery Type: {4}",
remoteWFDController.DeviceAddress,
remoteWFDController.MachineName,
GetFriendlyStringForDiscoveryScenarioType(discoveryScenarioType),
searchTimeoutMs,
GetFriendlyStringForDiscoverType(discoverType)
);
WfdDeviceDescriptor discoveredDeviceDescriptor = localWFDController.PerformTargetedDiscovery(
remoteWFDController.DeviceAddress,
deviceFilterBitmask,
searchTimeoutMs,
discoverType
);
if (discoveredDeviceDescriptor == null)
{
WiFiDirectTestLogger.Error("Target device {0} ({1}) not found.", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
}
return(discoveredDeviceDescriptor);
}
private bool PerformTargetedDiscovery()
{
DiscoveryScenarioType discoveryScenarioType;
switch (pairingScenarioType)
{
case PairingScenarioType.JoinExistingGo:
discoveryScenarioType = DiscoveryScenarioType.DiscoverAsGo;
break;
case PairingScenarioType.Invitation:
case PairingScenarioType.GoNegotiationDutBecomesGo:
case PairingScenarioType.GoNegotiationDutBecomesClient:
discoveryScenarioType = DiscoveryScenarioType.DiscoverAsDevice;
break;
default:
throw new Exception("Cannot map pairing scenario to discovery scenario.");
}
DiscoveryScenario discoveryScenario = new DiscoveryScenario(
localWFDController,
remoteWFDController,
discoveryScenarioType,
true, // isTargettedDiscovery
WFD_DISCOVER_TYPE.wfd_discover_type_auto,
pairingScenarioDiscoveryTimeoutMs,
false // discoverTestIe
);
DiscoveryScenarioResult discoveryScenarioResult = discoveryScenario.Execute();
if (!discoveryScenarioResult.ScenarioSucceeded)
{
WiFiDirectTestLogger.Error("Targetted discovery failed for device {0} ({1}). Aborting pairing operation.", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
}
return(discoveryScenarioResult.ScenarioSucceeded);
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Starting Unpublish for service with handle {0} on device {1} ({2})",
unpublishParameters.AdvertiserHandle,
advertisingWFDController.DeviceAddress,
advertisingWFDController.MachineName
);
advertisingWFDController.UnpublishService(
unpublishParameters.AdvertiserHandle,
unpublishParameters.Remove
);
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service unpublish scenario: {0}", e);
}
}
private bool VerifySessionState()
{
WfdGlobalSessionState globalSessionState = localWFDController.QueryGlobalSessionState();
if (globalSessionState.Sessions.Length != 1)
{
WiFiDirectTestLogger.Error("Expected a single active session. Current session count = {0}", globalSessionState.Sessions.Length);
return(false);
}
WFD_ROLE_TYPE expectedRole;
switch (pairingScenarioType)
{
case PairingScenarioType.Invitation:
case PairingScenarioType.GoNegotiationDutBecomesGo:
expectedRole = WFD_ROLE_TYPE.WFD_ROLE_TYPE_GROUP_OWNER;
break;
case PairingScenarioType.GoNegotiationDutBecomesClient:
case PairingScenarioType.JoinExistingGo:
expectedRole = WFD_ROLE_TYPE.WFD_ROLE_TYPE_CLIENT;
break;
default:
throw new Exception("Unable to map pairing scenario type to role type.");
}
if (globalSessionState.Sessions[0].Role != expectedRole)
{
WiFiDirectTestLogger.Error("DUT became the WFD {0}. Expected {1}", MapRoleToString(globalSessionState.Sessions[0].Role), MapRoleToString(expectedRole));
return(false);
}
return(true);
}
public static void RunDataPathValidation(WiFiDirectTestController localWFDController, WiFiDirectTestController remoteWFDController, string port = "5001")
{
// Close existing socket connections
localWFDController.ResetDataPathTester();
remoteWFDController.ResetDataPathTester();
// Turn off the listen state on the remote device before working with sockets.
remoteWFDController.ConfigureListenState(false);
remoteWFDController.StartStreamSocketListener(port);
localWFDController.ConnectStreamSocketAndSendGuid(port);
remoteWFDController.WaitForSocketConnectionReceived(); // Wait for the connection received callback to complete so the DataPathTestGuid is properly initialized
// Save GUID values to a local variable, to avoid having them change between the comparison and log prints below
Guid localTestGuid = localWFDController.DataPathTestGuid;
Guid remoteTestGuid = remoteWFDController.DataPathTestGuid;
if (remoteTestGuid != localTestGuid)
{
WiFiDirectTestLogger.Error("Received GUID value of {0} did not match transmitted value of {1}", remoteTestGuid, localTestGuid);
return;
}
WiFiDirectTestLogger.Log("Validated transmitted and received GUID values match.");
}
private void ExecuteInternal()
{
try
{
WiFiDirectTestLogger.Log(
"Beginning Connect Scenario from Discovery Handle {0} to Advertiser {1}. GetProvisioning={2}, ValidateData={3}",
connectParameters.DiscoveryHandle,
connectParameters.AdvertiserHandle,
connectParameters.Options.CallGetProvisioningInfo,
connectParameters.Options.ValidateData
);
string pin = "";
// Get the current session counts
int advertiserCountBefore = advertiserWFDController.GetServiceSessionCount();
int seekerCountBefore = seekerWFDController.GetServiceSessionCount();
// Set any options (like prefer GO)
// This also calls OpenSession()
if (connectParameters.Options.DeclineConnect)
{
if (!connectParameters.Options.CallGetProvisioningInfo ||
connectParameters.Options.ExpectConnectSuccess)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Bad test case, decline connection should call get provisioning info and expect failure"
));
}
advertiserWFDController.DeclineNextServiceConnectionRequest(connectParameters.AdvertiserHandle);
}
if (!connectParameters.Options.ExpectAdvertiserConnectSuccess)
{
advertiserWFDController.ExpectNextServiceConnectionRequestFailure(connectParameters.AdvertiserHandle);
}
Stopwatch openSessionStopwatch = new Stopwatch();
openSessionStopwatch.Start();
seekerWFDController.SetServiceOptions(
connectParameters.DiscoveryHandle,
connectParameters.Options.PreferGO,
connectParameters.Options.SessionInfo
);
openSessionStopwatch.Stop();
WiFiDirectTestLogger.Log("OpenSession completed in {0} ms.", openSessionStopwatch.ElapsedMilliseconds);
// Optionally GetProvisioningInfo before doing a PIN connection
if (connectParameters.Options.CallGetProvisioningInfo)
{
ProvisioningInfoWrapper provisioningInfo = null;
Stopwatch provDiscStopwatch = new Stopwatch();
// Handle expected failures in GetProvisioningInfo
try
{
provDiscStopwatch.Start();
provisioningInfo = seekerWFDController.GetServiceProvisioningInfo(
connectParameters.DiscoveryHandle,
connectParameters.Options.PreferredConfigMethod
);
}
catch (Exception e)
{
if (connectParameters.Options.ExpectGetProvisioningSuccess)
{
throw;
}
else
{
WiFiDirectTestLogger.Log("Caught expected exception in GetProvisioningInfo: {0}", e.Message);
if (connectParameters.Options.DeclineConnect)
{
advertiserWFDController.CheckAdvertiserLastSessionDeclined(connectParameters.AdvertiserHandle);
}
succeeded = true;
return;
}
}
finally
{
provDiscStopwatch.Stop();
WiFiDirectTestLogger.Log("GetServiceProvisioningInfo completed in {0} ms.", provDiscStopwatch.ElapsedMilliseconds);
if (succeeded && connectParameters.Options.DeclineConnect)
{
// 30 seconds is much more time than actually needed
if (provDiscStopwatch.ElapsedMilliseconds > 30000)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Expected decline to fail connect before 2 minute timeout, took too long, decline did not succeed properly"
));
}
}
}
if (!connectParameters.Options.ExpectGetProvisioningSuccess)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Expected GetProvisioningInfo to fail"
));
}
if (provisioningInfo.IsGroupFormationNeeded != connectParameters.Options.ExpectGroupFormationNeeded)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Expected Group Formation {0}, Actual Group Formation {1}",
(connectParameters.Options.ExpectGroupFormationNeeded) ? "Needed" : "Not Needed",
(provisioningInfo.IsGroupFormationNeeded) ? "Needed" : "Not Needed"
));
}
if (provisioningInfo.IsGroupFormationNeeded &&
provisioningInfo.SelectedConfigMethod != WiFiDirectServiceConfigurationMethod.Default)
{
if (provisioningInfo.SelectedConfigMethod == WiFiDirectServiceConfigurationMethod.PinDisplay)
{
// Seeker should have generated a PIN, now advertiser can enter the PIN
pin = seekerWFDController.GetServiceDisplayedPin();
advertiserWFDController.EnterServicesPin(pin);
}
else
{
// Advertiser will generate/display PIN, enter on seeker side before connecting
pin = advertiserWFDController.GetServiceDisplayedPin();
seekerWFDController.EnterServicesPin(pin);
}
}
WiFiDirectTestLogger.Log("Get Provisioning Info complete, using PIN: {0}", pin);
}
// Some tests will validate that this works even if there is a time delay from provisioning info available on seeker to calling connect
// Add a sleep here if that is the case
if (connectParameters.Options.DelaySeekerConnectCall)
{
// 5 seconds should be long enough for advertiser to attempt the connect before seeker is ready
Task.Delay(5000).Wait();
}
// Now do the real connect
Stopwatch connectStopwatch = new Stopwatch();
// Handle expected failures in ConnectService
try
{
connectStopwatch.Start();
seekerSessionHandle = seekerWFDController.ConnectService(
connectParameters.DiscoveryHandle
);
}
catch (Exception e)
{
if (connectParameters.Options.ExpectConnectSuccess)
{
throw;
}
else
{
WiFiDirectTestLogger.Log("Caught expected exception in ConnectService: {0}", e.Message);
succeeded = true;
return;
}
}
finally
{
connectStopwatch.Stop();
WiFiDirectTestLogger.Log("Connect completed in {0} ms.", connectStopwatch.ElapsedMilliseconds);
if (!connectParameters.Options.ExpectAdvertiserConnectSuccess)
{
advertiserWFDController.CheckAdvertiserLastSessionFailed(connectParameters.AdvertiserHandle);
}
if (succeeded && connectParameters.Options.DeclineConnect)
{
// 30 seconds is much more time than actually needed
if (connectStopwatch.ElapsedMilliseconds > 30000)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Expected decline to fail connect before 2 minute timeout, took too long, decline did not succeed properly"
));
}
}
}
if (!connectParameters.Options.ExpectConnectSuccess)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Expected Connect to fail"
));
}
// Advertiser should have gotten the connection
advertiserSessionHandle = advertiserWFDController.GetAdvertiserLastSession(
connectParameters.AdvertiserHandle,
pin.Length == 0 // autoAccept
);
ServiceSessionInfo advertiserSession = advertiserWFDController.GetServiceSessionInfo(advertiserSessionHandle);
if (advertiserSession.Status != WiFiDirectServiceSessionStatus.Open)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Advertiser session is not open (Status={0}, ErrorStatus={1})",
advertiserSession.Status,
advertiserSession.ErrorStatus
));
}
if (connectParameters.Options.SessionInfo.Length > 0 &&
connectParameters.Options.SessionInfo != advertiserSession.DeferredSessionInfo)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Advertiser and Seeker session info mismatch! (Seeker={0}) (Advertiser={1})",
WiFiDirectTestUtilities.GetTruncatedString(connectParameters.Options.SessionInfo),
WiFiDirectTestUtilities.GetTruncatedString(advertiserSession.DeferredSessionInfo)
));
}
ServiceSessionInfo seekerSession = seekerWFDController.GetServiceSessionInfo(seekerSessionHandle);
// Compare sessions for correct data
if (advertiserSession.ServiceName != seekerSession.ServiceName ||
advertiserSession.AdvertisementId != seekerSession.AdvertisementId ||
advertiserSession.ServiceAddress != seekerSession.ServiceAddress ||
advertiserSession.SessionAddress != seekerSession.SessionAddress ||
advertiserSession.SessionId != seekerSession.SessionId)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Advertiser and Seeker session mismatch! (Seeker={0}) (Advertiser={1})",
seekerSession.ToString(),
advertiserSession.ToString()
));
}
if (connectParameters.Options.ExpectDeferred)
{
seekerWFDController.CheckServiceSessionDeferred(seekerSessionHandle, true);
var advertiserInfo = advertiserWFDController.GetAdvertiserInfo(connectParameters.AdvertiserHandle);
if (advertiserInfo.DeferredSessionInfo.Length > 0 &&
seekerSession.DeferredSessionInfo != advertiserInfo.DeferredSessionInfo)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Advertiser and Seeker deferred session info mismatch! (Seeker={0}) (Advertiser={1})",
WiFiDirectTestUtilities.GetTruncatedString(seekerSession.DeferredSessionInfo),
WiFiDirectTestUtilities.GetTruncatedString(advertiserInfo.DeferredSessionInfo)
));
}
}
else
{
seekerWFDController.CheckServiceSessionDeferred(seekerSessionHandle, false);
if (seekerSession.DeferredSessionInfo != "")
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Seeker Received Deferred Session info, was not deferred session! (Session Info={0})",
WiFiDirectTestUtilities.GetTruncatedString(seekerSession.DeferredSessionInfo)
));
}
}
// Check that we added 1 session to each side
int advertiserCountAfter = advertiserWFDController.GetServiceSessionCount();
int seekerCountAfter = seekerWFDController.GetServiceSessionCount();
if (advertiserCountBefore + 1 != advertiserCountAfter ||
seekerCountBefore + 1 != seekerCountAfter)
{
throw new Exception(String.Format(
CultureInfo.InvariantCulture,
"Expected 1 new session on each side! (Seeker {0} -> {1}, Advertiser {2} -> {3})",
seekerCountBefore,
seekerCountAfter,
advertiserCountBefore,
advertiserCountAfter
));
}
if (connectParameters.Options.ValidateData)
{
var dataScenario = new ServicesOpenSocketSendDataScenario(
seekerWFDController,
advertiserWFDController,
new ServicesOpenSocketSendDataParameters(
seekerSessionHandle,
advertiserSessionHandle,
WiFiDirectServiceIPProtocol.Tcp,
validationPort++,
65536
)
);
validateDataResults = dataScenario.Execute();
if (!validateDataResults.ScenarioSucceeded)
{
throw new Exception("Failed data validation!");
}
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service connect scenario: {0}", e);
}
}
private void DoFindAllDiscovery()
{
Stopwatch discoveryStopwatch = new Stopwatch();
discoveryStopwatch.Start();
discoveryHandles = discoveryTestController.DiscoverServices(
discoveryParameters.Query,
discoveryParameters.ExpectedMatchCount > 0,
discoveryParameters.ServiceInfoRequest
);
discoveryStopwatch.Stop();
WiFiDirectTestLogger.Log("Services Discovery (FindAllAsync) completed in {0} ms.", discoveryStopwatch.ElapsedMilliseconds);
if (discoveryHandles.Count != discoveryParameters.ExpectedMatchCount)
{
WiFiDirectTestLogger.Error(
"Expected {0} devices but discovered {1} devices",
discoveryParameters.ExpectedMatchCount,
discoveryHandles.Count
);
return;
}
if (discoveryHandles.Count > 0 &&
discoveryParameters.AdvertisersToMatch != null &&
discoveryParameters.AdvertisersToMatch.Count > 0)
{
WiFiDirectTestLogger.Log("Checking discovery results for expected services");
bool foundAll = true;
IList <DiscoveredServiceInfo> discoveredDevices = new List <DiscoveredServiceInfo>();
foreach (var handle in discoveryHandles)
{
DiscoveredServiceInfo discovery = discoveryTestController.GetDiscoveredServiceInfo(handle);
discoveredDevices.Add(discovery);
WiFiDirectTestLogger.Log(
"Discovered service: {0} with address: {1}",
discovery.ServiceName,
discovery.ServiceAddress.ToString()
);
}
int adIdx = 0;
foreach (var handle in discoveryParameters.AdvertisersToMatch)
{
ServiceAdvertiserInfo advertiser = advertiserTestController.GetAdvertiserInfo(handle);
bool found = false;
// Check discovered list for match, remove
for (int i = 0; i < discoveredDevices.Count; i++)
{
if (advertiser.ServiceName == discoveredDevices[i].ServiceName &&
advertiser.ServiceAddress == discoveredDevices[i].ServiceAddress)
{
WiFiDirectTestLogger.Log(
"Found Expected Service: {0} with address: {1}",
discoveredDevices[i].ServiceName,
discoveredDevices[i].ServiceAddress.ToString()
);
if (discoveryParameters.AdvertiserServiceInfoMatch != null &&
discoveryParameters.AdvertiserServiceInfoMatch.Count >= adIdx)
{
if (discoveryParameters.AdvertiserServiceInfoMatch[adIdx])
{
WiFiDirectTestLogger.Log(
"Expecting Service Info:\n\t{0}\nReceived:\n\t{1}",
WiFiDirectTestUtilities.GetTruncatedString(advertiser.ServiceInfo, 32),
WiFiDirectTestUtilities.GetTruncatedString(discoveredDevices[i].ServiceInfo, 32)
);
if (advertiser.ServiceInfo != discoveredDevices[i].ServiceInfo)
{
// Allow multiple services with same name/different service info
// Skip if service info match fails, will fail if no service info found
continue;
}
}
else
{
WiFiDirectTestLogger.Log(
"Expecting No Service Info, Received:\n\t{0}",
WiFiDirectTestUtilities.GetTruncatedString(discoveredDevices[i].ServiceInfo, 32)
);
if ("" != discoveredDevices[i].ServiceInfo)
{
// Allow multiple services with same name/different service info
// Skip if service info match fails, will fail if no service info found
continue;
}
}
}
discoveredDevices.RemoveAt(i);
found = true;
break;
}
}
if (!found)
{
WiFiDirectTestLogger.Error(
"Did NOT Find Expected Service: {0} with address: {1}",
advertiser.ServiceName,
advertiser.ServiceAddress.ToString()
);
foundAll = false;
// Continue checking complete list
}
adIdx++;
}
if (discoveredDevices.Count > 0)
{
WiFiDirectTestLogger.Error("Found unexpected services!");
foundAll = false;
}
if (!foundAll)
{
return;
}
}
succeeded = true;
}
private void ExecuteInternal()
{
try
{
if (discoverTestIe)
{
remoteWFDController.SetTestIe();
}
if (discoveryScenarioType == DiscoveryScenarioType.DiscoverAsDevice)
{
// Enable listen state on the remote device if it is not already enabled.
remoteWFDController.ConfigureListenState(true);
}
else if (discoveryScenarioType == DiscoveryScenarioType.DiscoverAsGo)
{
// Start autonomous GO on the remote device if it is not already running
remoteWFDController.StartAutonomousGo();
}
// Flush the visible device list on the local device
localWFDController.FlushVisibleDeviceList();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
WfdDeviceDescriptor discoveredDeviceDescriptor;
if (isTargetedDiscovery)
{
discoveredDeviceDescriptor = PerformTargetedDiscovery();
}
else
{
discoveredDeviceDescriptor = PerformWildcardDiscovery();
}
if (discoveredDeviceDescriptor == null)
{
return;
}
WiFiDirectTestLogger.Log("Successfully discovered device {0} ({1})", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
stopwatch.Stop();
WiFiDirectTestLogger.Log("Discovery completed in {0} ms.", stopwatch.ElapsedMilliseconds);
if (discoverTestIe)
{
Guid discoveredGuid;
bool parsed = TestIeManager.TryParseIeBuffer(discoveredDeviceDescriptor.IE, out discoveredGuid);
if (!parsed)
{
WiFiDirectTestLogger.Error("Expected vendor extension IE not present in discovery result.");
return;
}
if (discoveredGuid == remoteWFDController.CurrentIEGuid)
{
WiFiDirectTestLogger.Log("Validated expected GUID {0} is present in vendor extension IE.", discoveredGuid);
}
else
{
WiFiDirectTestLogger.Error("Found incorrect GUID in vendor extension IE. Expected: {0}, Found: {1}", remoteWFDController.CurrentIEGuid, discoveredGuid);
return;
}
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while running discovery scenario: {0}", e);
}
}
private void ExecuteInternal()
{
try
{
var openSocketScenario = new ServicesOpenSocketScenario(
senderWFDController,
receiverWFDController,
new ServicesOpenSocketParameters(
socketDataParameters.SenderSessionHandle,
socketDataParameters.ReceiverSessionHandle,
socketDataParameters.Protocol,
socketDataParameters.Port
)
);
openSocketResult = openSocketScenario.Execute();
if (!openSocketResult.ScenarioSucceeded)
{
throw new Exception("Open Socket failed!");
}
ServicesSendDataScenario sendDataScenario = null;
if (socketDataParameters.Protocol == WiFiDirectServiceIPProtocol.Tcp)
{
sendDataScenario = new ServicesSendDataScenario(
senderWFDController,
receiverWFDController,
new ServicesSendDataParameters(
socketDataParameters.SenderSessionHandle,
openSocketResult.SenderSocketHandle,
socketDataParameters.ReceiverSessionHandle,
openSocketResult.ReceiverSocketHandle,
socketDataParameters.DataSize
)
);
}
else
{
// special case for UDP, just send on the opposite side for now
sendDataScenario = new ServicesSendDataScenario(
receiverWFDController,
senderWFDController,
new ServicesSendDataParameters(
socketDataParameters.ReceiverSessionHandle,
openSocketResult.ReceiverSocketHandle,
socketDataParameters.SenderSessionHandle,
openSocketResult.SenderSocketHandle,
socketDataParameters.DataSize
)
);
}
ServicesSendDataScenarioResult sendDataResult = sendDataScenario.Execute();
if (!sendDataResult.ScenarioSucceeded)
{
throw new Exception("Send Data failed!");
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing service open socket scenario: {0}", e);
}
}
public async Task <AsyncHandleListResult> DiscoverServicesAsync(string serviceName, bool fExpectResults = true, string serviceInfo = "")
{
List <WFDSvcWrapperHandle> results = new List <WFDSvcWrapperHandle>();
Exception error = null;
bool success = false;
try
{
ThrowIfDisposed();
WiFiDirectTestLogger.Log("Discover Services... (ServiceName={0}, ServiceInfo={1})", serviceName, serviceInfo);
string serviceSelector = "";
if (serviceInfo == "")
{
serviceSelector = WiFiDirectService.GetSelector(serviceName);
}
else
{
using (var serviceInfoDataWriter = new Windows.Storage.Streams.DataWriter(new Windows.Storage.Streams.InMemoryRandomAccessStream()))
{
serviceInfoDataWriter.WriteString(serviceInfo);
serviceSelector = WiFiDirectService.GetSelector(serviceName, serviceInfoDataWriter.DetachBuffer());
}
}
WiFiDirectTestLogger.Log("FindAllAsync... Using Selector: {0}", serviceSelector);
List <string> additionalProperties = new List <string>();
additionalProperties.Add("System.Devices.WiFiDirectServices.ServiceAddress");
additionalProperties.Add("System.Devices.WiFiDirectServices.ServiceName");
additionalProperties.Add("System.Devices.WiFiDirectServices.ServiceInformation");
additionalProperties.Add("System.Devices.WiFiDirectServices.AdvertisementId");
additionalProperties.Add("System.Devices.WiFiDirectServices.ServiceConfigMethods");
DeviceInformationCollection deviceInfoCollection = await DeviceInformation.FindAllAsync(serviceSelector, additionalProperties);
WiFiDirectTestLogger.Log(
"FindAllAsync...DONE Got {0} results",
(deviceInfoCollection == null) ? 0 : deviceInfoCollection.Count
);
if (deviceInfoCollection == null || deviceInfoCollection.Count == 0)
{
if (fExpectResults)
{
WiFiDirectTestLogger.Error("No services found!");
throw new Exception("Expected services discovered, found none!");
}
else
{
WiFiDirectTestLogger.Log("No services found (expected)");
}
}
else
{
if (!fExpectResults)
{
WiFiDirectTestLogger.Error("Services found, none expected!");
throw new Exception("Expected no services discovered, found at least 1!");
}
else
{
// NOTE: we don't clear this list
// Possible to discover A, discover B, then connect to A because its entry still exists
foreach (DeviceInformation deviceInfo in deviceInfoCollection)
{
WiFiDirectTestLogger.Log(
"Adding discovered service (Id={0}, Name={1})",
deviceInfo.Id,
deviceInfo.Name
);
DiscoveredService discovered = new DiscoveredService(deviceInfo, this, this, this);
discoveryCollection.Add(discovered.Handle, discovered);
results.Add(discovered.Handle);
}
}
}
success = true;
}
catch (Exception ex)
{
WiFiDirectTestLogger.Error("Exception in DiscoverServicesAsync");
error = ex;
}
return(new AsyncHandleListResult(results, success, error));
}
private void ExecuteInternal()
{
try
{
// For non-pushbutton pairing, generate a new passkey and make sure both test controllers have it.
if (configMethod != DOT11_WPS_CONFIG_METHOD.DOT11_WPS_CONFIG_METHOD_PUSHBUTTON)
{
remoteWFDController.PassKey = localWFDController.GenerateAndStoreNewPassKey();
}
// Prepare the remote device to receive the connection request.
remoteWFDController.AcceptNextGroupRequest(
localWFDController.DeviceAddress,
(pairingScenarioType == PairingScenarioType.GoNegotiationDutBecomesGo) ? ((byte)0) : ((byte)14),
GetAcceptConfigMethod()
);
// Begin by performing a targeted discovery for the remote device.
bool discoverySucceeded = PerformTargetedDiscovery();
if (!discoverySucceeded)
{
return;
}
WFD_PAIR_WITH_DEVICE_PREFERENCE pairWithDevicePreference;
switch (this.pairingScenarioType)
{
case PairingScenarioType.JoinExistingGo:
pairWithDevicePreference = WFD_PAIR_WITH_DEVICE_PREFERENCE.WFD_PAIRING_PREFER_NONE;
break;
case PairingScenarioType.Invitation:
pairWithDevicePreference = WFD_PAIR_WITH_DEVICE_PREFERENCE.WFD_PAIRING_PREFER_INVITATION;
break;
case PairingScenarioType.GoNegotiationDutBecomesGo:
case PairingScenarioType.GoNegotiationDutBecomesClient:
pairWithDevicePreference = WFD_PAIR_WITH_DEVICE_PREFERENCE.WFD_PAIRING_PREFER_GO_NEGOTIATION;
break;
default:
throw new Exception("Cannot map pairing scenario to pairing preference.");
}
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
// Pair with the target device.
WiFiDirectTestLogger.Log("Starting pairing with device {0} ({1})", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
localWFDController.PairWithDevice(
remoteWFDController.DeviceAddress,
pairWithDevicePreference,
(pairingScenarioType == PairingScenarioType.GoNegotiationDutBecomesClient) ? ((byte)0) : ((byte)14),
configMethod,
isPersistent
);
WiFiDirectTestLogger.Log("Pairing successful", remoteWFDController.DeviceAddress, remoteWFDController.MachineName);
stopwatch.Stop();
WiFiDirectTestLogger.Log("Pairing completed in {0} ms.", stopwatch.ElapsedMilliseconds);
bool sessionStateValid = VerifySessionState();
if (!sessionStateValid)
{
return;
}
if (this.runDataPathValidation)
{
WiFiDirectTestUtilities.RunDataPathValidation(localWFDController, remoteWFDController);
}
succeeded = true;
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while executing pairing scenario: {0}", e);
}
}
public void ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
try
{
lock (this.criticalSection)
{
StreamSocket streamSocket = args.Socket;
try
{
if (streamSocket.Information.RemoteAddress.IsEqual(this.expectedRemoteHost))
{
WiFiDirectTestLogger.Log("Connection received from {0}", streamSocket.Information.RemoteAddress);
this.streamSocketListener.Dispose();
this.streamSocketListener = null;
this.streamSocket = streamSocket;
streamSocket = null;
}
else
{
WiFiDirectTestLogger.Log("Closing unexpected connection received from {0}", streamSocket.Information.RemoteAddress);
}
}
finally
{
if (streamSocket != null)
{
streamSocket.Dispose();
}
}
if (this.streamSocket == null)
{
return;
}
using (DataReader dataReader = new DataReader(this.streamSocket.InputStream))
{
WiFiDirectTestLogger.Log("Waiting to receive GUID value {0}", this.streamSocket.Information.RemoteAddress);
Task readTask = dataReader.LoadAsync(16U).AsTask();
bool readComplete = readTask.Wait(new TimeSpan(0, 0, 1));
if (readComplete)
{
this.guidInternal = dataReader.ReadGuid();
WiFiDirectTestLogger.Log("Received GUID value {0}", this.guidInternal);
}
else
{
WiFiDirectTestLogger.Log("Timed out waiting for GUID value");
}
}
}
connectionReceivedCallbackCallbackEvent.Set();
}
catch (Exception e)
{
WiFiDirectTestLogger.Error("Caught exception while handling connection received event. {0}", e);
throw;
}
}
