public static IDisposable StartService(TestDetails testDetails, TestCallbackHandler testCallback)
        {
            if (_currentService != null)
            {
                _currentService.Dispose();
                _currentService = null;
            }

            _currentCallback = testCallback;
            _testDetails = testDetails;

            ServiceHost host = new ServiceHost(typeof(TestCallbackService));
            try
            {
                var binding = new NetNamedPipeBinding();
                binding.MaxReceivedMessageSize = 100000;
                host.AddServiceEndpoint(typeof(ITestCallbackService), binding, new Uri(ServiceAddress));
                host.Open();
            }
            catch (Exception)
            {
                ((IDisposable)host).Dispose();
                _currentCallback = null;
                throw;
            }
            return new ServiceWrapper(host);
        }
Example #2
0
        private async Task<MethodInfo> FindMethodToRunAsync(TestDetails details, List<Assembly> newAssemblies)
        {
            return await TaskEx.Run(() =>
            {
                Type methodType = null;
                foreach (var assembly in newAssemblies)
                {
                    methodType = assembly.GetType(details.TypeName);
                    if (methodType != null)
                        break;
                }

                if (methodType != null)
                {
                    // var methodType = Type.GetType(details.TypeName);
                    return methodType.GetMethod(details.MethodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

                }
                return null;
            });
        }
Example #3
0
        private Task<ResolveEventHandler> LoadAssembliesAsync(TestDetails details, List<Assembly> newAssemblies)
        {
            return TaskEx.Run(
                () =>
                {
                    string thisAssembly = GetType().Assembly.FullName;
                    string thisAssemblyLocation = GetType().Assembly.Location;
                    ResolveEventHandler resolveAction = (o, eventArgs) =>
                        {
                        // If the assembly name matches, then use the dll....

                        if (eventArgs.Name == thisAssembly)
                        {
                            return Assembly.LoadFrom(thisAssemblyLocation);
                        }

                        var matchingRef = details.AssembliesToLoad
                            .FirstOrDefault(
                                x => x.AssemblyName == eventArgs.Name);

                        if (matchingRef != null)
                        {
                            if (
                                string.IsNullOrWhiteSpace(
                                    matchingRef.FileName))
                            {
                                return
                                    Assembly.Load(matchingRef.AssemblyName);
                            }
                            else
                            {
                                return
                                    Assembly.LoadFrom(matchingRef.FileName);
                            }
                        }
                        return null;
                    };

                    AppDomain.CurrentDomain.AssemblyResolve += resolveAction;

                    // Load current assembly
                    Assembly.LoadFrom(GetType().Assembly.Location);


                    if (details.AssembliesToLoad != null)
                    {
                        foreach (var assemblyName in details.AssembliesToLoad)
                        {
                            if (string.IsNullOrWhiteSpace(assemblyName.FileName))
                            {
                                Assembly.Load(assemblyName.AssemblyName);
                            }
                            else
                            {
                                var assembly = Assembly.LoadFrom(assemblyName.FileName);

                                newAssemblies.Add(assembly);
                            }
                        }
                    }

                    return resolveAction;
                });
        }